1 #include <linux/libata.h>
2 #include <linux/cdrom.h>
3 #include <linux/pm_runtime.h>
4 #include <linux/module.h>
5 #include <linux/pm_qos.h>
6 #include <scsi/scsi_device.h>
7
8 #include "libata.h"
9
10 static int zpodd_poweroff_delay = 30; /* 30 seconds for power off delay */
11 module_param(zpodd_poweroff_delay, int, 0644);
12 MODULE_PARM_DESC(zpodd_poweroff_delay, "Poweroff delay for ZPODD in seconds");
13
14 enum odd_mech_type {
15 ODD_MECH_TYPE_SLOT,
16 ODD_MECH_TYPE_DRAWER,
17 ODD_MECH_TYPE_UNSUPPORTED,
18 };
19
20 struct zpodd {
21 enum odd_mech_type mech_type; /* init during probe, RO afterwards */
22 struct ata_device *dev;
23
24 /* The following fields are synchronized by PM core. */
25 bool from_notify; /* resumed as a result of
26 * acpi wake notification */
27 bool zp_ready; /* ZP ready state */
28 unsigned long last_ready; /* last ZP ready timestamp */
29 bool zp_sampled; /* ZP ready state sampled */
30 bool powered_off; /* ODD is powered off
31 * during suspend */
32 };
33
eject_tray(struct ata_device * dev)34 static int eject_tray(struct ata_device *dev)
35 {
36 struct ata_taskfile tf;
37 static const char cdb[ATAPI_CDB_LEN] = { GPCMD_START_STOP_UNIT,
38 0, 0, 0,
39 0x02, /* LoEj */
40 0, 0, 0, 0, 0, 0, 0,
41 };
42
43 ata_tf_init(dev, &tf);
44 tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
45 tf.command = ATA_CMD_PACKET;
46 tf.protocol = ATAPI_PROT_NODATA;
47
48 return ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
49 }
50
51 /* Per the spec, only slot type and drawer type ODD can be supported */
zpodd_get_mech_type(struct ata_device * dev)52 static enum odd_mech_type zpodd_get_mech_type(struct ata_device *dev)
53 {
54 char *buf;
55 unsigned int ret;
56 struct rm_feature_desc *desc;
57 struct ata_taskfile tf;
58 static const char cdb[ATAPI_CDB_LEN] = { GPCMD_GET_CONFIGURATION,
59 2, /* only 1 feature descriptor requested */
60 0, 3, /* 3, removable medium feature */
61 0, 0, 0,/* reserved */
62 0, 16,
63 0, 0, 0,
64 };
65
66 buf = kzalloc(16, GFP_KERNEL);
67 if (!buf)
68 return ODD_MECH_TYPE_UNSUPPORTED;
69 desc = (void *)(buf + 8);
70
71 ata_tf_init(dev, &tf);
72 tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
73 tf.command = ATA_CMD_PACKET;
74 tf.protocol = ATAPI_PROT_PIO;
75 tf.lbam = 16;
76
77 ret = ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
78 buf, 16, 0);
79 if (ret) {
80 kfree(buf);
81 return ODD_MECH_TYPE_UNSUPPORTED;
82 }
83
84 if (be16_to_cpu(desc->feature_code) != 3) {
85 kfree(buf);
86 return ODD_MECH_TYPE_UNSUPPORTED;
87 }
88
89 if (desc->mech_type == 0 && desc->load == 0 && desc->eject == 1) {
90 kfree(buf);
91 return ODD_MECH_TYPE_SLOT;
92 } else if (desc->mech_type == 1 && desc->load == 0 &&
93 desc->eject == 1) {
94 kfree(buf);
95 return ODD_MECH_TYPE_DRAWER;
96 } else {
97 kfree(buf);
98 return ODD_MECH_TYPE_UNSUPPORTED;
99 }
100 }
101
102 /* Test if ODD is zero power ready by sense code */
zpready(struct ata_device * dev)103 static bool zpready(struct ata_device *dev)
104 {
105 u8 sense_key, *sense_buf;
106 unsigned int ret, asc, ascq, add_len;
107 struct zpodd *zpodd = dev->zpodd;
108
109 ret = atapi_eh_tur(dev, &sense_key);
110
111 if (!ret || sense_key != NOT_READY)
112 return false;
113
114 sense_buf = dev->link->ap->sector_buf;
115 ret = atapi_eh_request_sense(dev, sense_buf, sense_key);
116 if (ret)
117 return false;
118
119 /* sense valid */
120 if ((sense_buf[0] & 0x7f) != 0x70)
121 return false;
122
123 add_len = sense_buf[7];
124 /* has asc and ascq */
125 if (add_len < 6)
126 return false;
127
128 asc = sense_buf[12];
129 ascq = sense_buf[13];
130
131 if (zpodd->mech_type == ODD_MECH_TYPE_SLOT)
132 /* no media inside */
133 return asc == 0x3a;
134 else
135 /* no media inside and door closed */
136 return asc == 0x3a && ascq == 0x01;
137 }
138
139 /*
140 * Update the zpodd->zp_ready field. This field will only be set
141 * if the ODD has stayed in ZP ready state for zpodd_poweroff_delay
142 * time, and will be used to decide if power off is allowed. If it
143 * is set, it will be cleared during resume from powered off state.
144 */
zpodd_on_suspend(struct ata_device * dev)145 void zpodd_on_suspend(struct ata_device *dev)
146 {
147 struct zpodd *zpodd = dev->zpodd;
148 unsigned long expires;
149
150 if (!zpready(dev)) {
151 zpodd->zp_sampled = false;
152 zpodd->zp_ready = false;
153 return;
154 }
155
156 if (!zpodd->zp_sampled) {
157 zpodd->zp_sampled = true;
158 zpodd->last_ready = jiffies;
159 return;
160 }
161
162 expires = zpodd->last_ready +
163 msecs_to_jiffies(zpodd_poweroff_delay * 1000);
164 if (time_before(jiffies, expires))
165 return;
166
167 zpodd->zp_ready = true;
168 }
169
zpodd_zpready(struct ata_device * dev)170 bool zpodd_zpready(struct ata_device *dev)
171 {
172 struct zpodd *zpodd = dev->zpodd;
173 return zpodd->zp_ready;
174 }
175
176 /*
177 * Enable runtime wake capability through ACPI and set the powered_off flag,
178 * this flag will be used during resume to decide what operations are needed
179 * to take.
180 *
181 * Also, media poll needs to be silenced, so that it doesn't bring the ODD
182 * back to full power state every few seconds.
183 */
zpodd_enable_run_wake(struct ata_device * dev)184 void zpodd_enable_run_wake(struct ata_device *dev)
185 {
186 struct zpodd *zpodd = dev->zpodd;
187
188 sdev_disable_disk_events(dev->sdev);
189
190 zpodd->powered_off = true;
191 device_set_run_wake(&dev->tdev, true);
192 acpi_pm_device_run_wake(&dev->tdev, true);
193 }
194
195 /* Disable runtime wake capability if it is enabled */
zpodd_disable_run_wake(struct ata_device * dev)196 void zpodd_disable_run_wake(struct ata_device *dev)
197 {
198 struct zpodd *zpodd = dev->zpodd;
199
200 if (zpodd->powered_off) {
201 acpi_pm_device_run_wake(&dev->tdev, false);
202 device_set_run_wake(&dev->tdev, false);
203 }
204 }
205
206 /*
207 * Post power on processing after the ODD has been recovered. If the
208 * ODD wasn't powered off during suspend, it doesn't do anything.
209 *
210 * For drawer type ODD, if it is powered on due to user pressed the
211 * eject button, the tray needs to be ejected. This can only be done
212 * after the ODD has been recovered, i.e. link is initialized and
213 * device is able to process NON_DATA PIO command, as eject needs to
214 * send command for the ODD to process.
215 *
216 * The from_notify flag set in wake notification handler function
217 * zpodd_wake_dev represents if power on is due to user's action.
218 *
219 * For both types of ODD, several fields need to be reset.
220 */
zpodd_post_poweron(struct ata_device * dev)221 void zpodd_post_poweron(struct ata_device *dev)
222 {
223 struct zpodd *zpodd = dev->zpodd;
224
225 if (!zpodd->powered_off)
226 return;
227
228 zpodd->powered_off = false;
229
230 if (zpodd->from_notify) {
231 zpodd->from_notify = false;
232 if (zpodd->mech_type == ODD_MECH_TYPE_DRAWER)
233 eject_tray(dev);
234 }
235
236 zpodd->zp_sampled = false;
237 zpodd->zp_ready = false;
238
239 sdev_enable_disk_events(dev->sdev);
240 }
241
zpodd_wake_dev(acpi_handle handle,u32 event,void * context)242 static void zpodd_wake_dev(acpi_handle handle, u32 event, void *context)
243 {
244 struct ata_device *ata_dev = context;
245 struct zpodd *zpodd = ata_dev->zpodd;
246 struct device *dev = &ata_dev->sdev->sdev_gendev;
247
248 if (event == ACPI_NOTIFY_DEVICE_WAKE && pm_runtime_suspended(dev)) {
249 zpodd->from_notify = true;
250 pm_runtime_resume(dev);
251 }
252 }
253
ata_acpi_add_pm_notifier(struct ata_device * dev)254 static void ata_acpi_add_pm_notifier(struct ata_device *dev)
255 {
256 acpi_handle handle = ata_dev_acpi_handle(dev);
257 acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
258 zpodd_wake_dev, dev);
259 }
260
ata_acpi_remove_pm_notifier(struct ata_device * dev)261 static void ata_acpi_remove_pm_notifier(struct ata_device *dev)
262 {
263 acpi_handle handle = ata_dev_acpi_handle(dev);
264 acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY, zpodd_wake_dev);
265 }
266
zpodd_init(struct ata_device * dev)267 void zpodd_init(struct ata_device *dev)
268 {
269 struct acpi_device *adev = ACPI_COMPANION(&dev->tdev);
270 enum odd_mech_type mech_type;
271 struct zpodd *zpodd;
272
273 if (dev->zpodd || !adev || !acpi_device_can_poweroff(adev))
274 return;
275
276 mech_type = zpodd_get_mech_type(dev);
277 if (mech_type == ODD_MECH_TYPE_UNSUPPORTED)
278 return;
279
280 zpodd = kzalloc(sizeof(struct zpodd), GFP_KERNEL);
281 if (!zpodd)
282 return;
283
284 zpodd->mech_type = mech_type;
285
286 ata_acpi_add_pm_notifier(dev);
287 zpodd->dev = dev;
288 dev->zpodd = zpodd;
289 dev_pm_qos_expose_flags(&dev->tdev, 0);
290 }
291
zpodd_exit(struct ata_device * dev)292 void zpodd_exit(struct ata_device *dev)
293 {
294 ata_acpi_remove_pm_notifier(dev);
295 kfree(dev->zpodd);
296 dev->zpodd = NULL;
297 }
298