Merge master.kernel.org:/home/rmk/linux-2.6-arm
[linux-2.6] / 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 "libata.h"
18
19 #include <acpi/acpi_bus.h>
20 #include <acpi/acnames.h>
21 #include <acpi/acnamesp.h>
22 #include <acpi/acparser.h>
23 #include <acpi/acexcep.h>
24 #include <acpi/acmacros.h>
25 #include <acpi/actypes.h>
26
27 #define SATA_ROOT_PORT(x)       (((x) >> 16) & 0xffff)
28 #define SATA_PORT_NUMBER(x)     ((x) & 0xffff)  /* or NO_PORT_MULT */
29 #define NO_PORT_MULT            0xffff
30 #define SATA_ADR_RSVD           0xffffffff
31
32 #define REGS_PER_GTF            7
33 struct taskfile_array {
34         u8      tfa[REGS_PER_GTF];      /* regs. 0x1f1 - 0x1f7 */
35 };
36
37 /*
38  *      Helper - belongs in the PCI layer somewhere eventually
39  */
40 static int is_pci_dev(struct device *dev)
41 {
42         return (dev->bus == &pci_bus_type);
43 }
44
45 /**
46  * sata_get_dev_handle - finds acpi_handle and PCI device.function
47  * @dev: device to locate
48  * @handle: returned acpi_handle for @dev
49  * @pcidevfn: return PCI device.func for @dev
50  *
51  * This function is somewhat SATA-specific.  Or at least the
52  * PATA & SATA versions of this function are different,
53  * so it's not entirely generic code.
54  *
55  * Returns 0 on success, <0 on error.
56  */
57 static int sata_get_dev_handle(struct device *dev, acpi_handle *handle,
58                                         acpi_integer *pcidevfn)
59 {
60         struct pci_dev  *pci_dev;
61         acpi_integer    addr;
62
63         if (!is_pci_dev(dev))
64                 return -ENODEV;
65
66         pci_dev = to_pci_dev(dev);      /* NOTE: PCI-specific */
67         /* Please refer to the ACPI spec for the syntax of _ADR. */
68         addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
69         *pcidevfn = addr;
70         *handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr);
71         if (!*handle)
72                 return -ENODEV;
73         return 0;
74 }
75
76 /**
77  * pata_get_dev_handle - finds acpi_handle and PCI device.function
78  * @dev: device to locate
79  * @handle: returned acpi_handle for @dev
80  * @pcidevfn: return PCI device.func for @dev
81  *
82  * The PATA and SATA versions of this function are different.
83  *
84  * Returns 0 on success, <0 on error.
85  */
86 static int pata_get_dev_handle(struct device *dev, acpi_handle *handle,
87                                 acpi_integer *pcidevfn)
88 {
89         unsigned int bus, devnum, func;
90         acpi_integer addr;
91         acpi_handle dev_handle, parent_handle;
92         struct acpi_buffer buffer = {.length = ACPI_ALLOCATE_BUFFER,
93                                         .pointer = NULL};
94         acpi_status status;
95         struct acpi_device_info *dinfo = NULL;
96         int ret = -ENODEV;
97         struct pci_dev *pdev;
98
99         if (!is_pci_dev(dev))
100                 return -ENODEV;
101
102         pdev = to_pci_dev(dev);
103
104         bus = pdev->bus->number;
105         devnum = PCI_SLOT(pdev->devfn);
106         func = PCI_FUNC(pdev->devfn);
107
108         dev_handle = DEVICE_ACPI_HANDLE(dev);
109         parent_handle = DEVICE_ACPI_HANDLE(dev->parent);
110
111         status = acpi_get_object_info(parent_handle, &buffer);
112         if (ACPI_FAILURE(status))
113                 goto err;
114
115         dinfo = buffer.pointer;
116         if (dinfo && (dinfo->valid & ACPI_VALID_ADR) &&
117             dinfo->address == bus) {
118                 /* ACPI spec for _ADR for PCI bus: */
119                 addr = (acpi_integer)(devnum << 16 | func);
120                 *pcidevfn = addr;
121                 *handle = dev_handle;
122         } else {
123                 goto err;
124         }
125
126         if (!*handle)
127                 goto err;
128         ret = 0;
129 err:
130         kfree(dinfo);
131         return ret;
132 }
133
134 struct walk_info {              /* can be trimmed some */
135         struct device   *dev;
136         struct acpi_device *adev;
137         acpi_handle     handle;
138         acpi_integer    pcidevfn;
139         unsigned int    drivenum;
140         acpi_handle     obj_handle;
141         struct ata_port *ataport;
142         struct ata_device *atadev;
143         u32             sata_adr;
144         int             status;
145         char            basepath[ACPI_PATHNAME_MAX];
146         int             basepath_len;
147 };
148
149 static acpi_status get_devices(acpi_handle handle,
150                                 u32 level, void *context, void **return_value)
151 {
152         acpi_status             status;
153         struct walk_info        *winfo = context;
154         struct acpi_buffer      namebuf = {ACPI_ALLOCATE_BUFFER, NULL};
155         char                    *pathname;
156         struct acpi_buffer      buffer;
157         struct acpi_device_info *dinfo;
158
159         status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &namebuf);
160         if (status)
161                 goto ret;
162         pathname = namebuf.pointer;
163
164         buffer.length = ACPI_ALLOCATE_BUFFER;
165         buffer.pointer = NULL;
166         status = acpi_get_object_info(handle, &buffer);
167         if (ACPI_FAILURE(status))
168                 goto out2;
169
170         dinfo = buffer.pointer;
171
172         /* find full device path name for pcidevfn */
173         if (dinfo && (dinfo->valid & ACPI_VALID_ADR) &&
174             dinfo->address == winfo->pcidevfn) {
175                 if (ata_msg_probe(winfo->ataport))
176                         ata_dev_printk(winfo->atadev, KERN_DEBUG,
177                                 ":%s: matches pcidevfn (0x%llx)\n",
178                                 pathname, winfo->pcidevfn);
179                 strlcpy(winfo->basepath, pathname,
180                         sizeof(winfo->basepath));
181                 winfo->basepath_len = strlen(pathname);
182                 goto out;
183         }
184
185         /* if basepath is not yet known, ignore this object */
186         if (!winfo->basepath_len)
187                 goto out;
188
189         /* if this object is in scope of basepath, maybe use it */
190         if (strncmp(pathname, winfo->basepath,
191             winfo->basepath_len) == 0) {
192                 if (!(dinfo->valid & ACPI_VALID_ADR))
193                         goto out;
194                 if (ata_msg_probe(winfo->ataport))
195                         ata_dev_printk(winfo->atadev, KERN_DEBUG,
196                                 "GOT ONE: (%s) root_port = 0x%llx,"
197                                 " port_num = 0x%llx\n", pathname,
198                                 SATA_ROOT_PORT(dinfo->address),
199                                 SATA_PORT_NUMBER(dinfo->address));
200                 /* heuristics: */
201                 if (SATA_PORT_NUMBER(dinfo->address) != NO_PORT_MULT)
202                         if (ata_msg_probe(winfo->ataport))
203                                 ata_dev_printk(winfo->atadev,
204                                         KERN_DEBUG, "warning: don't"
205                                         " know how to handle SATA port"
206                                         " multiplier\n");
207                 if (SATA_ROOT_PORT(dinfo->address) ==
208                         winfo->ataport->port_no &&
209                     SATA_PORT_NUMBER(dinfo->address) == NO_PORT_MULT) {
210                         if (ata_msg_probe(winfo->ataport))
211                                 ata_dev_printk(winfo->atadev,
212                                         KERN_DEBUG,
213                                         "THIS ^^^^^ is the requested"
214                                         " SATA drive (handle = 0x%p)\n",
215                                         handle);
216                         winfo->sata_adr = dinfo->address;
217                         winfo->obj_handle = handle;
218                 }
219         }
220 out:
221         kfree(dinfo);
222 out2:
223         kfree(pathname);
224
225 ret:
226         return status;
227 }
228
229 /* Get the SATA drive _ADR object. */
230 static int get_sata_adr(struct device *dev, acpi_handle handle,
231                         acpi_integer pcidevfn, unsigned int drive,
232                         struct ata_port *ap,
233                         struct ata_device *atadev, u32 *dev_adr)
234 {
235         acpi_status     status;
236         struct walk_info *winfo;
237         int             err = -ENOMEM;
238
239         winfo = kzalloc(sizeof(struct walk_info), GFP_KERNEL);
240         if (!winfo)
241                 goto out;
242
243         winfo->dev = dev;
244         winfo->atadev = atadev;
245         winfo->ataport = ap;
246         if (acpi_bus_get_device(handle, &winfo->adev) < 0)
247                 if (ata_msg_probe(ap))
248                         ata_dev_printk(winfo->atadev, KERN_DEBUG,
249                                 "acpi_bus_get_device failed\n");
250         winfo->handle = handle;
251         winfo->pcidevfn = pcidevfn;
252         winfo->drivenum = drive;
253
254         status = acpi_get_devices(NULL, get_devices, winfo, NULL);
255         if (ACPI_FAILURE(status)) {
256                 if (ata_msg_probe(ap))
257                         ata_dev_printk(winfo->atadev, KERN_DEBUG,
258                                 "%s: acpi_get_devices failed\n",
259                                 __FUNCTION__);
260                 err = -ENODEV;
261         } else {
262                 *dev_adr = winfo->sata_adr;
263                 atadev->obj_handle = winfo->obj_handle;
264                 err = 0;
265         }
266         kfree(winfo);
267 out:
268         return err;
269 }
270
271 /**
272  * do_drive_get_GTF - get the drive bootup default taskfile settings
273  * @dev: target ATA device
274  * @gtf_length: number of bytes of _GTF data returned at @gtf_address
275  * @gtf_address: buffer containing _GTF taskfile arrays
276  *
277  * This applies to both PATA and SATA drives.
278  *
279  * The _GTF method has no input parameters.
280  * It returns a variable number of register set values (registers
281  * hex 1F1..1F7, taskfiles).
282  * The <variable number> is not known in advance, so have ACPI-CA
283  * allocate the buffer as needed and return it, then free it later.
284  *
285  * The returned @gtf_length and @gtf_address are only valid if the
286  * function return value is 0.
287  */
288 static int do_drive_get_GTF(struct ata_device *dev, unsigned int *gtf_length,
289                             unsigned long *gtf_address, unsigned long *obj_loc)
290 {
291         struct ata_port *ap = dev->ap;
292         acpi_status status;
293         acpi_handle dev_handle = NULL;
294         acpi_handle chan_handle, drive_handle;
295         acpi_integer pcidevfn = 0;
296         u32 dev_adr;
297         struct acpi_buffer output;
298         union acpi_object *out_obj;
299         struct device *gdev = ap->host->dev;
300         int err = -ENODEV;
301
302         *gtf_length = 0;
303         *gtf_address = 0UL;
304         *obj_loc = 0UL;
305
306         if (libata_noacpi)
307                 return 0;
308
309         if (ata_msg_probe(ap))
310                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
311                                __FUNCTION__, ap->port_no);
312
313         if (!ata_dev_enabled(dev) || (ap->flags & ATA_FLAG_DISABLED)) {
314                 if (ata_msg_probe(ap))
315                         ata_dev_printk(dev, KERN_DEBUG, "%s: ERR: "
316                                 "ata_dev_present: %d, PORT_DISABLED: %lu\n",
317                                 __FUNCTION__, ata_dev_enabled(dev),
318                                 ap->flags & ATA_FLAG_DISABLED);
319                 goto out;
320         }
321
322         /* Don't continue if device has no _ADR method.
323          * _GTF is intended for known motherboard devices. */
324         if (!(ap->flags & ATA_FLAG_ACPI_SATA)) {
325                 err = pata_get_dev_handle(gdev, &dev_handle, &pcidevfn);
326                 if (err < 0) {
327                         if (ata_msg_probe(ap))
328                                 ata_dev_printk(dev, KERN_DEBUG,
329                                         "%s: pata_get_dev_handle failed (%d)\n",
330                                         __FUNCTION__, err);
331                         goto out;
332                 }
333         } else {
334                 err = sata_get_dev_handle(gdev, &dev_handle, &pcidevfn);
335                 if (err < 0) {
336                         if (ata_msg_probe(ap))
337                                 ata_dev_printk(dev, KERN_DEBUG,
338                                         "%s: sata_get_dev_handle failed (%d\n",
339                                         __FUNCTION__, err);
340                         goto out;
341                 }
342         }
343
344         /* Get this drive's _ADR info. if not already known. */
345         if (!dev->obj_handle) {
346                 if (!(ap->flags & ATA_FLAG_ACPI_SATA)) {
347                         /* get child objects of dev_handle == channel objects,
348                          * + _their_ children == drive objects */
349                         /* channel is ap->port_no */
350                         chan_handle = acpi_get_child(dev_handle,
351                                                 ap->port_no);
352                         if (ata_msg_probe(ap))
353                                 ata_dev_printk(dev, KERN_DEBUG,
354                                         "%s: chan adr=%d: chan_handle=0x%p\n",
355                                         __FUNCTION__, ap->port_no,
356                                         chan_handle);
357                         if (!chan_handle) {
358                                 err = -ENODEV;
359                                 goto out;
360                         }
361                         /* TBD: could also check ACPI object VALID bits */
362                         drive_handle = acpi_get_child(chan_handle, dev->devno);
363                         if (!drive_handle) {
364                                 err = -ENODEV;
365                                 goto out;
366                         }
367                         dev_adr = dev->devno;
368                         dev->obj_handle = drive_handle;
369                 } else {        /* for SATA mode */
370                         dev_adr = SATA_ADR_RSVD;
371                         err = get_sata_adr(gdev, dev_handle, pcidevfn, 0,
372                                         ap, dev, &dev_adr);
373                 }
374                 if (err < 0 || dev_adr == SATA_ADR_RSVD ||
375                     !dev->obj_handle) {
376                         if (ata_msg_probe(ap))
377                                 ata_dev_printk(dev, KERN_DEBUG,
378                                         "%s: get_sata/pata_adr failed: "
379                                         "err=%d, dev_adr=%u, obj_handle=0x%p\n",
380                                         __FUNCTION__, err, dev_adr,
381                                         dev->obj_handle);
382                         goto out;
383                 }
384         }
385
386         /* Setting up output buffer */
387         output.length = ACPI_ALLOCATE_BUFFER;
388         output.pointer = NULL;  /* ACPI-CA sets this; save/free it later */
389
390         /* _GTF has no input parameters */
391         err = -EIO;
392         status = acpi_evaluate_object(dev->obj_handle, "_GTF",
393                                         NULL, &output);
394         if (ACPI_FAILURE(status)) {
395                 if (ata_msg_probe(ap))
396                         ata_dev_printk(dev, KERN_DEBUG,
397                                 "%s: Run _GTF error: status = 0x%x\n",
398                                 __FUNCTION__, status);
399                 goto out;
400         }
401
402         if (!output.length || !output.pointer) {
403                 if (ata_msg_probe(ap))
404                         ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
405                                 "length or ptr is NULL (0x%llx, 0x%p)\n",
406                                 __FUNCTION__,
407                                 (unsigned long long)output.length,
408                                 output.pointer);
409                 kfree(output.pointer);
410                 goto out;
411         }
412
413         out_obj = output.pointer;
414         if (out_obj->type != ACPI_TYPE_BUFFER) {
415                 kfree(output.pointer);
416                 if (ata_msg_probe(ap))
417                         ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
418                                 "error: expected object type of "
419                                 " ACPI_TYPE_BUFFER, got 0x%x\n",
420                                 __FUNCTION__, out_obj->type);
421                 err = -ENOENT;
422                 goto out;
423         }
424
425         if (!out_obj->buffer.length || !out_obj->buffer.pointer ||
426             out_obj->buffer.length % REGS_PER_GTF) {
427                 if (ata_msg_drv(ap))
428                         ata_dev_printk(dev, KERN_ERR,
429                                 "%s: unexpected GTF length (%d) or addr (0x%p)\n",
430                                 __FUNCTION__, out_obj->buffer.length,
431                                 out_obj->buffer.pointer);
432                 err = -ENOENT;
433                 goto out;
434         }
435
436         *gtf_length = out_obj->buffer.length;
437         *gtf_address = (unsigned long)out_obj->buffer.pointer;
438         *obj_loc = (unsigned long)out_obj;
439         if (ata_msg_probe(ap))
440                 ata_dev_printk(dev, KERN_DEBUG, "%s: returning "
441                         "gtf_length=%d, gtf_address=0x%lx, obj_loc=0x%lx\n",
442                         __FUNCTION__, *gtf_length, *gtf_address, *obj_loc);
443         err = 0;
444 out:
445         return err;
446 }
447
448 /**
449  * taskfile_load_raw - send taskfile registers to host controller
450  * @dev: target ATA device
451  * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
452  *
453  * Outputs ATA taskfile to standard ATA host controller using MMIO
454  * or PIO as indicated by the ATA_FLAG_MMIO flag.
455  * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
456  * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
457  * hob_lbal, hob_lbam, and hob_lbah.
458  *
459  * This function waits for idle (!BUSY and !DRQ) after writing
460  * registers.  If the control register has a new value, this
461  * function also waits for idle after writing control and before
462  * writing the remaining registers.
463  *
464  * LOCKING: TBD:
465  * Inherited from caller.
466  */
467 static void taskfile_load_raw(struct ata_device *dev,
468                               const struct taskfile_array *gtf)
469 {
470         struct ata_port *ap = dev->ap;
471         struct ata_taskfile tf;
472         unsigned int err;
473
474         if (ata_msg_probe(ap))
475                 ata_dev_printk(dev, KERN_DEBUG, "%s: (0x1f1-1f7): hex: "
476                         "%02x %02x %02x %02x %02x %02x %02x\n",
477                         __FUNCTION__,
478                         gtf->tfa[0], gtf->tfa[1], gtf->tfa[2],
479                         gtf->tfa[3], gtf->tfa[4], gtf->tfa[5], gtf->tfa[6]);
480
481         if ((gtf->tfa[0] == 0) && (gtf->tfa[1] == 0) && (gtf->tfa[2] == 0)
482             && (gtf->tfa[3] == 0) && (gtf->tfa[4] == 0) && (gtf->tfa[5] == 0)
483             && (gtf->tfa[6] == 0))
484                 return;
485
486         ata_tf_init(dev, &tf);
487
488         /* convert gtf to tf */
489         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */
490         tf.protocol = ATA_PROT_NODATA;
491         tf.feature = gtf->tfa[0];       /* 0x1f1 */
492         tf.nsect   = gtf->tfa[1];       /* 0x1f2 */
493         tf.lbal    = gtf->tfa[2];       /* 0x1f3 */
494         tf.lbam    = gtf->tfa[3];       /* 0x1f4 */
495         tf.lbah    = gtf->tfa[4];       /* 0x1f5 */
496         tf.device  = gtf->tfa[5];       /* 0x1f6 */
497         tf.command = gtf->tfa[6];       /* 0x1f7 */
498
499         err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
500         if (err && ata_msg_probe(ap))
501                 ata_dev_printk(dev, KERN_ERR,
502                         "%s: ata_exec_internal failed: %u\n",
503                         __FUNCTION__, err);
504 }
505
506 /**
507  * do_drive_set_taskfiles - write the drive taskfile settings from _GTF
508  * @dev: target ATA device
509  * @gtf_length: total number of bytes of _GTF taskfiles
510  * @gtf_address: location of _GTF taskfile arrays
511  *
512  * This applies to both PATA and SATA drives.
513  *
514  * Write {gtf_address, length gtf_length} in groups of
515  * REGS_PER_GTF bytes.
516  */
517 static int do_drive_set_taskfiles(struct ata_device *dev,
518                                   unsigned int gtf_length,
519                                   unsigned long gtf_address)
520 {
521         struct ata_port *ap = dev->ap;
522         int err = -ENODEV;
523         int gtf_count = gtf_length / REGS_PER_GTF;
524         int ix;
525         struct taskfile_array   *gtf;
526
527         if (ata_msg_probe(ap))
528                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
529                                __FUNCTION__, ap->port_no);
530
531         if (libata_noacpi || !(ap->flags & ATA_FLAG_ACPI_SATA))
532                 return 0;
533
534         if (!ata_dev_enabled(dev) || (ap->flags & ATA_FLAG_DISABLED))
535                 goto out;
536         if (!gtf_count)         /* shouldn't be here */
537                 goto out;
538
539         if (gtf_length % REGS_PER_GTF) {
540                 if (ata_msg_drv(ap))
541                         ata_dev_printk(dev, KERN_ERR,
542                                 "%s: unexpected GTF length (%d)\n",
543                                 __FUNCTION__, gtf_length);
544                 goto out;
545         }
546
547         for (ix = 0; ix < gtf_count; ix++) {
548                 gtf = (struct taskfile_array *)
549                         (gtf_address + ix * REGS_PER_GTF);
550
551                 /* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */
552                 taskfile_load_raw(dev, gtf);
553         }
554
555         err = 0;
556 out:
557         return err;
558 }
559
560 /**
561  * ata_acpi_exec_tfs - get then write drive taskfile settings
562  * @ap: the ata_port for the drive
563  *
564  * This applies to both PATA and SATA drives.
565  */
566 int ata_acpi_exec_tfs(struct ata_port *ap)
567 {
568         int ix;
569         int ret = 0;
570         unsigned int gtf_length;
571         unsigned long gtf_address;
572         unsigned long obj_loc;
573
574         if (libata_noacpi)
575                 return 0;
576         /*
577          * TBD - implement PATA support.  For now,
578          * we should not run GTF on PATA devices since some
579          * PATA require execution of GTM/STM before GTF.
580          */
581         if (!(ap->flags & ATA_FLAG_ACPI_SATA))
582                 return 0;
583
584         for (ix = 0; ix < ATA_MAX_DEVICES; ix++) {
585                 struct ata_device *dev = &ap->device[ix];
586
587                 if (!ata_dev_enabled(dev))
588                         continue;
589
590                 ret = do_drive_get_GTF(dev, &gtf_length, &gtf_address,
591                                        &obj_loc);
592                 if (ret < 0) {
593                         if (ata_msg_probe(ap))
594                                 ata_port_printk(ap, KERN_DEBUG,
595                                         "%s: get_GTF error (%d)\n",
596                                         __FUNCTION__, ret);
597                         break;
598                 }
599
600                 ret = do_drive_set_taskfiles(dev, gtf_length, gtf_address);
601                 kfree((void *)obj_loc);
602                 if (ret < 0) {
603                         if (ata_msg_probe(ap))
604                                 ata_port_printk(ap, KERN_DEBUG,
605                                         "%s: set_taskfiles error (%d)\n",
606                                         __FUNCTION__, ret);
607                         break;
608                 }
609         }
610
611         return ret;
612 }
613
614 /**
615  * ata_acpi_push_id - send Identify data to drive
616  * @dev: target ATA device
617  *
618  * _SDD ACPI object: for SATA mode only
619  * Must be after Identify (Packet) Device -- uses its data
620  * ATM this function never returns a failure.  It is an optional
621  * method and if it fails for whatever reason, we should still
622  * just keep going.
623  */
624 int ata_acpi_push_id(struct ata_device *dev)
625 {
626         struct ata_port *ap = dev->ap;
627         acpi_handle handle;
628         acpi_integer pcidevfn;
629         int err;
630         struct device *gdev = ap->host->dev;
631         u32 dev_adr;
632         acpi_status status;
633         struct acpi_object_list input;
634         union acpi_object in_params[1];
635
636         if (libata_noacpi)
637                 return 0;
638
639         if (ata_msg_probe(ap))
640                 ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
641                                __FUNCTION__, dev->devno, ap->port_no);
642
643         /* Don't continue if not a SATA device. */
644         if (!(ap->flags & ATA_FLAG_ACPI_SATA)) {
645                 if (ata_msg_probe(ap))
646                         ata_dev_printk(dev, KERN_DEBUG,
647                                 "%s: Not a SATA device\n", __FUNCTION__);
648                 goto out;
649         }
650
651         /* Don't continue if device has no _ADR method.
652          * _SDD is intended for known motherboard devices. */
653         err = sata_get_dev_handle(gdev, &handle, &pcidevfn);
654         if (err < 0) {
655                 if (ata_msg_probe(ap))
656                         ata_dev_printk(dev, KERN_DEBUG,
657                                 "%s: sata_get_dev_handle failed (%d\n",
658                                 __FUNCTION__, err);
659                 goto out;
660         }
661
662         /* Get this drive's _ADR info, if not already known */
663         if (!dev->obj_handle) {
664                 dev_adr = SATA_ADR_RSVD;
665                 err = get_sata_adr(gdev, handle, pcidevfn, dev->devno, ap, dev,
666                                         &dev_adr);
667                 if (err < 0 || dev_adr == SATA_ADR_RSVD ||
668                         !dev->obj_handle) {
669                         if (ata_msg_probe(ap))
670                                 ata_dev_printk(dev, KERN_DEBUG,
671                                         "%s: get_sata_adr failed: "
672                                         "err=%d, dev_adr=%u, obj_handle=0x%p\n",
673                                         __FUNCTION__, err, dev_adr,
674                                         dev->obj_handle);
675                         goto out;
676                 }
677         }
678
679         /* Give the drive Identify data to the drive via the _SDD method */
680         /* _SDD: set up input parameters */
681         input.count = 1;
682         input.pointer = in_params;
683         in_params[0].type = ACPI_TYPE_BUFFER;
684         in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
685         in_params[0].buffer.pointer = (u8 *)dev->id;
686         /* Output buffer: _SDD has no output */
687
688         /* It's OK for _SDD to be missing too. */
689         swap_buf_le16(dev->id, ATA_ID_WORDS);
690         status = acpi_evaluate_object(dev->obj_handle, "_SDD", &input, NULL);
691         swap_buf_le16(dev->id, ATA_ID_WORDS);
692
693         err = ACPI_FAILURE(status) ? -EIO : 0;
694         if (err < 0) {
695                 if (ata_msg_probe(ap))
696                         ata_dev_printk(dev, KERN_DEBUG,
697                                        "%s _SDD error: status = 0x%x\n",
698                                        __FUNCTION__, status);
699         }
700
701         /* always return success */
702 out:
703         return 0;
704 }
705
706