Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * libata-acpi.c
4 : : * Provides ACPI support for PATA/SATA.
5 : : *
6 : : * Copyright (C) 2006 Intel Corp.
7 : : * Copyright (C) 2006 Randy Dunlap
8 : : */
9 : :
10 : : #include <linux/module.h>
11 : : #include <linux/ata.h>
12 : : #include <linux/delay.h>
13 : : #include <linux/device.h>
14 : : #include <linux/errno.h>
15 : : #include <linux/kernel.h>
16 : : #include <linux/acpi.h>
17 : : #include <linux/libata.h>
18 : : #include <linux/pci.h>
19 : : #include <linux/slab.h>
20 : : #include <linux/pm_runtime.h>
21 : : #include <scsi/scsi_device.h>
22 : : #include "libata.h"
23 : :
24 : : unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT;
25 : : module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644);
26 : : MODULE_PARM_DESC(acpi_gtf_filter, "filter mask for ACPI _GTF commands, set to filter out (0x1=set xfermode, 0x2=lock/freeze lock, 0x4=DIPM, 0x8=FPDMA non-zero offset, 0x10=FPDMA DMA Setup FIS auto-activate)");
27 : :
28 : : #define NO_PORT_MULT 0xffff
29 : : #define SATA_ADR(root, pmp) (((root) << 16) | (pmp))
30 : :
31 : : #define REGS_PER_GTF 7
32 : : struct ata_acpi_gtf {
33 : : u8 tf[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */
34 : : } __packed;
35 : :
36 : 0 : static void ata_acpi_clear_gtf(struct ata_device *dev)
37 : : {
38 : 0 : kfree(dev->gtf_cache);
39 : 0 : dev->gtf_cache = NULL;
40 : : }
41 : :
42 : : struct ata_acpi_hotplug_context {
43 : : struct acpi_hotplug_context hp;
44 : : union {
45 : : struct ata_port *ap;
46 : : struct ata_device *dev;
47 : : } data;
48 : : };
49 : :
50 : : #define ata_hotplug_data(context) (container_of((context), struct ata_acpi_hotplug_context, hp)->data)
51 : :
52 : : /**
53 : : * ata_dev_acpi_handle - provide the acpi_handle for an ata_device
54 : : * @dev: the acpi_handle returned will correspond to this device
55 : : *
56 : : * Returns the acpi_handle for the ACPI namespace object corresponding to
57 : : * the ata_device passed into the function, or NULL if no such object exists
58 : : * or ACPI is disabled for this device due to consecutive errors.
59 : : */
60 : 468 : acpi_handle ata_dev_acpi_handle(struct ata_device *dev)
61 : : {
62 : 468 : return dev->flags & ATA_DFLAG_ACPI_DISABLED ?
63 [ + - - + : 468 : NULL : ACPI_HANDLE(&dev->tdev);
- - ]
64 : : }
65 : :
66 : : /* @ap and @dev are the same as ata_acpi_handle_hotplug() */
67 : 0 : static void ata_acpi_detach_device(struct ata_port *ap, struct ata_device *dev)
68 : : {
69 [ # # ]: 0 : if (dev)
70 : 0 : dev->flags |= ATA_DFLAG_DETACH;
71 : : else {
72 : 0 : struct ata_link *tlink;
73 : 0 : struct ata_device *tdev;
74 : :
75 [ # # ]: 0 : ata_for_each_link(tlink, ap, EDGE)
76 [ # # ]: 0 : ata_for_each_dev(tdev, tlink, ALL)
77 : 0 : tdev->flags |= ATA_DFLAG_DETACH;
78 : : }
79 : :
80 : 0 : ata_port_schedule_eh(ap);
81 : 0 : }
82 : :
83 : : /**
84 : : * ata_acpi_handle_hotplug - ACPI event handler backend
85 : : * @ap: ATA port ACPI event occurred
86 : : * @dev: ATA device ACPI event occurred (can be NULL)
87 : : * @event: ACPI event which occurred
88 : : *
89 : : * All ACPI bay / device realted events end up in this function. If
90 : : * the event is port-wide @dev is NULL. If the event is specific to a
91 : : * device, @dev points to it.
92 : : *
93 : : * Hotplug (as opposed to unplug) notification is always handled as
94 : : * port-wide while unplug only kills the target device on device-wide
95 : : * event.
96 : : *
97 : : * LOCKING:
98 : : * ACPI notify handler context. May sleep.
99 : : */
100 : 0 : static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev,
101 : : u32 event)
102 : : {
103 : 0 : struct ata_eh_info *ehi = &ap->link.eh_info;
104 : 0 : int wait = 0;
105 : 0 : unsigned long flags;
106 : :
107 : 0 : spin_lock_irqsave(ap->lock, flags);
108 : : /*
109 : : * When dock driver calls into the routine, it will always use
110 : : * ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
111 : : * ACPI_NOTIFY_EJECT_REQUEST for remove
112 : : */
113 [ # # # ]: 0 : switch (event) {
114 : 0 : case ACPI_NOTIFY_BUS_CHECK:
115 : : case ACPI_NOTIFY_DEVICE_CHECK:
116 : 0 : ata_ehi_push_desc(ehi, "ACPI event");
117 : :
118 : 0 : ata_ehi_hotplugged(ehi);
119 : 0 : ata_port_freeze(ap);
120 : 0 : break;
121 : 0 : case ACPI_NOTIFY_EJECT_REQUEST:
122 : 0 : ata_ehi_push_desc(ehi, "ACPI event");
123 : :
124 : 0 : ata_acpi_detach_device(ap, dev);
125 : 0 : wait = 1;
126 : 0 : break;
127 : : }
128 : :
129 : 0 : spin_unlock_irqrestore(ap->lock, flags);
130 : :
131 [ # # ]: 0 : if (wait)
132 : 0 : ata_port_wait_eh(ap);
133 : 0 : }
134 : :
135 : 0 : static int ata_acpi_dev_notify_dock(struct acpi_device *adev, u32 event)
136 : : {
137 : 0 : struct ata_device *dev = ata_hotplug_data(adev->hp).dev;
138 : 0 : ata_acpi_handle_hotplug(dev->link->ap, dev, event);
139 : 0 : return 0;
140 : : }
141 : :
142 : 0 : static int ata_acpi_ap_notify_dock(struct acpi_device *adev, u32 event)
143 : : {
144 : 0 : ata_acpi_handle_hotplug(ata_hotplug_data(adev->hp).ap, NULL, event);
145 : 0 : return 0;
146 : : }
147 : :
148 : : static void ata_acpi_uevent(struct ata_port *ap, struct ata_device *dev,
149 : : u32 event)
150 : : {
151 : : struct kobject *kobj = NULL;
152 : : char event_string[20];
153 : : char *envp[] = { event_string, NULL };
154 : :
155 : : if (dev) {
156 : : if (dev->sdev)
157 : : kobj = &dev->sdev->sdev_gendev.kobj;
158 : : } else
159 : : kobj = &ap->dev->kobj;
160 : :
161 : : if (kobj) {
162 : : snprintf(event_string, 20, "BAY_EVENT=%d", event);
163 : : kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
164 : : }
165 : : }
166 : :
167 : 0 : static void ata_acpi_ap_uevent(struct acpi_device *adev, u32 event)
168 : : {
169 : 0 : ata_acpi_uevent(ata_hotplug_data(adev->hp).ap, NULL, event);
170 : 0 : }
171 : :
172 : 0 : static void ata_acpi_dev_uevent(struct acpi_device *adev, u32 event)
173 : : {
174 : 0 : struct ata_device *dev = ata_hotplug_data(adev->hp).dev;
175 : 0 : ata_acpi_uevent(dev->link->ap, dev, event);
176 : 0 : }
177 : :
178 : : /* bind acpi handle to pata port */
179 : 156 : void ata_acpi_bind_port(struct ata_port *ap)
180 : : {
181 [ - + ]: 156 : struct acpi_device *host_companion = ACPI_COMPANION(ap->host->dev);
182 : 156 : struct acpi_device *adev;
183 : 156 : struct ata_acpi_hotplug_context *context;
184 : :
185 [ + - + - : 156 : if (libata_noacpi || ap->flags & ATA_FLAG_ACPI_SATA || !host_companion)
- + ]
186 : : return;
187 : :
188 : 0 : acpi_preset_companion(&ap->tdev, host_companion, ap->port_no);
189 : :
190 [ # # ]: 0 : if (ata_acpi_gtm(ap, &ap->__acpi_init_gtm) == 0)
191 : 0 : ap->pflags |= ATA_PFLAG_INIT_GTM_VALID;
192 : :
193 [ # # ]: 0 : adev = ACPI_COMPANION(&ap->tdev);
194 [ # # # # ]: 0 : if (!adev || adev->hp)
195 : : return;
196 : :
197 : 0 : context = kzalloc(sizeof(*context), GFP_KERNEL);
198 [ # # ]: 0 : if (!context)
199 : : return;
200 : :
201 : 0 : context->data.ap = ap;
202 : 0 : acpi_initialize_hp_context(adev, &context->hp, ata_acpi_ap_notify_dock,
203 : : ata_acpi_ap_uevent);
204 : : }
205 : :
206 : 312 : void ata_acpi_bind_dev(struct ata_device *dev)
207 : : {
208 : 312 : struct ata_port *ap = dev->link->ap;
209 [ - + ]: 312 : struct acpi_device *port_companion = ACPI_COMPANION(&ap->tdev);
210 [ - + ]: 312 : struct acpi_device *host_companion = ACPI_COMPANION(ap->host->dev);
211 : 312 : struct acpi_device *parent, *adev;
212 : 312 : struct ata_acpi_hotplug_context *context;
213 : 312 : u64 adr;
214 : :
215 : : /*
216 : : * For both sata/pata devices, host companion device is required.
217 : : * For pata device, port companion device is also required.
218 : : */
219 [ + - - + ]: 312 : if (libata_noacpi || !host_companion ||
220 [ # # # # ]: 0 : (!(ap->flags & ATA_FLAG_ACPI_SATA) && !port_companion))
221 : : return;
222 : :
223 [ # # ]: 0 : if (ap->flags & ATA_FLAG_ACPI_SATA) {
224 [ # # ]: 0 : if (!sata_pmp_attached(ap))
225 : 0 : adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
226 : : else
227 : 0 : adr = SATA_ADR(ap->port_no, dev->link->pmp);
228 : : parent = host_companion;
229 : : } else {
230 : 0 : adr = dev->devno;
231 : 0 : parent = port_companion;
232 : : }
233 : :
234 : 0 : acpi_preset_companion(&dev->tdev, parent, adr);
235 [ # # ]: 0 : adev = ACPI_COMPANION(&dev->tdev);
236 [ # # # # ]: 0 : if (!adev || adev->hp)
237 : : return;
238 : :
239 : 0 : context = kzalloc(sizeof(*context), GFP_KERNEL);
240 [ # # ]: 0 : if (!context)
241 : : return;
242 : :
243 : 0 : context->data.dev = dev;
244 : 0 : acpi_initialize_hp_context(adev, &context->hp, ata_acpi_dev_notify_dock,
245 : : ata_acpi_dev_uevent);
246 : : }
247 : :
248 : : /**
249 : : * ata_acpi_dissociate - dissociate ATA host from ACPI objects
250 : : * @host: target ATA host
251 : : *
252 : : * This function is called during driver detach after the whole host
253 : : * is shut down.
254 : : *
255 : : * LOCKING:
256 : : * EH context.
257 : : */
258 : 0 : void ata_acpi_dissociate(struct ata_host *host)
259 : : {
260 : 0 : int i;
261 : :
262 : : /* Restore initial _GTM values so that driver which attaches
263 : : * afterward can use them too.
264 : : */
265 [ # # ]: 0 : for (i = 0; i < host->n_ports; i++) {
266 : 0 : struct ata_port *ap = host->ports[i];
267 [ # # ]: 0 : const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
268 : :
269 [ # # # # : 0 : if (ACPI_HANDLE(&ap->tdev) && gtm)
# # # # ]
270 : 0 : ata_acpi_stm(ap, gtm);
271 : : }
272 : 0 : }
273 : :
274 : : /**
275 : : * ata_acpi_gtm - execute _GTM
276 : : * @ap: target ATA port
277 : : * @gtm: out parameter for _GTM result
278 : : *
279 : : * Evaluate _GTM and store the result in @gtm.
280 : : *
281 : : * LOCKING:
282 : : * EH context.
283 : : *
284 : : * RETURNS:
285 : : * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
286 : : */
287 : 0 : int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *gtm)
288 : : {
289 : 0 : struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
290 : 0 : union acpi_object *out_obj;
291 : 0 : acpi_status status;
292 : 0 : int rc = 0;
293 [ # # # # ]: 0 : acpi_handle handle = ACPI_HANDLE(&ap->tdev);
294 : :
295 [ # # ]: 0 : if (!handle)
296 : : return -EINVAL;
297 : :
298 : 0 : status = acpi_evaluate_object(handle, "_GTM", NULL, &output);
299 : :
300 : 0 : rc = -ENOENT;
301 [ # # ]: 0 : if (status == AE_NOT_FOUND)
302 : 0 : goto out_free;
303 : :
304 : 0 : rc = -EINVAL;
305 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
306 : 0 : ata_port_err(ap, "ACPI get timing mode failed (AE 0x%x)\n",
307 : : status);
308 : 0 : goto out_free;
309 : : }
310 : :
311 : 0 : out_obj = output.pointer;
312 [ # # ]: 0 : if (out_obj->type != ACPI_TYPE_BUFFER) {
313 : 0 : ata_port_warn(ap, "_GTM returned unexpected object type 0x%x\n",
314 : : out_obj->type);
315 : :
316 : 0 : goto out_free;
317 : : }
318 : :
319 [ # # ]: 0 : if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) {
320 : 0 : ata_port_err(ap, "_GTM returned invalid length %d\n",
321 : : out_obj->buffer.length);
322 : 0 : goto out_free;
323 : : }
324 : :
325 : 0 : memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm));
326 : 0 : rc = 0;
327 : 0 : out_free:
328 : 0 : kfree(output.pointer);
329 : 0 : return rc;
330 : : }
331 : :
332 : : EXPORT_SYMBOL_GPL(ata_acpi_gtm);
333 : :
334 : : /**
335 : : * ata_acpi_stm - execute _STM
336 : : * @ap: target ATA port
337 : : * @stm: timing parameter to _STM
338 : : *
339 : : * Evaluate _STM with timing parameter @stm.
340 : : *
341 : : * LOCKING:
342 : : * EH context.
343 : : *
344 : : * RETURNS:
345 : : * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
346 : : */
347 : 0 : int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm)
348 : : {
349 : 0 : acpi_status status;
350 : 0 : struct ata_acpi_gtm stm_buf = *stm;
351 : 0 : struct acpi_object_list input;
352 : 0 : union acpi_object in_params[3];
353 : :
354 : 0 : in_params[0].type = ACPI_TYPE_BUFFER;
355 : 0 : in_params[0].buffer.length = sizeof(struct ata_acpi_gtm);
356 : 0 : in_params[0].buffer.pointer = (u8 *)&stm_buf;
357 : : /* Buffers for id may need byteswapping ? */
358 : 0 : in_params[1].type = ACPI_TYPE_BUFFER;
359 : 0 : in_params[1].buffer.length = 512;
360 : 0 : in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
361 : 0 : in_params[2].type = ACPI_TYPE_BUFFER;
362 : 0 : in_params[2].buffer.length = 512;
363 : 0 : in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
364 : :
365 : 0 : input.count = 3;
366 : 0 : input.pointer = in_params;
367 : :
368 [ # # # # ]: 0 : status = acpi_evaluate_object(ACPI_HANDLE(&ap->tdev), "_STM",
369 : : &input, NULL);
370 : :
371 [ # # ]: 0 : if (status == AE_NOT_FOUND)
372 : : return -ENOENT;
373 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
374 : 0 : ata_port_err(ap, "ACPI set timing mode failed (status=0x%x)\n",
375 : : status);
376 : 0 : return -EINVAL;
377 : : }
378 : : return 0;
379 : : }
380 : :
381 : : EXPORT_SYMBOL_GPL(ata_acpi_stm);
382 : :
383 : : /**
384 : : * ata_dev_get_GTF - get the drive bootup default taskfile settings
385 : : * @dev: target ATA device
386 : : * @gtf: output parameter for buffer containing _GTF taskfile arrays
387 : : *
388 : : * This applies to both PATA and SATA drives.
389 : : *
390 : : * The _GTF method has no input parameters.
391 : : * It returns a variable number of register set values (registers
392 : : * hex 1F1..1F7, taskfiles).
393 : : * The <variable number> is not known in advance, so have ACPI-CA
394 : : * allocate the buffer as needed and return it, then free it later.
395 : : *
396 : : * LOCKING:
397 : : * EH context.
398 : : *
399 : : * RETURNS:
400 : : * Number of taskfiles on success, 0 if _GTF doesn't exist. -EINVAL
401 : : * if _GTF is invalid.
402 : : */
403 : 0 : static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
404 : : {
405 : 0 : struct ata_port *ap = dev->link->ap;
406 : 0 : acpi_status status;
407 : 0 : struct acpi_buffer output;
408 : 0 : union acpi_object *out_obj;
409 : 0 : int rc = 0;
410 : :
411 : : /* if _GTF is cached, use the cached value */
412 [ # # ]: 0 : if (dev->gtf_cache) {
413 : 0 : out_obj = dev->gtf_cache;
414 : 0 : goto done;
415 : : }
416 : :
417 : : /* set up output buffer */
418 : 0 : output.length = ACPI_ALLOCATE_BUFFER;
419 : 0 : output.pointer = NULL; /* ACPI-CA sets this; save/free it later */
420 : :
421 [ # # ]: 0 : if (ata_msg_probe(ap))
422 : 0 : ata_dev_dbg(dev, "%s: ENTER: port#: %d\n",
423 : : __func__, ap->port_no);
424 : :
425 : : /* _GTF has no input parameters */
426 : 0 : status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_GTF", NULL,
427 : : &output);
428 : 0 : out_obj = dev->gtf_cache = output.pointer;
429 : :
430 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
431 [ # # ]: 0 : if (status != AE_NOT_FOUND) {
432 : 0 : ata_dev_warn(dev, "_GTF evaluation failed (AE 0x%x)\n",
433 : : status);
434 : 0 : rc = -EINVAL;
435 : : }
436 : 0 : goto out_free;
437 : : }
438 : :
439 [ # # # # ]: 0 : if (!output.length || !output.pointer) {
440 [ # # ]: 0 : if (ata_msg_probe(ap))
441 : 0 : ata_dev_dbg(dev, "%s: Run _GTF: length or ptr is NULL (0x%llx, 0x%p)\n",
442 : : __func__,
443 : : (unsigned long long)output.length,
444 : : output.pointer);
445 : 0 : rc = -EINVAL;
446 : 0 : goto out_free;
447 : : }
448 : :
449 [ # # ]: 0 : if (out_obj->type != ACPI_TYPE_BUFFER) {
450 : 0 : ata_dev_warn(dev, "_GTF unexpected object type 0x%x\n",
451 : : out_obj->type);
452 : 0 : rc = -EINVAL;
453 : 0 : goto out_free;
454 : : }
455 : :
456 [ # # ]: 0 : if (out_obj->buffer.length % REGS_PER_GTF) {
457 : 0 : ata_dev_warn(dev, "unexpected _GTF length (%d)\n",
458 : : out_obj->buffer.length);
459 : 0 : rc = -EINVAL;
460 : 0 : goto out_free;
461 : : }
462 : :
463 : 0 : done:
464 : 0 : rc = out_obj->buffer.length / REGS_PER_GTF;
465 [ # # ]: 0 : if (gtf) {
466 : 0 : *gtf = (void *)out_obj->buffer.pointer;
467 [ # # ]: 0 : if (ata_msg_probe(ap))
468 : 0 : ata_dev_dbg(dev, "%s: returning gtf=%p, gtf_count=%d\n",
469 : : __func__, *gtf, rc);
470 : : }
471 : : return rc;
472 : :
473 : 0 : out_free:
474 : 0 : ata_acpi_clear_gtf(dev);
475 : 0 : return rc;
476 : : }
477 : :
478 : : /**
479 : : * ata_acpi_gtm_xfermode - determine xfermode from GTM parameter
480 : : * @dev: target device
481 : : * @gtm: GTM parameter to use
482 : : *
483 : : * Determine xfermask for @dev from @gtm.
484 : : *
485 : : * LOCKING:
486 : : * None.
487 : : *
488 : : * RETURNS:
489 : : * Determined xfermask.
490 : : */
491 : 0 : unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
492 : : const struct ata_acpi_gtm *gtm)
493 : : {
494 : 0 : unsigned long xfer_mask = 0;
495 : 0 : unsigned int type;
496 : 0 : int unit;
497 : 0 : u8 mode;
498 : :
499 : : /* we always use the 0 slot for crap hardware */
500 : 0 : unit = dev->devno;
501 [ # # ]: 0 : if (!(gtm->flags & 0x10))
502 : 0 : unit = 0;
503 : :
504 : : /* PIO */
505 : 0 : mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio);
506 : 0 : xfer_mask |= ata_xfer_mode2mask(mode);
507 : :
508 : : /* See if we have MWDMA or UDMA data. We don't bother with
509 : : * MWDMA if UDMA is available as this means the BIOS set UDMA
510 : : * and our error changedown if it works is UDMA to PIO anyway.
511 : : */
512 [ # # ]: 0 : if (!(gtm->flags & (1 << (2 * unit))))
513 : : type = ATA_SHIFT_MWDMA;
514 : : else
515 : 0 : type = ATA_SHIFT_UDMA;
516 : :
517 : 0 : mode = ata_timing_cycle2mode(type, gtm->drive[unit].dma);
518 : 0 : xfer_mask |= ata_xfer_mode2mask(mode);
519 : :
520 : 0 : return xfer_mask;
521 : : }
522 : : EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask);
523 : :
524 : : /**
525 : : * ata_acpi_cbl_80wire - Check for 80 wire cable
526 : : * @ap: Port to check
527 : : * @gtm: GTM data to use
528 : : *
529 : : * Return 1 if the @gtm indicates the BIOS selected an 80wire mode.
530 : : */
531 : 0 : int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm)
532 : : {
533 : 0 : struct ata_device *dev;
534 : :
535 [ # # ]: 0 : ata_for_each_dev(dev, &ap->link, ENABLED) {
536 : 0 : unsigned long xfer_mask, udma_mask;
537 : :
538 : 0 : xfer_mask = ata_acpi_gtm_xfermask(dev, gtm);
539 : 0 : ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask);
540 : :
541 [ # # ]: 0 : if (udma_mask & ~ATA_UDMA_MASK_40C)
542 : 0 : return 1;
543 : : }
544 : :
545 : : return 0;
546 : : }
547 : : EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
548 : :
549 : 0 : static void ata_acpi_gtf_to_tf(struct ata_device *dev,
550 : : const struct ata_acpi_gtf *gtf,
551 : : struct ata_taskfile *tf)
552 : : {
553 [ # # ]: 0 : ata_tf_init(dev, tf);
554 : :
555 : 0 : tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
556 : 0 : tf->protocol = ATA_PROT_NODATA;
557 : 0 : tf->feature = gtf->tf[0]; /* 0x1f1 */
558 : 0 : tf->nsect = gtf->tf[1]; /* 0x1f2 */
559 : 0 : tf->lbal = gtf->tf[2]; /* 0x1f3 */
560 : 0 : tf->lbam = gtf->tf[3]; /* 0x1f4 */
561 : 0 : tf->lbah = gtf->tf[4]; /* 0x1f5 */
562 : 0 : tf->device = gtf->tf[5]; /* 0x1f6 */
563 : 0 : tf->command = gtf->tf[6]; /* 0x1f7 */
564 : 0 : }
565 : :
566 : : static int ata_acpi_filter_tf(struct ata_device *dev,
567 : : const struct ata_taskfile *tf,
568 : : const struct ata_taskfile *ptf)
569 : : {
570 : : if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) {
571 : : /* libata doesn't use ACPI to configure transfer mode.
572 : : * It will only confuse device configuration. Skip.
573 : : */
574 : : if (tf->command == ATA_CMD_SET_FEATURES &&
575 : : tf->feature == SETFEATURES_XFER)
576 : : return 1;
577 : : }
578 : :
579 : : if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) {
580 : : /* BIOS writers, sorry but we don't wanna lock
581 : : * features unless the user explicitly said so.
582 : : */
583 : :
584 : : /* DEVICE CONFIGURATION FREEZE LOCK */
585 : : if (tf->command == ATA_CMD_CONF_OVERLAY &&
586 : : tf->feature == ATA_DCO_FREEZE_LOCK)
587 : : return 1;
588 : :
589 : : /* SECURITY FREEZE LOCK */
590 : : if (tf->command == ATA_CMD_SEC_FREEZE_LOCK)
591 : : return 1;
592 : :
593 : : /* SET MAX LOCK and SET MAX FREEZE LOCK */
594 : : if ((!ptf || ptf->command != ATA_CMD_READ_NATIVE_MAX) &&
595 : : tf->command == ATA_CMD_SET_MAX &&
596 : : (tf->feature == ATA_SET_MAX_LOCK ||
597 : : tf->feature == ATA_SET_MAX_FREEZE_LOCK))
598 : : return 1;
599 : : }
600 : :
601 : : if (tf->command == ATA_CMD_SET_FEATURES &&
602 : : tf->feature == SETFEATURES_SATA_ENABLE) {
603 : : /* inhibit enabling DIPM */
604 : : if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM &&
605 : : tf->nsect == SATA_DIPM)
606 : : return 1;
607 : :
608 : : /* inhibit FPDMA non-zero offset */
609 : : if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET &&
610 : : (tf->nsect == SATA_FPDMA_OFFSET ||
611 : : tf->nsect == SATA_FPDMA_IN_ORDER))
612 : : return 1;
613 : :
614 : : /* inhibit FPDMA auto activation */
615 : : if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA &&
616 : : tf->nsect == SATA_FPDMA_AA)
617 : : return 1;
618 : : }
619 : :
620 : : return 0;
621 : : }
622 : :
623 : : /**
624 : : * ata_acpi_run_tf - send taskfile registers to host controller
625 : : * @dev: target ATA device
626 : : * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
627 : : *
628 : : * Outputs ATA taskfile to standard ATA host controller.
629 : : * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
630 : : * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
631 : : * hob_lbal, hob_lbam, and hob_lbah.
632 : : *
633 : : * This function waits for idle (!BUSY and !DRQ) after writing
634 : : * registers. If the control register has a new value, this
635 : : * function also waits for idle after writing control and before
636 : : * writing the remaining registers.
637 : : *
638 : : * LOCKING:
639 : : * EH context.
640 : : *
641 : : * RETURNS:
642 : : * 1 if command is executed successfully. 0 if ignored, rejected or
643 : : * filtered out, -errno on other errors.
644 : : */
645 : 0 : static int ata_acpi_run_tf(struct ata_device *dev,
646 : : const struct ata_acpi_gtf *gtf,
647 : : const struct ata_acpi_gtf *prev_gtf)
648 : : {
649 : 0 : struct ata_taskfile *pptf = NULL;
650 : 0 : struct ata_taskfile tf, ptf, rtf;
651 : 0 : unsigned int err_mask;
652 : 0 : const char *level;
653 : 0 : const char *descr;
654 : 0 : char msg[60];
655 : 0 : int rc;
656 : :
657 [ # # # # : 0 : if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
# # ]
658 [ # # # # : 0 : && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
# # ]
659 [ # # ]: 0 : && (gtf->tf[6] == 0))
660 : : return 0;
661 : :
662 : 0 : ata_acpi_gtf_to_tf(dev, gtf, &tf);
663 [ # # ]: 0 : if (prev_gtf) {
664 : 0 : ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf);
665 : 0 : pptf = &ptf;
666 : : }
667 : :
668 [ # # ]: 0 : if (!ata_acpi_filter_tf(dev, &tf, pptf)) {
669 : 0 : rtf = tf;
670 : 0 : err_mask = ata_exec_internal(dev, &rtf, NULL,
671 : : DMA_NONE, NULL, 0, 0);
672 : :
673 [ # # # ]: 0 : switch (err_mask) {
674 : 0 : case 0:
675 : 0 : level = KERN_DEBUG;
676 : 0 : snprintf(msg, sizeof(msg), "succeeded");
677 : 0 : rc = 1;
678 : 0 : break;
679 : :
680 : 0 : case AC_ERR_DEV:
681 : 0 : level = KERN_INFO;
682 : 0 : snprintf(msg, sizeof(msg),
683 : : "rejected by device (Stat=0x%02x Err=0x%02x)",
684 : 0 : rtf.command, rtf.feature);
685 : 0 : rc = 0;
686 : 0 : break;
687 : :
688 : 0 : default:
689 : 0 : level = KERN_ERR;
690 : 0 : snprintf(msg, sizeof(msg),
691 : : "failed (Emask=0x%x Stat=0x%02x Err=0x%02x)",
692 : 0 : err_mask, rtf.command, rtf.feature);
693 : 0 : rc = -EIO;
694 : 0 : break;
695 : : }
696 : : } else {
697 : 0 : level = KERN_INFO;
698 : 0 : snprintf(msg, sizeof(msg), "filtered out");
699 : 0 : rc = 0;
700 : : }
701 : 0 : descr = ata_get_cmd_descript(tf.command);
702 : :
703 [ # # ]: 0 : ata_dev_printk(dev, level,
704 : : "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n",
705 : 0 : tf.command, tf.feature, tf.nsect, tf.lbal,
706 : 0 : tf.lbam, tf.lbah, tf.device,
707 : : (descr ? descr : "unknown"), msg);
708 : :
709 : 0 : return rc;
710 : : }
711 : :
712 : : /**
713 : : * ata_acpi_exec_tfs - get then write drive taskfile settings
714 : : * @dev: target ATA device
715 : : * @nr_executed: out parameter for the number of executed commands
716 : : *
717 : : * Evaluate _GTF and execute returned taskfiles.
718 : : *
719 : : * LOCKING:
720 : : * EH context.
721 : : *
722 : : * RETURNS:
723 : : * Number of executed taskfiles on success, 0 if _GTF doesn't exist.
724 : : * -errno on other errors.
725 : : */
726 : 0 : static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
727 : : {
728 : 0 : struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL;
729 : 0 : int gtf_count, i, rc;
730 : :
731 : : /* get taskfiles */
732 : 0 : rc = ata_dev_get_GTF(dev, >f);
733 [ # # ]: 0 : if (rc < 0)
734 : : return rc;
735 : : gtf_count = rc;
736 : :
737 : : /* execute them */
738 [ # # ]: 0 : for (i = 0; i < gtf_count; i++, gtf++) {
739 : 0 : rc = ata_acpi_run_tf(dev, gtf, pgtf);
740 [ # # ]: 0 : if (rc < 0)
741 : : break;
742 [ # # ]: 0 : if (rc) {
743 : 0 : (*nr_executed)++;
744 : 0 : pgtf = gtf;
745 : : }
746 : : }
747 : :
748 : 0 : ata_acpi_clear_gtf(dev);
749 : :
750 : 0 : if (rc < 0)
751 : : return rc;
752 : : return 0;
753 : : }
754 : :
755 : : /**
756 : : * ata_acpi_push_id - send Identify data to drive
757 : : * @dev: target ATA device
758 : : *
759 : : * _SDD ACPI object: for SATA mode only
760 : : * Must be after Identify (Packet) Device -- uses its data
761 : : * ATM this function never returns a failure. It is an optional
762 : : * method and if it fails for whatever reason, we should still
763 : : * just keep going.
764 : : *
765 : : * LOCKING:
766 : : * EH context.
767 : : *
768 : : * RETURNS:
769 : : * 0 on success, -ENOENT if _SDD doesn't exist, -errno on failure.
770 : : */
771 : 0 : static int ata_acpi_push_id(struct ata_device *dev)
772 : : {
773 : 0 : struct ata_port *ap = dev->link->ap;
774 : 0 : acpi_status status;
775 : 0 : struct acpi_object_list input;
776 : 0 : union acpi_object in_params[1];
777 : :
778 [ # # ]: 0 : if (ata_msg_probe(ap))
779 : 0 : ata_dev_dbg(dev, "%s: ix = %d, port#: %d\n",
780 : : __func__, dev->devno, ap->port_no);
781 : :
782 : : /* Give the drive Identify data to the drive via the _SDD method */
783 : : /* _SDD: set up input parameters */
784 : 0 : input.count = 1;
785 : 0 : input.pointer = in_params;
786 : 0 : in_params[0].type = ACPI_TYPE_BUFFER;
787 : 0 : in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
788 : 0 : in_params[0].buffer.pointer = (u8 *)dev->id;
789 : : /* Output buffer: _SDD has no output */
790 : :
791 : : /* It's OK for _SDD to be missing too. */
792 : 0 : swap_buf_le16(dev->id, ATA_ID_WORDS);
793 : 0 : status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_SDD", &input,
794 : : NULL);
795 : 0 : swap_buf_le16(dev->id, ATA_ID_WORDS);
796 : :
797 [ # # ]: 0 : if (status == AE_NOT_FOUND)
798 : : return -ENOENT;
799 : :
800 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
801 : 0 : ata_dev_warn(dev, "ACPI _SDD failed (AE 0x%x)\n", status);
802 : 0 : return -EIO;
803 : : }
804 : :
805 : : return 0;
806 : : }
807 : :
808 : : /**
809 : : * ata_acpi_on_suspend - ATA ACPI hook called on suspend
810 : : * @ap: target ATA port
811 : : *
812 : : * This function is called when @ap is about to be suspended. All
813 : : * devices are already put to sleep but the port_suspend() callback
814 : : * hasn't been executed yet. Error return from this function aborts
815 : : * suspend.
816 : : *
817 : : * LOCKING:
818 : : * EH context.
819 : : *
820 : : * RETURNS:
821 : : * 0 on success, -errno on failure.
822 : : */
823 : 0 : int ata_acpi_on_suspend(struct ata_port *ap)
824 : : {
825 : : /* nada */
826 : 0 : return 0;
827 : : }
828 : :
829 : : /**
830 : : * ata_acpi_on_resume - ATA ACPI hook called on resume
831 : : * @ap: target ATA port
832 : : *
833 : : * This function is called when @ap is resumed - right after port
834 : : * itself is resumed but before any EH action is taken.
835 : : *
836 : : * LOCKING:
837 : : * EH context.
838 : : */
839 : 0 : void ata_acpi_on_resume(struct ata_port *ap)
840 : : {
841 [ # # ]: 0 : const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
842 : 0 : struct ata_device *dev;
843 : :
844 [ # # # # : 0 : if (ACPI_HANDLE(&ap->tdev) && gtm) {
# # # # ]
845 : : /* _GTM valid */
846 : :
847 : : /* restore timing parameters */
848 : 0 : ata_acpi_stm(ap, gtm);
849 : :
850 : : /* _GTF should immediately follow _STM so that it can
851 : : * use values set by _STM. Cache _GTF result and
852 : : * schedule _GTF.
853 : : */
854 [ # # ]: 0 : ata_for_each_dev(dev, &ap->link, ALL) {
855 : 0 : ata_acpi_clear_gtf(dev);
856 [ # # # # : 0 : if (ata_dev_enabled(dev) &&
# # ]
857 [ # # ]: 0 : ata_dev_acpi_handle(dev) &&
858 : 0 : ata_dev_get_GTF(dev, NULL) >= 0)
859 : 0 : dev->flags |= ATA_DFLAG_ACPI_PENDING;
860 : : }
861 : : } else {
862 : : /* SATA _GTF needs to be evaulated after _SDD and
863 : : * there's no reason to evaluate IDE _GTF early
864 : : * without _STM. Clear cache and schedule _GTF.
865 : : */
866 [ # # ]: 0 : ata_for_each_dev(dev, &ap->link, ALL) {
867 : 0 : ata_acpi_clear_gtf(dev);
868 [ # # # # ]: 0 : if (ata_dev_enabled(dev))
869 : 0 : dev->flags |= ATA_DFLAG_ACPI_PENDING;
870 : : }
871 : : }
872 : 0 : }
873 : :
874 : 0 : static int ata_acpi_choose_suspend_state(struct ata_device *dev, bool runtime)
875 : : {
876 : 0 : int d_max_in = ACPI_STATE_D3_COLD;
877 : 0 : if (!runtime)
878 : 0 : goto out;
879 : :
880 : : /*
881 : : * For ATAPI, runtime D3 cold is only allowed
882 : : * for ZPODD in zero power ready state
883 : : */
884 [ # # ]: 0 : if (dev->class == ATA_DEV_ATAPI &&
885 : : !(zpodd_dev_enabled(dev) && zpodd_zpready(dev)))
886 : : d_max_in = ACPI_STATE_D3_HOT;
887 : :
888 : 0 : out:
889 : 0 : return acpi_pm_device_sleep_state(&dev->tdev, NULL, d_max_in);
890 : : }
891 : :
892 : 0 : static void sata_acpi_set_state(struct ata_port *ap, pm_message_t state)
893 : : {
894 : 0 : bool runtime = PMSG_IS_AUTO(state);
895 : 0 : struct ata_device *dev;
896 : 0 : acpi_handle handle;
897 : 0 : int acpi_state;
898 : :
899 [ # # ]: 0 : ata_for_each_dev(dev, &ap->link, ENABLED) {
900 : 0 : handle = ata_dev_acpi_handle(dev);
901 [ # # ]: 0 : if (!handle)
902 : 0 : continue;
903 : :
904 [ # # ]: 0 : if (!(state.event & PM_EVENT_RESUME)) {
905 [ # # ]: 0 : acpi_state = ata_acpi_choose_suspend_state(dev, runtime);
906 [ # # ]: 0 : if (acpi_state == ACPI_STATE_D0)
907 : 0 : continue;
908 : 0 : if (runtime && zpodd_dev_enabled(dev) &&
909 : : acpi_state == ACPI_STATE_D3_COLD)
910 : : zpodd_enable_run_wake(dev);
911 : 0 : acpi_bus_set_power(handle, acpi_state);
912 : : } else {
913 : 0 : if (runtime && zpodd_dev_enabled(dev))
914 : : zpodd_disable_run_wake(dev);
915 : 0 : acpi_bus_set_power(handle, ACPI_STATE_D0);
916 : : }
917 : : }
918 : 0 : }
919 : :
920 : : /* ACPI spec requires _PS0 when IDE power on and _PS3 when power off */
921 : 0 : static void pata_acpi_set_state(struct ata_port *ap, pm_message_t state)
922 : : {
923 : 0 : struct ata_device *dev;
924 : 0 : acpi_handle port_handle;
925 : :
926 [ # # # # ]: 0 : port_handle = ACPI_HANDLE(&ap->tdev);
927 [ # # ]: 0 : if (!port_handle)
928 : : return;
929 : :
930 : : /* channel first and then drives for power on and vica versa
931 : : for power off */
932 [ # # ]: 0 : if (state.event & PM_EVENT_RESUME)
933 : 0 : acpi_bus_set_power(port_handle, ACPI_STATE_D0);
934 : :
935 [ # # ]: 0 : ata_for_each_dev(dev, &ap->link, ENABLED) {
936 : 0 : acpi_handle dev_handle = ata_dev_acpi_handle(dev);
937 [ # # ]: 0 : if (!dev_handle)
938 : 0 : continue;
939 : :
940 [ # # ]: 0 : acpi_bus_set_power(dev_handle, state.event & PM_EVENT_RESUME ?
941 : : ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
942 : : }
943 : :
944 [ # # ]: 0 : if (!(state.event & PM_EVENT_RESUME))
945 : 0 : acpi_bus_set_power(port_handle, ACPI_STATE_D3_COLD);
946 : : }
947 : :
948 : : /**
949 : : * ata_acpi_set_state - set the port power state
950 : : * @ap: target ATA port
951 : : * @state: state, on/off
952 : : *
953 : : * This function sets a proper ACPI D state for the device on
954 : : * system and runtime PM operations.
955 : : */
956 : 0 : void ata_acpi_set_state(struct ata_port *ap, pm_message_t state)
957 : : {
958 [ # # ]: 0 : if (ap->flags & ATA_FLAG_ACPI_SATA)
959 : 0 : sata_acpi_set_state(ap, state);
960 : : else
961 : 0 : pata_acpi_set_state(ap, state);
962 : 0 : }
963 : :
964 : : /**
965 : : * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
966 : : * @dev: target ATA device
967 : : *
968 : : * This function is called when @dev is about to be configured.
969 : : * IDENTIFY data might have been modified after this hook is run.
970 : : *
971 : : * LOCKING:
972 : : * EH context.
973 : : *
974 : : * RETURNS:
975 : : * Positive number if IDENTIFY data needs to be refreshed, 0 if not,
976 : : * -errno on failure.
977 : : */
978 : 468 : int ata_acpi_on_devcfg(struct ata_device *dev)
979 : : {
980 : 468 : struct ata_port *ap = dev->link->ap;
981 : 468 : struct ata_eh_context *ehc = &ap->link.eh_context;
982 : 468 : int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
983 : 468 : int nr_executed = 0;
984 : 468 : int rc;
985 : :
986 [ - + ]: 468 : if (!ata_dev_acpi_handle(dev))
987 : : return 0;
988 : :
989 : : /* do we need to do _GTF? */
990 [ # # # # ]: 0 : if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
991 [ # # ]: 0 : !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
992 : : return 0;
993 : :
994 : : /* do _SDD if SATA */
995 [ # # ]: 0 : if (acpi_sata) {
996 : 0 : rc = ata_acpi_push_id(dev);
997 [ # # ]: 0 : if (rc && rc != -ENOENT)
998 : 0 : goto acpi_err;
999 : : }
1000 : :
1001 : : /* do _GTF */
1002 : 0 : rc = ata_acpi_exec_tfs(dev, &nr_executed);
1003 [ # # ]: 0 : if (rc)
1004 : 0 : goto acpi_err;
1005 : :
1006 : 0 : dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
1007 : :
1008 : : /* refresh IDENTIFY page if any _GTF command has been executed */
1009 [ # # ]: 0 : if (nr_executed) {
1010 : 0 : rc = ata_dev_reread_id(dev, 0);
1011 [ # # ]: 0 : if (rc < 0) {
1012 : 0 : ata_dev_err(dev,
1013 : : "failed to IDENTIFY after ACPI commands\n");
1014 : 0 : return rc;
1015 : : }
1016 : : }
1017 : :
1018 : : return 0;
1019 : :
1020 : 0 : acpi_err:
1021 : : /* ignore evaluation failure if we can continue safely */
1022 [ # # # # : 0 : if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
# # ]
1023 : : return 0;
1024 : :
1025 : : /* fail and let EH retry once more for unknown IO errors */
1026 [ # # ]: 0 : if (!(dev->flags & ATA_DFLAG_ACPI_FAILED)) {
1027 : 0 : dev->flags |= ATA_DFLAG_ACPI_FAILED;
1028 : 0 : return rc;
1029 : : }
1030 : :
1031 : 0 : dev->flags |= ATA_DFLAG_ACPI_DISABLED;
1032 : 0 : ata_dev_warn(dev, "ACPI: failed the second time, disabled\n");
1033 : :
1034 : : /* We can safely continue if no _GTF command has been executed
1035 : : * and port is not frozen.
1036 : : */
1037 [ # # # # ]: 0 : if (!nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
1038 : 0 : return 0;
1039 : :
1040 : : return rc;
1041 : : }
1042 : :
1043 : : /**
1044 : : * ata_acpi_on_disable - ATA ACPI hook called when a device is disabled
1045 : : * @dev: target ATA device
1046 : : *
1047 : : * This function is called when @dev is about to be disabled.
1048 : : *
1049 : : * LOCKING:
1050 : : * EH context.
1051 : : */
1052 : 0 : void ata_acpi_on_disable(struct ata_device *dev)
1053 : : {
1054 : 0 : ata_acpi_clear_gtf(dev);
1055 : 0 : }
|
