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