2 * Provides ACPI support for IDE drives.
4 * Copyright (C) 2005 Intel Corp.
5 * Copyright (C) 2005 Randy Dunlap
6 * Copyright (C) 2006 SUSE Linux Products GmbH
7 * Copyright (C) 2006 Hannes Reinecke
10 #include <linux/ata.h>
11 #include <linux/delay.h>
12 #include <linux/device.h>
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
15 #include <acpi/acpi.h>
16 #include <linux/ide.h>
17 #include <linux/pci.h>
18 #include <linux/dmi.h>
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>
28 #define REGS_PER_GTF 7
29 struct taskfile_array
{
30 u8 tfa
[REGS_PER_GTF
]; /* regs. 0x1f1 - 0x1f7 */
41 struct ide_acpi_drive_link
{
43 acpi_handle obj_handle
;
47 struct ide_acpi_hwif_link
{
49 acpi_handle obj_handle
;
50 struct GTM_buffer gtm
;
51 struct ide_acpi_drive_link master
;
52 struct ide_acpi_drive_link slave
;
56 /* note: adds function name and KERN_DEBUG */
58 #define DEBPRINT(fmt, args...) \
59 printk(KERN_DEBUG "%s: " fmt, __FUNCTION__, ## args)
61 #define DEBPRINT(fmt, args...) do {} while (0)
62 #endif /* DEBUGGING */
64 extern int ide_noacpi
;
65 extern int ide_noacpitfs
;
66 extern int ide_noacpionboot
;
68 static bool ide_noacpi_psx
;
69 static int no_acpi_psx(const struct dmi_system_id
*id
)
71 ide_noacpi_psx
= true;
72 printk(KERN_NOTICE
"%s detected - disable ACPI _PSx.\n", id
->ident
);
76 static const struct dmi_system_id ide_acpi_dmi_table
[] = {
78 /* We should check if this is because ACPI NVS isn't save/restored. */
80 .callback
= no_acpi_psx
,
83 DMI_MATCH(DMI_BIOS_VENDOR
, "Phoenix Technologies Ltd."),
84 DMI_MATCH(DMI_BIOS_VERSION
, "KAM1.60")
88 { } /* terminate list */
91 static int ide_acpi_blacklist(void)
97 dmi_check_system(ide_acpi_dmi_table
);
102 * ide_get_dev_handle - finds acpi_handle and PCI device.function
103 * @dev: device to locate
104 * @handle: returned acpi_handle for @dev
105 * @pcidevfn: return PCI device.func for @dev
107 * Returns the ACPI object handle to the corresponding PCI device.
109 * Returns 0 on success, <0 on error.
111 static int ide_get_dev_handle(struct device
*dev
, acpi_handle
*handle
,
112 acpi_integer
*pcidevfn
)
114 struct pci_dev
*pdev
= to_pci_dev(dev
);
115 unsigned int bus
, devnum
, func
;
117 acpi_handle dev_handle
;
118 struct acpi_buffer buffer
= {.length
= ACPI_ALLOCATE_BUFFER
,
121 struct acpi_device_info
*dinfo
= NULL
;
124 bus
= pdev
->bus
->number
;
125 devnum
= PCI_SLOT(pdev
->devfn
);
126 func
= PCI_FUNC(pdev
->devfn
);
127 /* ACPI _ADR encoding for PCI bus: */
128 addr
= (acpi_integer
)(devnum
<< 16 | func
);
130 DEBPRINT("ENTER: pci %02x:%02x.%01x\n", bus
, devnum
, func
);
132 dev_handle
= DEVICE_ACPI_HANDLE(dev
);
134 DEBPRINT("no acpi handle for device\n");
138 status
= acpi_get_object_info(dev_handle
, &buffer
);
139 if (ACPI_FAILURE(status
)) {
140 DEBPRINT("get_object_info for device failed\n");
143 dinfo
= buffer
.pointer
;
144 if (dinfo
&& (dinfo
->valid
& ACPI_VALID_ADR
) &&
145 dinfo
->address
== addr
) {
147 *handle
= dev_handle
;
149 DEBPRINT("get_object_info for device has wrong "
150 " address: %llu, should be %u\n",
151 dinfo
? (unsigned long long)dinfo
->address
: -1ULL,
156 DEBPRINT("for dev=0x%x.%x, addr=0x%llx, *handle=0x%p\n",
157 devnum
, func
, (unsigned long long)addr
, *handle
);
165 * ide_acpi_hwif_get_handle - Get ACPI object handle for a given hwif
166 * @hwif: device to locate
168 * Retrieves the object handle for a given hwif.
170 * Returns handle on success, 0 on error.
172 static acpi_handle
ide_acpi_hwif_get_handle(ide_hwif_t
*hwif
)
174 struct device
*dev
= hwif
->gendev
.parent
;
175 acpi_handle dev_handle
;
176 acpi_integer pcidevfn
;
177 acpi_handle chan_handle
;
180 DEBPRINT("ENTER: device %s\n", hwif
->name
);
183 DEBPRINT("no PCI device for %s\n", hwif
->name
);
187 err
= ide_get_dev_handle(dev
, &dev_handle
, &pcidevfn
);
189 DEBPRINT("ide_get_dev_handle failed (%d)\n", err
);
193 /* get child objects of dev_handle == channel objects,
194 * + _their_ children == drive objects */
195 /* channel is hwif->channel */
196 chan_handle
= acpi_get_child(dev_handle
, hwif
->channel
);
197 DEBPRINT("chan adr=%d: handle=0x%p\n",
198 hwif
->channel
, chan_handle
);
204 * ide_acpi_drive_get_handle - Get ACPI object handle for a given drive
205 * @drive: device to locate
207 * Retrieves the object handle of a given drive. According to the ACPI
208 * spec the drive is a child of the hwif.
210 * Returns handle on success, 0 on error.
212 static acpi_handle
ide_acpi_drive_get_handle(ide_drive_t
*drive
)
214 ide_hwif_t
*hwif
= HWIF(drive
);
216 acpi_handle drive_handle
;
221 if (!hwif
->acpidata
->obj_handle
)
224 port
= hwif
->channel
? drive
->dn
- 2: drive
->dn
;
226 DEBPRINT("ENTER: %s at channel#: %d port#: %d\n",
227 drive
->name
, hwif
->channel
, port
);
230 /* TBD: could also check ACPI object VALID bits */
231 drive_handle
= acpi_get_child(hwif
->acpidata
->obj_handle
, port
);
232 DEBPRINT("drive %s handle 0x%p\n", drive
->name
, drive_handle
);
238 * do_drive_get_GTF - get the drive bootup default taskfile settings
239 * @drive: the drive for which the taskfile settings should be retrieved
240 * @gtf_length: number of bytes of _GTF data returned at @gtf_address
241 * @gtf_address: buffer containing _GTF taskfile arrays
243 * The _GTF method has no input parameters.
244 * It returns a variable number of register set values (registers
245 * hex 1F1..1F7, taskfiles).
246 * The <variable number> is not known in advance, so have ACPI-CA
247 * allocate the buffer as needed and return it, then free it later.
249 * The returned @gtf_length and @gtf_address are only valid if the
250 * function return value is 0.
252 static int do_drive_get_GTF(ide_drive_t
*drive
,
253 unsigned int *gtf_length
, unsigned long *gtf_address
,
254 unsigned long *obj_loc
)
257 struct acpi_buffer output
;
258 union acpi_object
*out_obj
;
259 ide_hwif_t
*hwif
= HWIF(drive
);
260 struct device
*dev
= hwif
->gendev
.parent
;
272 DEBPRINT("no PCI device for %s\n", hwif
->name
);
276 if (!hwif
->acpidata
) {
277 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
281 port
= hwif
->channel
? drive
->dn
- 2: drive
->dn
;
283 if (!drive
->acpidata
) {
285 drive
->acpidata
= &hwif
->acpidata
->master
;
286 hwif
->acpidata
->master
.drive
= drive
;
288 drive
->acpidata
= &hwif
->acpidata
->slave
;
289 hwif
->acpidata
->slave
.drive
= drive
;
293 DEBPRINT("ENTER: %s at %s, port#: %d, hard_port#: %d\n",
294 hwif
->name
, dev
->bus_id
, port
, hwif
->channel
);
296 if (!drive
->present
) {
297 DEBPRINT("%s drive %d:%d not present\n",
298 hwif
->name
, hwif
->channel
, port
);
302 /* Get this drive's _ADR info. if not already known. */
303 if (!drive
->acpidata
->obj_handle
) {
304 drive
->acpidata
->obj_handle
= ide_acpi_drive_get_handle(drive
);
305 if (!drive
->acpidata
->obj_handle
) {
306 DEBPRINT("No ACPI object found for %s\n",
312 /* Setting up output buffer */
313 output
.length
= ACPI_ALLOCATE_BUFFER
;
314 output
.pointer
= NULL
; /* ACPI-CA sets this; save/free it later */
316 /* _GTF has no input parameters */
318 status
= acpi_evaluate_object(drive
->acpidata
->obj_handle
, "_GTF",
320 if (ACPI_FAILURE(status
)) {
322 "%s: Run _GTF error: status = 0x%x\n",
323 __FUNCTION__
, status
);
327 if (!output
.length
|| !output
.pointer
) {
328 DEBPRINT("Run _GTF: "
329 "length or ptr is NULL (0x%llx, 0x%p)\n",
330 (unsigned long long)output
.length
,
335 out_obj
= output
.pointer
;
336 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
337 DEBPRINT("Run _GTF: error: "
338 "expected object type of ACPI_TYPE_BUFFER, "
339 "got 0x%x\n", out_obj
->type
);
341 kfree(output
.pointer
);
345 if (!out_obj
->buffer
.length
|| !out_obj
->buffer
.pointer
||
346 out_obj
->buffer
.length
% REGS_PER_GTF
) {
348 "%s: unexpected GTF length (%d) or addr (0x%p)\n",
349 __FUNCTION__
, out_obj
->buffer
.length
,
350 out_obj
->buffer
.pointer
);
352 kfree(output
.pointer
);
356 *gtf_length
= out_obj
->buffer
.length
;
357 *gtf_address
= (unsigned long)out_obj
->buffer
.pointer
;
358 *obj_loc
= (unsigned long)out_obj
;
359 DEBPRINT("returning gtf_length=%d, gtf_address=0x%lx, obj_loc=0x%lx\n",
360 *gtf_length
, *gtf_address
, *obj_loc
);
367 * taskfile_load_raw - send taskfile registers to drive
368 * @drive: drive to which output is sent
369 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
371 * Outputs IDE taskfile to the drive.
373 static int taskfile_load_raw(ide_drive_t
*drive
,
374 const struct taskfile_array
*gtf
)
379 DEBPRINT("(0x1f1-1f7): hex: "
380 "%02x %02x %02x %02x %02x %02x %02x\n",
381 gtf
->tfa
[0], gtf
->tfa
[1], gtf
->tfa
[2],
382 gtf
->tfa
[3], gtf
->tfa
[4], gtf
->tfa
[5], gtf
->tfa
[6]);
384 memset(&args
, 0, sizeof(ide_task_t
));
386 /* convert gtf to IDE Taskfile */
387 memcpy(&args
.tf_array
[7], >f
->tfa
, 7);
388 args
.tf_flags
= IDE_TFLAG_TF
| IDE_TFLAG_DEVICE
;
391 DEBPRINT("_GTF execution disabled\n");
395 err
= ide_no_data_taskfile(drive
, &args
);
397 printk(KERN_ERR
"%s: ide_no_data_taskfile failed: %u\n",
404 * do_drive_set_taskfiles - write the drive taskfile settings from _GTF
405 * @drive: the drive to which the taskfile command should be sent
406 * @gtf_length: total number of bytes of _GTF taskfiles
407 * @gtf_address: location of _GTF taskfile arrays
409 * Write {gtf_address, length gtf_length} in groups of
410 * REGS_PER_GTF bytes.
412 static int do_drive_set_taskfiles(ide_drive_t
*drive
,
413 unsigned int gtf_length
,
414 unsigned long gtf_address
)
416 int rc
= -ENODEV
, err
;
417 int gtf_count
= gtf_length
/ REGS_PER_GTF
;
419 struct taskfile_array
*gtf
;
424 DEBPRINT("ENTER: %s, hard_port#: %d\n", drive
->name
, drive
->dn
);
428 if (!gtf_count
) /* shouldn't be here */
431 DEBPRINT("total GTF bytes=%u (0x%x), gtf_count=%d, addr=0x%lx\n",
432 gtf_length
, gtf_length
, gtf_count
, gtf_address
);
434 if (gtf_length
% REGS_PER_GTF
) {
435 printk(KERN_ERR
"%s: unexpected GTF length (%d)\n",
436 __FUNCTION__
, gtf_length
);
441 for (ix
= 0; ix
< gtf_count
; ix
++) {
442 gtf
= (struct taskfile_array
*)
443 (gtf_address
+ ix
* REGS_PER_GTF
);
445 /* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */
446 err
= taskfile_load_raw(drive
, gtf
);
456 * ide_acpi_exec_tfs - get then write drive taskfile settings
457 * @drive: the drive for which the taskfile settings should be
460 * According to the ACPI spec this should be called after _STM
461 * has been evaluated for the interface. Some ACPI vendors interpret
462 * that as a hard requirement and modify the taskfile according
463 * to the Identify Drive information passed down with _STM.
464 * So one should really make sure to call this only after _STM has
467 int ide_acpi_exec_tfs(ide_drive_t
*drive
)
470 unsigned int gtf_length
;
471 unsigned long gtf_address
;
472 unsigned long obj_loc
;
477 DEBPRINT("call get_GTF, drive=%s port=%d\n", drive
->name
, drive
->dn
);
479 ret
= do_drive_get_GTF(drive
, >f_length
, >f_address
, &obj_loc
);
481 DEBPRINT("get_GTF error (%d)\n", ret
);
485 DEBPRINT("call set_taskfiles, drive=%s\n", drive
->name
);
487 ret
= do_drive_set_taskfiles(drive
, gtf_length
, gtf_address
);
488 kfree((void *)obj_loc
);
490 DEBPRINT("set_taskfiles error (%d)\n", ret
);
493 DEBPRINT("ret=%d\n", ret
);
499 * ide_acpi_get_timing - get the channel (controller) timings
500 * @hwif: target IDE interface (channel)
502 * This function executes the _GTM ACPI method for the target channel.
505 void ide_acpi_get_timing(ide_hwif_t
*hwif
)
508 struct acpi_buffer output
;
509 union acpi_object
*out_obj
;
514 DEBPRINT("ENTER:\n");
516 if (!hwif
->acpidata
) {
517 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
521 /* Setting up output buffer for _GTM */
522 output
.length
= ACPI_ALLOCATE_BUFFER
;
523 output
.pointer
= NULL
; /* ACPI-CA sets this; save/free it later */
525 /* _GTM has no input parameters */
526 status
= acpi_evaluate_object(hwif
->acpidata
->obj_handle
, "_GTM",
529 DEBPRINT("_GTM status: %d, outptr: 0x%p, outlen: 0x%llx\n",
530 status
, output
.pointer
,
531 (unsigned long long)output
.length
);
533 if (ACPI_FAILURE(status
)) {
534 DEBPRINT("Run _GTM error: status = 0x%x\n", status
);
538 if (!output
.length
|| !output
.pointer
) {
539 DEBPRINT("Run _GTM: length or ptr is NULL (0x%llx, 0x%p)\n",
540 (unsigned long long)output
.length
,
542 kfree(output
.pointer
);
546 out_obj
= output
.pointer
;
547 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
548 kfree(output
.pointer
);
549 DEBPRINT("Run _GTM: error: "
550 "expected object type of ACPI_TYPE_BUFFER, "
551 "got 0x%x\n", out_obj
->type
);
555 if (!out_obj
->buffer
.length
|| !out_obj
->buffer
.pointer
||
556 out_obj
->buffer
.length
!= sizeof(struct GTM_buffer
)) {
557 kfree(output
.pointer
);
559 "%s: unexpected _GTM length (0x%x)[should be 0x%zx] or "
561 __FUNCTION__
, out_obj
->buffer
.length
,
562 sizeof(struct GTM_buffer
), out_obj
->buffer
.pointer
);
566 memcpy(&hwif
->acpidata
->gtm
, out_obj
->buffer
.pointer
,
567 sizeof(struct GTM_buffer
));
569 DEBPRINT("_GTM info: ptr: 0x%p, len: 0x%x, exp.len: 0x%Zx\n",
570 out_obj
->buffer
.pointer
, out_obj
->buffer
.length
,
571 sizeof(struct GTM_buffer
));
573 DEBPRINT("_GTM fields: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
574 hwif
->acpidata
->gtm
.PIO_speed0
,
575 hwif
->acpidata
->gtm
.DMA_speed0
,
576 hwif
->acpidata
->gtm
.PIO_speed1
,
577 hwif
->acpidata
->gtm
.DMA_speed1
,
578 hwif
->acpidata
->gtm
.GTM_flags
);
580 kfree(output
.pointer
);
584 * ide_acpi_push_timing - set the channel (controller) timings
585 * @hwif: target IDE interface (channel)
587 * This function executes the _STM ACPI method for the target channel.
589 * _STM requires Identify Drive data, which has to passed as an argument.
590 * Unfortunately hd_driveid is a mangled version which we can't readily
591 * use; hence we'll get the information afresh.
593 void ide_acpi_push_timing(ide_hwif_t
*hwif
)
596 struct acpi_object_list input
;
597 union acpi_object in_params
[3];
598 struct ide_acpi_drive_link
*master
= &hwif
->acpidata
->master
;
599 struct ide_acpi_drive_link
*slave
= &hwif
->acpidata
->slave
;
604 DEBPRINT("ENTER:\n");
606 if (!hwif
->acpidata
) {
607 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
611 /* Give the GTM buffer + drive Identify data to the channel via the
613 /* setup input parameters buffer for _STM */
615 input
.pointer
= in_params
;
616 in_params
[0].type
= ACPI_TYPE_BUFFER
;
617 in_params
[0].buffer
.length
= sizeof(struct GTM_buffer
);
618 in_params
[0].buffer
.pointer
= (u8
*)&hwif
->acpidata
->gtm
;
619 in_params
[1].type
= ACPI_TYPE_BUFFER
;
620 in_params
[1].buffer
.length
= sizeof(struct hd_driveid
);
621 in_params
[1].buffer
.pointer
= (u8
*)&master
->idbuff
;
622 in_params
[2].type
= ACPI_TYPE_BUFFER
;
623 in_params
[2].buffer
.length
= sizeof(struct hd_driveid
);
624 in_params
[2].buffer
.pointer
= (u8
*)&slave
->idbuff
;
625 /* Output buffer: _STM has no output */
627 status
= acpi_evaluate_object(hwif
->acpidata
->obj_handle
, "_STM",
630 if (ACPI_FAILURE(status
)) {
631 DEBPRINT("Run _STM error: status = 0x%x\n", status
);
633 DEBPRINT("_STM status: %d\n", status
);
637 * ide_acpi_set_state - set the channel power state
638 * @hwif: target IDE interface
641 * This function executes the _PS0/_PS3 ACPI method to set the power state.
642 * ACPI spec requires _PS0 when IDE power on and _PS3 when power off
644 void ide_acpi_set_state(ide_hwif_t
*hwif
, int on
)
648 if (ide_noacpi
|| ide_noacpi_psx
)
651 DEBPRINT("ENTER:\n");
653 if (!hwif
->acpidata
) {
654 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
657 /* channel first and then drives for power on and verse versa for power off */
659 acpi_bus_set_power(hwif
->acpidata
->obj_handle
, ACPI_STATE_D0
);
660 for (unit
= 0; unit
< MAX_DRIVES
; ++unit
) {
661 ide_drive_t
*drive
= &hwif
->drives
[unit
];
663 if (!drive
->acpidata
->obj_handle
)
664 drive
->acpidata
->obj_handle
= ide_acpi_drive_get_handle(drive
);
666 if (drive
->acpidata
->obj_handle
&& drive
->present
) {
667 acpi_bus_set_power(drive
->acpidata
->obj_handle
,
668 on
? ACPI_STATE_D0
: ACPI_STATE_D3
);
672 acpi_bus_set_power(hwif
->acpidata
->obj_handle
, ACPI_STATE_D3
);
676 * ide_acpi_init - initialize the ACPI link for an IDE interface
677 * @hwif: target IDE interface (channel)
679 * The ACPI spec is not quite clear when the drive identify buffer
680 * should be obtained. Calling IDENTIFY DEVICE during shutdown
681 * is not the best of ideas as the drive might already being put to
682 * sleep. And obviously we can't call it during resume.
683 * So we get the information during startup; but this means that
684 * any changes during run-time will be lost after resume.
686 void ide_acpi_init(ide_hwif_t
*hwif
)
690 struct ide_acpi_drive_link
*master
;
691 struct ide_acpi_drive_link
*slave
;
693 ide_acpi_blacklist();
695 hwif
->acpidata
= kzalloc(sizeof(struct ide_acpi_hwif_link
), GFP_KERNEL
);
699 hwif
->acpidata
->obj_handle
= ide_acpi_hwif_get_handle(hwif
);
700 if (!hwif
->acpidata
->obj_handle
) {
701 DEBPRINT("no ACPI object for %s found\n", hwif
->name
);
702 kfree(hwif
->acpidata
);
703 hwif
->acpidata
= NULL
;
708 * The ACPI spec mandates that we send information
709 * for both drives, regardless whether they are connected
712 hwif
->acpidata
->master
.drive
= &hwif
->drives
[0];
713 hwif
->drives
[0].acpidata
= &hwif
->acpidata
->master
;
714 master
= &hwif
->acpidata
->master
;
716 hwif
->acpidata
->slave
.drive
= &hwif
->drives
[1];
717 hwif
->drives
[1].acpidata
= &hwif
->acpidata
->slave
;
718 slave
= &hwif
->acpidata
->slave
;
722 * Send IDENTIFY for each drive
724 if (master
->drive
->present
) {
725 err
= taskfile_lib_get_identify(master
->drive
, master
->idbuff
);
727 DEBPRINT("identify device %s failed (%d)\n",
728 master
->drive
->name
, err
);
732 if (slave
->drive
->present
) {
733 err
= taskfile_lib_get_identify(slave
->drive
, slave
->idbuff
);
735 DEBPRINT("identify device %s failed (%d)\n",
736 slave
->drive
->name
, err
);
740 if (ide_noacpionboot
) {
741 DEBPRINT("ACPI methods disabled on boot\n");
745 /* ACPI _PS0 before _STM */
746 ide_acpi_set_state(hwif
, 1);
748 * ACPI requires us to call _STM on startup
750 ide_acpi_get_timing(hwif
);
751 ide_acpi_push_timing(hwif
);
753 for (unit
= 0; unit
< MAX_DRIVES
; ++unit
) {
754 ide_drive_t
*drive
= &hwif
->drives
[unit
];
756 if (drive
->present
) {
757 /* Execute ACPI startup code */
758 ide_acpi_exec_tfs(drive
);