?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
allow coexistance of N build and AC build.
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / drivers / ata / libata-acpi.c
blob02236739b40f73787dfbd5cb40204117dd44be6f
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
Tomato firmware and modifications.