libata-core: Expose gtm methods for driver use
[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 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 EXPORT_SYMBOL_GPL(ata_acpi_gtm);
248
249 /**
250  * ata_acpi_stm - execute _STM
251  * @ap: target ATA port
252  * @stm: timing parameter to _STM
253  *
254  * Evaluate _STM with timing parameter @stm.
255  *
256  * LOCKING:
257  * EH context.
258  *
259  * RETURNS:
260  * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
261  */
262 int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
263 {
264         acpi_status status;
265         struct acpi_object_list         input;
266         union acpi_object               in_params[3];
267
268         in_params[0].type = ACPI_TYPE_BUFFER;
269         in_params[0].buffer.length = sizeof(struct ata_acpi_gtm);
270         in_params[0].buffer.pointer = (u8 *)stm;
271         /* Buffers for id may need byteswapping ? */
272         in_params[1].type = ACPI_TYPE_BUFFER;
273         in_params[1].buffer.length = 512;
274         in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
275         in_params[2].type = ACPI_TYPE_BUFFER;
276         in_params[2].buffer.length = 512;
277         in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
278
279         input.count = 3;
280         input.pointer = in_params;
281
282         status = acpi_evaluate_object(ap->acpi_handle, "_STM", &input, NULL);
283
284         if (status == AE_NOT_FOUND)
285                 return -ENOENT;
286         if (ACPI_FAILURE(status)) {
287                 ata_port_printk(ap, KERN_ERR,
288                         "ACPI set timing mode failed (status=0x%x)\n", status);
289                 return -EINVAL;
290         }
291         return 0;
292 }
293
294 EXPORT_SYMBOL_GPL(ata_acpi_stm);
295
296 /**
297  * ata_dev_get_GTF - get the drive bootup default taskfile settings
298  * @dev: target ATA device
299  * @gtf: output parameter for buffer containing _GTF taskfile arrays
300  * @ptr_to_free: pointer which should be freed
301  *
302  * This applies to both PATA and SATA drives.
303  *
304  * The _GTF method has no input parameters.
305  * It returns a variable number of register set values (registers
306  * hex 1F1..1F7, taskfiles).
307  * The <variable number> is not known in advance, so have ACPI-CA
308  * allocate the buffer as needed and return it, then free it later.
309  *
310  * LOCKING:
311  * EH context.
312  *
313  * RETURNS:
314  * Number of taskfiles on success, 0 if _GTF doesn't exist or doesn't
315  * contain valid data.  -errno on other errors.
316  */
317 static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
318                            void **ptr_to_free)
319 {
320         struct ata_port *ap = dev->link->ap;
321         acpi_status status;
322         struct acpi_buffer output;
323         union acpi_object *out_obj;
324         int rc = 0;
325
326         /* set up output buffer */
327         output.length = ACPI_ALLOCATE_BUFFER;
328         output.pointer = NULL;  /* ACPI-CA sets this; save/free it later */
329
330         if (ata_msg_probe(ap))
331                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
332                                __FUNCTION__, ap->port_no);
333
334         /* _GTF has no input parameters */
335         status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output);
336
337         if (ACPI_FAILURE(status)) {
338                 if (status != AE_NOT_FOUND) {
339                         ata_dev_printk(dev, KERN_WARNING,
340                                        "_GTF evaluation failed (AE 0x%x)\n",
341                                        status);
342                         rc = -EIO;
343                 }
344                 goto out_free;
345         }
346
347         if (!output.length || !output.pointer) {
348                 if (ata_msg_probe(ap))
349                         ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
350                                 "length or ptr is NULL (0x%llx, 0x%p)\n",
351                                 __FUNCTION__,
352                                 (unsigned long long)output.length,
353                                 output.pointer);
354                 goto out_free;
355         }
356
357         out_obj = output.pointer;
358         if (out_obj->type != ACPI_TYPE_BUFFER) {
359                 ata_dev_printk(dev, KERN_WARNING,
360                                "_GTF unexpected object type 0x%x\n",
361                                out_obj->type);
362                 rc = -EINVAL;
363                 goto out_free;
364         }
365
366         if (out_obj->buffer.length % REGS_PER_GTF) {
367                 ata_dev_printk(dev, KERN_WARNING,
368                                "unexpected _GTF length (%d)\n",
369                                out_obj->buffer.length);
370                 rc = -EINVAL;
371                 goto out_free;
372         }
373
374         *ptr_to_free = out_obj;
375         *gtf = (void *)out_obj->buffer.pointer;
376         rc = out_obj->buffer.length / REGS_PER_GTF;
377
378         if (ata_msg_probe(ap))
379                 ata_dev_printk(dev, KERN_DEBUG, "%s: returning "
380                         "gtf=%p, gtf_count=%d, ptr_to_free=%p\n",
381                         __FUNCTION__, *gtf, rc, *ptr_to_free);
382         return rc;
383
384  out_free:
385         kfree(output.pointer);
386         return rc;
387 }
388
389 /**
390  * ata_acpi_cbl_80wire          -       Check for 80 wire cable
391  * @ap: Port to check
392  *
393  * Return 1 if the ACPI mode data for this port indicates the BIOS selected
394  * an 80wire mode.
395  */
396
397 int ata_acpi_cbl_80wire(struct ata_port *ap)
398 {
399         struct ata_acpi_gtm gtm;
400         int valid = 0;
401         
402         /* No _GTM data, no information */
403         if (ata_acpi_gtm(ap, &gtm) < 0)
404                 return 0;
405                 
406         /* Split timing, DMA enabled */
407         if ((gtm.flags & 0x11) == 0x11 && gtm.drive[0].dma < 55)
408                 valid |= 1;
409         if ((gtm.flags & 0x14) == 0x14 && gtm.drive[1].dma < 55)
410                 valid |= 2;
411         /* Shared timing, DMA enabled */
412         if ((gtm.flags & 0x11) == 0x01 && gtm.drive[0].dma < 55)
413                 valid |= 1;
414         if ((gtm.flags & 0x14) == 0x04 && gtm.drive[0].dma < 55)
415                 valid |= 2;
416
417         /* Drive check */
418         if ((valid & 1) && ata_dev_enabled(&ap->link.device[0]))
419                 return 1;
420         if ((valid & 2) && ata_dev_enabled(&ap->link.device[1]))
421                 return 1;
422         return 0;
423 }
424
425 EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
426
427 /**
428  * taskfile_load_raw - send taskfile registers to host controller
429  * @dev: target ATA device
430  * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
431  *
432  * Outputs ATA taskfile to standard ATA host controller using MMIO
433  * or PIO as indicated by the ATA_FLAG_MMIO flag.
434  * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
435  * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
436  * hob_lbal, hob_lbam, and hob_lbah.
437  *
438  * This function waits for idle (!BUSY and !DRQ) after writing
439  * registers.  If the control register has a new value, this
440  * function also waits for idle after writing control and before
441  * writing the remaining registers.
442  *
443  * LOCKING:
444  * EH context.
445  *
446  * RETURNS:
447  * 0 on success, -errno on failure.
448  */
449 static int taskfile_load_raw(struct ata_device *dev,
450                               const struct ata_acpi_gtf *gtf)
451 {
452         struct ata_port *ap = dev->link->ap;
453         struct ata_taskfile tf, rtf;
454         unsigned int err_mask;
455
456         if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
457             && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
458             && (gtf->tf[6] == 0))
459                 return 0;
460
461         ata_tf_init(dev, &tf);
462
463         /* convert gtf to tf */
464         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */
465         tf.protocol = ATA_PROT_NODATA;
466         tf.feature = gtf->tf[0];        /* 0x1f1 */
467         tf.nsect   = gtf->tf[1];        /* 0x1f2 */
468         tf.lbal    = gtf->tf[2];        /* 0x1f3 */
469         tf.lbam    = gtf->tf[3];        /* 0x1f4 */
470         tf.lbah    = gtf->tf[4];        /* 0x1f5 */
471         tf.device  = gtf->tf[5];        /* 0x1f6 */
472         tf.command = gtf->tf[6];        /* 0x1f7 */
473
474         if (ata_msg_probe(ap))
475                 ata_dev_printk(dev, KERN_DEBUG, "executing ACPI cmd "
476                                "%02x/%02x:%02x:%02x:%02x:%02x:%02x\n",
477                                tf.command, tf.feature, tf.nsect,
478                                tf.lbal, tf.lbam, tf.lbah, tf.device);
479
480         rtf = tf;
481         err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0);
482         if (err_mask) {
483                 ata_dev_printk(dev, KERN_ERR,
484                         "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
485                         "(Emask=0x%x Stat=0x%02x Err=0x%02x)\n",
486                         tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam,
487                         tf.lbah, tf.device, err_mask, rtf.command, rtf.feature);
488                 return -EIO;
489         }
490
491         return 0;
492 }
493
494 /**
495  * ata_acpi_exec_tfs - get then write drive taskfile settings
496  * @dev: target ATA device
497  *
498  * Evaluate _GTF and excute returned taskfiles.
499  *
500  * LOCKING:
501  * EH context.
502  *
503  * RETURNS:
504  * Number of executed taskfiles on success, 0 if _GTF doesn't exist or
505  * doesn't contain valid data.  -errno on other errors.
506  */
507 static int ata_acpi_exec_tfs(struct ata_device *dev)
508 {
509         struct ata_acpi_gtf *gtf = NULL;
510         void *ptr_to_free = NULL;
511         int gtf_count, i, rc;
512
513         /* get taskfiles */
514         rc = ata_dev_get_GTF(dev, &gtf, &ptr_to_free);
515         if (rc < 0)
516                 return rc;
517         gtf_count = rc;
518
519         /* execute them */
520         for (i = 0, rc = 0; i < gtf_count; i++) {
521                 int tmp;
522
523                 /* ACPI errors are eventually ignored.  Run till the
524                  * end even after errors.
525                  */
526                 tmp = taskfile_load_raw(dev, gtf++);
527                 if (!rc)
528                         rc = tmp;
529         }
530
531         kfree(ptr_to_free);
532
533         if (rc == 0)
534                 return gtf_count;
535         return rc;
536 }
537
538 /**
539  * ata_acpi_push_id - send Identify data to drive
540  * @dev: target ATA device
541  *
542  * _SDD ACPI object: for SATA mode only
543  * Must be after Identify (Packet) Device -- uses its data
544  * ATM this function never returns a failure.  It is an optional
545  * method and if it fails for whatever reason, we should still
546  * just keep going.
547  *
548  * LOCKING:
549  * EH context.
550  *
551  * RETURNS:
552  * 0 on success, -errno on failure.
553  */
554 static int ata_acpi_push_id(struct ata_device *dev)
555 {
556         struct ata_port *ap = dev->link->ap;
557         int err;
558         acpi_status status;
559         struct acpi_object_list input;
560         union acpi_object in_params[1];
561
562         if (ata_msg_probe(ap))
563                 ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
564                                __FUNCTION__, dev->devno, ap->port_no);
565
566         /* Give the drive Identify data to the drive via the _SDD method */
567         /* _SDD: set up input parameters */
568         input.count = 1;
569         input.pointer = in_params;
570         in_params[0].type = ACPI_TYPE_BUFFER;
571         in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
572         in_params[0].buffer.pointer = (u8 *)dev->id;
573         /* Output buffer: _SDD has no output */
574
575         /* It's OK for _SDD to be missing too. */
576         swap_buf_le16(dev->id, ATA_ID_WORDS);
577         status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL);
578         swap_buf_le16(dev->id, ATA_ID_WORDS);
579
580         err = ACPI_FAILURE(status) ? -EIO : 0;
581         if (err < 0)
582                 ata_dev_printk(dev, KERN_WARNING,
583                                "ACPI _SDD failed (AE 0x%x)\n", status);
584
585         return err;
586 }
587
588 /**
589  * ata_acpi_on_suspend - ATA ACPI hook called on suspend
590  * @ap: target ATA port
591  *
592  * This function is called when @ap is about to be suspended.  All
593  * devices are already put to sleep but the port_suspend() callback
594  * hasn't been executed yet.  Error return from this function aborts
595  * suspend.
596  *
597  * LOCKING:
598  * EH context.
599  *
600  * RETURNS:
601  * 0 on success, -errno on failure.
602  */
603 int ata_acpi_on_suspend(struct ata_port *ap)
604 {
605         unsigned long flags;
606         int rc;
607
608         /* proceed iff per-port acpi_handle is valid */
609         if (!ap->acpi_handle)
610                 return 0;
611         BUG_ON(ap->flags & ATA_FLAG_ACPI_SATA);
612
613         /* store timing parameters */
614         rc = ata_acpi_gtm(ap, &ap->acpi_gtm);
615
616         spin_lock_irqsave(ap->lock, flags);
617         if (rc == 0)
618                 ap->pflags |= ATA_PFLAG_GTM_VALID;
619         else
620                 ap->pflags &= ~ATA_PFLAG_GTM_VALID;
621         spin_unlock_irqrestore(ap->lock, flags);
622
623         if (rc == -ENOENT)
624                 rc = 0;
625         return rc;
626 }
627
628 /**
629  * ata_acpi_on_resume - ATA ACPI hook called on resume
630  * @ap: target ATA port
631  *
632  * This function is called when @ap is resumed - right after port
633  * itself is resumed but before any EH action is taken.
634  *
635  * LOCKING:
636  * EH context.
637  */
638 void ata_acpi_on_resume(struct ata_port *ap)
639 {
640         struct ata_device *dev;
641
642         if (ap->acpi_handle && (ap->pflags & ATA_PFLAG_GTM_VALID)) {
643                 BUG_ON(ap->flags & ATA_FLAG_ACPI_SATA);
644
645                 /* restore timing parameters */
646                 ata_acpi_stm(ap, &ap->acpi_gtm);
647         }
648
649         /* schedule _GTF */
650         ata_link_for_each_dev(dev, &ap->link)
651                 dev->flags |= ATA_DFLAG_ACPI_PENDING;
652 }
653
654 /**
655  * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
656  * @dev: target ATA device
657  *
658  * This function is called when @dev is about to be configured.
659  * IDENTIFY data might have been modified after this hook is run.
660  *
661  * LOCKING:
662  * EH context.
663  *
664  * RETURNS:
665  * Positive number if IDENTIFY data needs to be refreshed, 0 if not,
666  * -errno on failure.
667  */
668 int ata_acpi_on_devcfg(struct ata_device *dev)
669 {
670         struct ata_port *ap = dev->link->ap;
671         struct ata_eh_context *ehc = &ap->link.eh_context;
672         int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
673         int rc;
674
675         if (!dev->acpi_handle)
676                 return 0;
677
678         /* do we need to do _GTF? */
679         if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
680             !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
681                 return 0;
682
683         /* do _SDD if SATA */
684         if (acpi_sata) {
685                 rc = ata_acpi_push_id(dev);
686                 if (rc)
687                         goto acpi_err;
688         }
689
690         /* do _GTF */
691         rc = ata_acpi_exec_tfs(dev);
692         if (rc < 0)
693                 goto acpi_err;
694
695         dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
696
697         /* refresh IDENTIFY page if any _GTF command has been executed */
698         if (rc > 0) {
699                 rc = ata_dev_reread_id(dev, 0);
700                 if (rc < 0) {
701                         ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY "
702                                        "after ACPI commands\n");
703                         return rc;
704                 }
705         }
706
707         return 0;
708
709  acpi_err:
710         /* let EH retry on the first failure, disable ACPI on the second */
711         if (dev->flags & ATA_DFLAG_ACPI_FAILED) {
712                 ata_dev_printk(dev, KERN_WARNING, "ACPI on devcfg failed the "
713                                "second time, disabling (errno=%d)\n", rc);
714
715                 dev->acpi_handle = NULL;
716
717                 /* if port is working, request IDENTIFY reload and continue */
718                 if (!(ap->pflags & ATA_PFLAG_FROZEN))
719                         rc = 1;
720         }
721         dev->flags |= ATA_DFLAG_ACPI_FAILED;
722         return rc;
723 }