libata: Integrate ACPI-based PATA/SATA hotplug - version 5
[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/ata.h>
10 #include <linux/delay.h>
11 #include <linux/device.h>
12 #include <linux/errno.h>
13 #include <linux/kernel.h>
14 #include <linux/acpi.h>
15 #include <linux/libata.h>
16 #include <linux/pci.h>
17 #include <scsi/scsi_device.h>
18 #include "libata.h"
19
20 #include <acpi/acpi_bus.h>
21 #include <acpi/acnames.h>
22 #include <acpi/acnamesp.h>
23 #include <acpi/acparser.h>
24 #include <acpi/acexcep.h>
25 #include <acpi/acmacros.h>
26 #include <acpi/actypes.h>
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 /*
37  *      Helper - belongs in the PCI layer somewhere eventually
38  */
39 static int is_pci_dev(struct device *dev)
40 {
41         return (dev->bus == &pci_bus_type);
42 }
43
44 /**
45  * ata_acpi_associate_sata_port - associate SATA port with ACPI objects
46  * @ap: target SATA port
47  *
48  * Look up ACPI objects associated with @ap and initialize acpi_handle
49  * fields of @ap, the port and devices accordingly.
50  *
51  * LOCKING:
52  * EH context.
53  *
54  * RETURNS:
55  * 0 on success, -errno on failure.
56  */
57 void ata_acpi_associate_sata_port(struct ata_port *ap)
58 {
59         WARN_ON(!(ap->flags & ATA_FLAG_ACPI_SATA));
60
61         if (!ap->nr_pmp_links) {
62                 acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
63
64                 ap->link.device->acpi_handle =
65                         acpi_get_child(ap->host->acpi_handle, adr);
66         } else {
67                 struct ata_link *link;
68
69                 ap->link.device->acpi_handle = NULL;
70
71                 ata_port_for_each_link(link, ap) {
72                         acpi_integer adr = SATA_ADR(ap->port_no, link->pmp);
73
74                         link->device->acpi_handle =
75                                 acpi_get_child(ap->host->acpi_handle, adr);
76                 }
77         }
78 }
79
80 static void ata_acpi_associate_ide_port(struct ata_port *ap)
81 {
82         int max_devices, i;
83
84         ap->acpi_handle = acpi_get_child(ap->host->acpi_handle, ap->port_no);
85         if (!ap->acpi_handle)
86                 return;
87
88         max_devices = 1;
89         if (ap->flags & ATA_FLAG_SLAVE_POSS)
90                 max_devices++;
91
92         for (i = 0; i < max_devices; i++) {
93                 struct ata_device *dev = &ap->link.device[i];
94
95                 dev->acpi_handle = acpi_get_child(ap->acpi_handle, i);
96         }
97 }
98
99 static void ata_acpi_handle_hotplug (struct ata_port *ap, struct kobject *kobj,
100                                      u32 event)
101 {
102         char event_string[12];
103         char *envp[] = { event_string, NULL };
104         struct ata_eh_info *ehi = &ap->link.eh_info;
105
106         if (event == 0 || event == 1) {
107                unsigned long flags;
108                spin_lock_irqsave(ap->lock, flags);
109                ata_ehi_clear_desc(ehi);
110                ata_ehi_push_desc(ehi, "ACPI event");
111                ata_ehi_hotplugged(ehi);
112                ata_port_freeze(ap);
113                spin_unlock_irqrestore(ap->lock, flags);
114         }
115
116         if (kobj) {
117                 sprintf(event_string, "BAY_EVENT=%d", event);
118                 kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
119         }
120 }
121
122 static void ata_acpi_dev_notify(acpi_handle handle, u32 event, void *data)
123 {
124         struct ata_device *dev = data;
125         struct kobject *kobj = NULL;
126
127         if (dev->sdev)
128                 kobj = &dev->sdev->sdev_gendev.kobj;
129
130         ata_acpi_handle_hotplug (dev->link->ap, kobj, event);
131 }
132
133 static void ata_acpi_ap_notify(acpi_handle handle, u32 event, void *data)
134 {
135         struct ata_port *ap = data;
136
137         ata_acpi_handle_hotplug (ap, &ap->dev->kobj, event);
138 }
139
140 /**
141  * ata_acpi_associate - associate ATA host with ACPI objects
142  * @host: target ATA host
143  *
144  * Look up ACPI objects associated with @host and initialize
145  * acpi_handle fields of @host, its ports and devices accordingly.
146  *
147  * LOCKING:
148  * EH context.
149  *
150  * RETURNS:
151  * 0 on success, -errno on failure.
152  */
153 void ata_acpi_associate(struct ata_host *host)
154 {
155         int i, j;
156
157         if (!is_pci_dev(host->dev) || libata_noacpi)
158                 return;
159
160         host->acpi_handle = DEVICE_ACPI_HANDLE(host->dev);
161         if (!host->acpi_handle)
162                 return;
163
164         for (i = 0; i < host->n_ports; i++) {
165                 struct ata_port *ap = host->ports[i];
166
167                 if (host->ports[0]->flags & ATA_FLAG_ACPI_SATA)
168                         ata_acpi_associate_sata_port(ap);
169                 else
170                         ata_acpi_associate_ide_port(ap);
171
172                 if (ap->acpi_handle)
173                         acpi_install_notify_handler (ap->acpi_handle,
174                                                      ACPI_SYSTEM_NOTIFY,
175                                                      ata_acpi_ap_notify,
176                                                      ap);
177
178                 for (j = 0; j < ata_link_max_devices(&ap->link); j++) {
179                         struct ata_device *dev = &ap->link.device[j];
180
181                         if (dev->acpi_handle)
182                                 acpi_install_notify_handler (dev->acpi_handle,
183                                                              ACPI_SYSTEM_NOTIFY,
184                                                              ata_acpi_dev_notify,
185                                                              dev);
186                 }
187         }
188 }
189
190 /**
191  * ata_acpi_gtm - execute _GTM
192  * @ap: target ATA port
193  * @gtm: out parameter for _GTM result
194  *
195  * Evaluate _GTM and store the result in @gtm.
196  *
197  * LOCKING:
198  * EH context.
199  *
200  * RETURNS:
201  * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
202  */
203 static int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
204 {
205         struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
206         union acpi_object *out_obj;
207         acpi_status status;
208         int rc = 0;
209
210         status = acpi_evaluate_object(ap->acpi_handle, "_GTM", NULL, &output);
211
212         rc = -ENOENT;
213         if (status == AE_NOT_FOUND)
214                 goto out_free;
215
216         rc = -EINVAL;
217         if (ACPI_FAILURE(status)) {
218                 ata_port_printk(ap, KERN_ERR,
219                                 "ACPI get timing mode failed (AE 0x%x)\n",
220                                 status);
221                 goto out_free;
222         }
223
224         out_obj = output.pointer;
225         if (out_obj->type != ACPI_TYPE_BUFFER) {
226                 ata_port_printk(ap, KERN_WARNING,
227                                 "_GTM returned unexpected object type 0x%x\n",
228                                 out_obj->type);
229
230                 goto out_free;
231         }
232
233         if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) {
234                 ata_port_printk(ap, KERN_ERR,
235                                 "_GTM returned invalid length %d\n",
236                                 out_obj->buffer.length);
237                 goto out_free;
238         }
239
240         memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm));
241         rc = 0;
242  out_free:
243         kfree(output.pointer);
244         return rc;
245 }
246
247 /**
248  * ata_acpi_stm - execute _STM
249  * @ap: target ATA port
250  * @stm: timing parameter to _STM
251  *
252  * Evaluate _STM with timing parameter @stm.
253  *
254  * LOCKING:
255  * EH context.
256  *
257  * RETURNS:
258  * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
259  */
260 static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
261 {
262         acpi_status status;
263         struct acpi_object_list         input;
264         union acpi_object               in_params[3];
265
266         in_params[0].type = ACPI_TYPE_BUFFER;
267         in_params[0].buffer.length = sizeof(struct ata_acpi_gtm);
268         in_params[0].buffer.pointer = (u8 *)stm;
269         /* Buffers for id may need byteswapping ? */
270         in_params[1].type = ACPI_TYPE_BUFFER;
271         in_params[1].buffer.length = 512;
272         in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
273         in_params[2].type = ACPI_TYPE_BUFFER;
274         in_params[2].buffer.length = 512;
275         in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
276
277         input.count = 3;
278         input.pointer = in_params;
279
280         status = acpi_evaluate_object(ap->acpi_handle, "_STM", &input, NULL);
281
282         if (status == AE_NOT_FOUND)
283                 return -ENOENT;
284         if (ACPI_FAILURE(status)) {
285                 ata_port_printk(ap, KERN_ERR,
286                         "ACPI set timing mode failed (status=0x%x)\n", status);
287                 return -EINVAL;
288         }
289         return 0;
290 }
291
292 /**
293  * ata_dev_get_GTF - get the drive bootup default taskfile settings
294  * @dev: target ATA device
295  * @gtf: output parameter for buffer containing _GTF taskfile arrays
296  * @ptr_to_free: pointer which should be freed
297  *
298  * This applies to both PATA and SATA drives.
299  *
300  * The _GTF method has no input parameters.
301  * It returns a variable number of register set values (registers
302  * hex 1F1..1F7, taskfiles).
303  * The <variable number> is not known in advance, so have ACPI-CA
304  * allocate the buffer as needed and return it, then free it later.
305  *
306  * LOCKING:
307  * EH context.
308  *
309  * RETURNS:
310  * Number of taskfiles on success, 0 if _GTF doesn't exist or doesn't
311  * contain valid data.  -errno on other errors.
312  */
313 static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
314                            void **ptr_to_free)
315 {
316         struct ata_port *ap = dev->link->ap;
317         acpi_status status;
318         struct acpi_buffer output;
319         union acpi_object *out_obj;
320         int rc = 0;
321
322         /* set up output buffer */
323         output.length = ACPI_ALLOCATE_BUFFER;
324         output.pointer = NULL;  /* ACPI-CA sets this; save/free it later */
325
326         if (ata_msg_probe(ap))
327                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
328                                __FUNCTION__, ap->port_no);
329
330         /* _GTF has no input parameters */
331         status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output);
332
333         if (ACPI_FAILURE(status)) {
334                 if (status != AE_NOT_FOUND) {
335                         ata_dev_printk(dev, KERN_WARNING,
336                                        "_GTF evaluation failed (AE 0x%x)\n",
337                                        status);
338                         rc = -EIO;
339                 }
340                 goto out_free;
341         }
342
343         if (!output.length || !output.pointer) {
344                 if (ata_msg_probe(ap))
345                         ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
346                                 "length or ptr is NULL (0x%llx, 0x%p)\n",
347                                 __FUNCTION__,
348                                 (unsigned long long)output.length,
349                                 output.pointer);
350                 goto out_free;
351         }
352
353         out_obj = output.pointer;
354         if (out_obj->type != ACPI_TYPE_BUFFER) {
355                 ata_dev_printk(dev, KERN_WARNING,
356                                "_GTF unexpected object type 0x%x\n",
357                                out_obj->type);
358                 rc = -EINVAL;
359                 goto out_free;
360         }
361
362         if (out_obj->buffer.length % REGS_PER_GTF) {
363                 ata_dev_printk(dev, KERN_WARNING,
364                                "unexpected _GTF length (%d)\n",
365                                out_obj->buffer.length);
366                 rc = -EINVAL;
367                 goto out_free;
368         }
369
370         *ptr_to_free = out_obj;
371         *gtf = (void *)out_obj->buffer.pointer;
372         rc = out_obj->buffer.length / REGS_PER_GTF;
373
374         if (ata_msg_probe(ap))
375                 ata_dev_printk(dev, KERN_DEBUG, "%s: returning "
376                         "gtf=%p, gtf_count=%d, ptr_to_free=%p\n",
377                         __FUNCTION__, *gtf, rc, *ptr_to_free);
378         return rc;
379
380  out_free:
381         kfree(output.pointer);
382         return rc;
383 }
384
385 /**
386  * ata_acpi_cbl_80wire          -       Check for 80 wire cable
387  * @ap: Port to check
388  *
389  * Return 1 if the ACPI mode data for this port indicates the BIOS selected
390  * an 80wire mode.
391  */
392
393 int ata_acpi_cbl_80wire(struct ata_port *ap)
394 {
395         struct ata_acpi_gtm gtm;
396         int valid = 0;
397         
398         /* No _GTM data, no information */
399         if (ata_acpi_gtm(ap, &gtm) < 0)
400                 return 0;
401                 
402         /* Split timing, DMA enabled */
403         if ((gtm.flags & 0x11) == 0x11 && gtm.drive[0].dma < 55)
404                 valid |= 1;
405         if ((gtm.flags & 0x14) == 0x14 && gtm.drive[1].dma < 55)
406                 valid |= 2;
407         /* Shared timing, DMA enabled */
408         if ((gtm.flags & 0x11) == 0x01 && gtm.drive[0].dma < 55)
409                 valid |= 1;
410         if ((gtm.flags & 0x14) == 0x04 && gtm.drive[0].dma < 55)
411                 valid |= 2;
412
413         /* Drive check */
414         if ((valid & 1) && ata_dev_enabled(&ap->link.device[0]))
415                 return 1;
416         if ((valid & 2) && ata_dev_enabled(&ap->link.device[1]))
417                 return 1;
418         return 0;
419 }
420
421 EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
422
423 /**
424  * taskfile_load_raw - send taskfile registers to host controller
425  * @dev: target ATA device
426  * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
427  *
428  * Outputs ATA taskfile to standard ATA host controller using MMIO
429  * or PIO as indicated by the ATA_FLAG_MMIO flag.
430  * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
431  * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
432  * hob_lbal, hob_lbam, and hob_lbah.
433  *
434  * This function waits for idle (!BUSY and !DRQ) after writing
435  * registers.  If the control register has a new value, this
436  * function also waits for idle after writing control and before
437  * writing the remaining registers.
438  *
439  * LOCKING:
440  * EH context.
441  *
442  * RETURNS:
443  * 0 on success, -errno on failure.
444  */
445 static int taskfile_load_raw(struct ata_device *dev,
446                               const struct ata_acpi_gtf *gtf)
447 {
448         struct ata_port *ap = dev->link->ap;
449         struct ata_taskfile tf, rtf;
450         unsigned int err_mask;
451
452         if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
453             && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
454             && (gtf->tf[6] == 0))
455                 return 0;
456
457         ata_tf_init(dev, &tf);
458
459         /* convert gtf to tf */
460         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */
461         tf.protocol = ATA_PROT_NODATA;
462         tf.feature = gtf->tf[0];        /* 0x1f1 */
463         tf.nsect   = gtf->tf[1];        /* 0x1f2 */
464         tf.lbal    = gtf->tf[2];        /* 0x1f3 */
465         tf.lbam    = gtf->tf[3];        /* 0x1f4 */
466         tf.lbah    = gtf->tf[4];        /* 0x1f5 */
467         tf.device  = gtf->tf[5];        /* 0x1f6 */
468         tf.command = gtf->tf[6];        /* 0x1f7 */
469
470         if (ata_msg_probe(ap))
471                 ata_dev_printk(dev, KERN_DEBUG, "executing ACPI cmd "
472                                "%02x/%02x:%02x:%02x:%02x:%02x:%02x\n",
473                                tf.command, tf.feature, tf.nsect,
474                                tf.lbal, tf.lbam, tf.lbah, tf.device);
475
476         rtf = tf;
477         err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0);
478         if (err_mask) {
479                 ata_dev_printk(dev, KERN_ERR,
480                         "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
481                         "(Emask=0x%x Stat=0x%02x Err=0x%02x)\n",
482                         tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam,
483                         tf.lbah, tf.device, err_mask, rtf.command, rtf.feature);
484                 return -EIO;
485         }
486
487         return 0;
488 }
489
490 /**
491  * ata_acpi_exec_tfs - get then write drive taskfile settings
492  * @dev: target ATA device
493  *
494  * Evaluate _GTF and excute returned taskfiles.
495  *
496  * LOCKING:
497  * EH context.
498  *
499  * RETURNS:
500  * Number of executed taskfiles on success, 0 if _GTF doesn't exist or
501  * doesn't contain valid data.  -errno on other errors.
502  */
503 static int ata_acpi_exec_tfs(struct ata_device *dev)
504 {
505         struct ata_acpi_gtf *gtf = NULL;
506         void *ptr_to_free = NULL;
507         int gtf_count, i, rc;
508
509         /* get taskfiles */
510         rc = ata_dev_get_GTF(dev, &gtf, &ptr_to_free);
511         if (rc < 0)
512                 return rc;
513         gtf_count = rc;
514
515         /* execute them */
516         for (i = 0, rc = 0; i < gtf_count; i++) {
517                 int tmp;
518
519                 /* ACPI errors are eventually ignored.  Run till the
520                  * end even after errors.
521                  */
522                 tmp = taskfile_load_raw(dev, gtf++);
523                 if (!rc)
524                         rc = tmp;
525         }
526
527         kfree(ptr_to_free);
528
529         if (rc == 0)
530                 return gtf_count;
531         return rc;
532 }
533
534 /**
535  * ata_acpi_push_id - send Identify data to drive
536  * @dev: target ATA device
537  *
538  * _SDD ACPI object: for SATA mode only
539  * Must be after Identify (Packet) Device -- uses its data
540  * ATM this function never returns a failure.  It is an optional
541  * method and if it fails for whatever reason, we should still
542  * just keep going.
543  *
544  * LOCKING:
545  * EH context.
546  *
547  * RETURNS:
548  * 0 on success, -errno on failure.
549  */
550 static int ata_acpi_push_id(struct ata_device *dev)
551 {
552         struct ata_port *ap = dev->link->ap;
553         int err;
554         acpi_status status;
555         struct acpi_object_list input;
556         union acpi_object in_params[1];
557
558         if (ata_msg_probe(ap))
559                 ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
560                                __FUNCTION__, dev->devno, ap->port_no);
561
562         /* Give the drive Identify data to the drive via the _SDD method */
563         /* _SDD: set up input parameters */
564         input.count = 1;
565         input.pointer = in_params;
566         in_params[0].type = ACPI_TYPE_BUFFER;
567         in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
568         in_params[0].buffer.pointer = (u8 *)dev->id;
569         /* Output buffer: _SDD has no output */
570
571         /* It's OK for _SDD to be missing too. */
572         swap_buf_le16(dev->id, ATA_ID_WORDS);
573         status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL);
574         swap_buf_le16(dev->id, ATA_ID_WORDS);
575
576         err = ACPI_FAILURE(status) ? -EIO : 0;
577         if (err < 0)
578                 ata_dev_printk(dev, KERN_WARNING,
579                                "ACPI _SDD failed (AE 0x%x)\n", status);
580
581         return err;
582 }
583
584 /**
585  * ata_acpi_on_suspend - ATA ACPI hook called on suspend
586  * @ap: target ATA port
587  *
588  * This function is called when @ap is about to be suspended.  All
589  * devices are already put to sleep but the port_suspend() callback
590  * hasn't been executed yet.  Error return from this function aborts
591  * suspend.
592  *
593  * LOCKING:
594  * EH context.
595  *
596  * RETURNS:
597  * 0 on success, -errno on failure.
598  */
599 int ata_acpi_on_suspend(struct ata_port *ap)
600 {
601         unsigned long flags;
602         int rc;
603
604         /* proceed iff per-port acpi_handle is valid */
605         if (!ap->acpi_handle)
606                 return 0;
607         BUG_ON(ap->flags & ATA_FLAG_ACPI_SATA);
608
609         /* store timing parameters */
610         rc = ata_acpi_gtm(ap, &ap->acpi_gtm);
611
612         spin_lock_irqsave(ap->lock, flags);
613         if (rc == 0)
614                 ap->pflags |= ATA_PFLAG_GTM_VALID;
615         else
616                 ap->pflags &= ~ATA_PFLAG_GTM_VALID;
617         spin_unlock_irqrestore(ap->lock, flags);
618
619         if (rc == -ENOENT)
620                 rc = 0;
621         return rc;
622 }
623
624 /**
625  * ata_acpi_on_resume - ATA ACPI hook called on resume
626  * @ap: target ATA port
627  *
628  * This function is called when @ap is resumed - right after port
629  * itself is resumed but before any EH action is taken.
630  *
631  * LOCKING:
632  * EH context.
633  */
634 void ata_acpi_on_resume(struct ata_port *ap)
635 {
636         struct ata_device *dev;
637
638         if (ap->acpi_handle && (ap->pflags & ATA_PFLAG_GTM_VALID)) {
639                 BUG_ON(ap->flags & ATA_FLAG_ACPI_SATA);
640
641                 /* restore timing parameters */
642                 ata_acpi_stm(ap, &ap->acpi_gtm);
643         }
644
645         /* schedule _GTF */
646         ata_link_for_each_dev(dev, &ap->link)
647                 dev->flags |= ATA_DFLAG_ACPI_PENDING;
648 }
649
650 /**
651  * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
652  * @dev: target ATA device
653  *
654  * This function is called when @dev is about to be configured.
655  * IDENTIFY data might have been modified after this hook is run.
656  *
657  * LOCKING:
658  * EH context.
659  *
660  * RETURNS:
661  * Positive number if IDENTIFY data needs to be refreshed, 0 if not,
662  * -errno on failure.
663  */
664 int ata_acpi_on_devcfg(struct ata_device *dev)
665 {
666         struct ata_port *ap = dev->link->ap;
667         struct ata_eh_context *ehc = &ap->link.eh_context;
668         int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
669         int rc;
670
671         if (!dev->acpi_handle)
672                 return 0;
673
674         /* do we need to do _GTF? */
675         if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
676             !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
677                 return 0;
678
679         /* do _SDD if SATA */
680         if (acpi_sata) {
681                 rc = ata_acpi_push_id(dev);
682                 if (rc)
683                         goto acpi_err;
684         }
685
686         /* do _GTF */
687         rc = ata_acpi_exec_tfs(dev);
688         if (rc < 0)
689                 goto acpi_err;
690
691         dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
692
693         /* refresh IDENTIFY page if any _GTF command has been executed */
694         if (rc > 0) {
695                 rc = ata_dev_reread_id(dev, 0);
696                 if (rc < 0) {
697                         ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY "
698                                        "after ACPI commands\n");
699                         return rc;
700                 }
701         }
702
703         return 0;
704
705  acpi_err:
706         /* let EH retry on the first failure, disable ACPI on the second */
707         if (dev->flags & ATA_DFLAG_ACPI_FAILED) {
708                 ata_dev_printk(dev, KERN_WARNING, "ACPI on devcfg failed the "
709                                "second time, disabling (errno=%d)\n", rc);
710
711                 dev->acpi_handle = NULL;
712
713                 /* if port is working, request IDENTIFY reload and continue */
714                 if (!(ap->pflags & ATA_PFLAG_FROZEN))
715                         rc = 1;
716         }
717         dev->flags |= ATA_DFLAG_ACPI_FAILED;
718         return rc;
719 }