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