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 DEBPRINT("ENTER: %s at %s, port#: %d, hard_port#: %d\n",
284 hwif
->name
, dev
->bus_id
, port
, hwif
->channel
);
286 if (!drive
->present
) {
287 DEBPRINT("%s drive %d:%d not present\n",
288 hwif
->name
, hwif
->channel
, port
);
292 /* Get this drive's _ADR info. if not already known. */
293 if (!drive
->acpidata
->obj_handle
) {
294 drive
->acpidata
->obj_handle
= ide_acpi_drive_get_handle(drive
);
295 if (!drive
->acpidata
->obj_handle
) {
296 DEBPRINT("No ACPI object found for %s\n",
302 /* Setting up output buffer */
303 output
.length
= ACPI_ALLOCATE_BUFFER
;
304 output
.pointer
= NULL
; /* ACPI-CA sets this; save/free it later */
306 /* _GTF has no input parameters */
308 status
= acpi_evaluate_object(drive
->acpidata
->obj_handle
, "_GTF",
310 if (ACPI_FAILURE(status
)) {
312 "%s: Run _GTF error: status = 0x%x\n",
313 __FUNCTION__
, status
);
317 if (!output
.length
|| !output
.pointer
) {
318 DEBPRINT("Run _GTF: "
319 "length or ptr is NULL (0x%llx, 0x%p)\n",
320 (unsigned long long)output
.length
,
325 out_obj
= output
.pointer
;
326 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
327 DEBPRINT("Run _GTF: error: "
328 "expected object type of ACPI_TYPE_BUFFER, "
329 "got 0x%x\n", out_obj
->type
);
331 kfree(output
.pointer
);
335 if (!out_obj
->buffer
.length
|| !out_obj
->buffer
.pointer
||
336 out_obj
->buffer
.length
% REGS_PER_GTF
) {
338 "%s: unexpected GTF length (%d) or addr (0x%p)\n",
339 __FUNCTION__
, out_obj
->buffer
.length
,
340 out_obj
->buffer
.pointer
);
342 kfree(output
.pointer
);
346 *gtf_length
= out_obj
->buffer
.length
;
347 *gtf_address
= (unsigned long)out_obj
->buffer
.pointer
;
348 *obj_loc
= (unsigned long)out_obj
;
349 DEBPRINT("returning gtf_length=%d, gtf_address=0x%lx, obj_loc=0x%lx\n",
350 *gtf_length
, *gtf_address
, *obj_loc
);
357 * taskfile_load_raw - send taskfile registers to drive
358 * @drive: drive to which output is sent
359 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
361 * Outputs IDE taskfile to the drive.
363 static int taskfile_load_raw(ide_drive_t
*drive
,
364 const struct taskfile_array
*gtf
)
369 DEBPRINT("(0x1f1-1f7): hex: "
370 "%02x %02x %02x %02x %02x %02x %02x\n",
371 gtf
->tfa
[0], gtf
->tfa
[1], gtf
->tfa
[2],
372 gtf
->tfa
[3], gtf
->tfa
[4], gtf
->tfa
[5], gtf
->tfa
[6]);
374 memset(&args
, 0, sizeof(ide_task_t
));
376 /* convert gtf to IDE Taskfile */
377 memcpy(&args
.tf_array
[7], >f
->tfa
, 7);
378 args
.tf_flags
= IDE_TFLAG_TF
| IDE_TFLAG_DEVICE
;
381 DEBPRINT("_GTF execution disabled\n");
385 err
= ide_no_data_taskfile(drive
, &args
);
387 printk(KERN_ERR
"%s: ide_no_data_taskfile failed: %u\n",
394 * do_drive_set_taskfiles - write the drive taskfile settings from _GTF
395 * @drive: the drive to which the taskfile command should be sent
396 * @gtf_length: total number of bytes of _GTF taskfiles
397 * @gtf_address: location of _GTF taskfile arrays
399 * Write {gtf_address, length gtf_length} in groups of
400 * REGS_PER_GTF bytes.
402 static int do_drive_set_taskfiles(ide_drive_t
*drive
,
403 unsigned int gtf_length
,
404 unsigned long gtf_address
)
406 int rc
= -ENODEV
, err
;
407 int gtf_count
= gtf_length
/ REGS_PER_GTF
;
409 struct taskfile_array
*gtf
;
414 DEBPRINT("ENTER: %s, hard_port#: %d\n", drive
->name
, drive
->dn
);
418 if (!gtf_count
) /* shouldn't be here */
421 DEBPRINT("total GTF bytes=%u (0x%x), gtf_count=%d, addr=0x%lx\n",
422 gtf_length
, gtf_length
, gtf_count
, gtf_address
);
424 if (gtf_length
% REGS_PER_GTF
) {
425 printk(KERN_ERR
"%s: unexpected GTF length (%d)\n",
426 __FUNCTION__
, gtf_length
);
431 for (ix
= 0; ix
< gtf_count
; ix
++) {
432 gtf
= (struct taskfile_array
*)
433 (gtf_address
+ ix
* REGS_PER_GTF
);
435 /* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */
436 err
= taskfile_load_raw(drive
, gtf
);
446 * ide_acpi_exec_tfs - get then write drive taskfile settings
447 * @drive: the drive for which the taskfile settings should be
450 * According to the ACPI spec this should be called after _STM
451 * has been evaluated for the interface. Some ACPI vendors interpret
452 * that as a hard requirement and modify the taskfile according
453 * to the Identify Drive information passed down with _STM.
454 * So one should really make sure to call this only after _STM has
457 int ide_acpi_exec_tfs(ide_drive_t
*drive
)
460 unsigned int gtf_length
;
461 unsigned long gtf_address
;
462 unsigned long obj_loc
;
467 DEBPRINT("call get_GTF, drive=%s port=%d\n", drive
->name
, drive
->dn
);
469 ret
= do_drive_get_GTF(drive
, >f_length
, >f_address
, &obj_loc
);
471 DEBPRINT("get_GTF error (%d)\n", ret
);
475 DEBPRINT("call set_taskfiles, drive=%s\n", drive
->name
);
477 ret
= do_drive_set_taskfiles(drive
, gtf_length
, gtf_address
);
478 kfree((void *)obj_loc
);
480 DEBPRINT("set_taskfiles error (%d)\n", ret
);
483 DEBPRINT("ret=%d\n", ret
);
489 * ide_acpi_get_timing - get the channel (controller) timings
490 * @hwif: target IDE interface (channel)
492 * This function executes the _GTM ACPI method for the target channel.
495 void ide_acpi_get_timing(ide_hwif_t
*hwif
)
498 struct acpi_buffer output
;
499 union acpi_object
*out_obj
;
504 DEBPRINT("ENTER:\n");
506 if (!hwif
->acpidata
) {
507 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
511 /* Setting up output buffer for _GTM */
512 output
.length
= ACPI_ALLOCATE_BUFFER
;
513 output
.pointer
= NULL
; /* ACPI-CA sets this; save/free it later */
515 /* _GTM has no input parameters */
516 status
= acpi_evaluate_object(hwif
->acpidata
->obj_handle
, "_GTM",
519 DEBPRINT("_GTM status: %d, outptr: 0x%p, outlen: 0x%llx\n",
520 status
, output
.pointer
,
521 (unsigned long long)output
.length
);
523 if (ACPI_FAILURE(status
)) {
524 DEBPRINT("Run _GTM error: status = 0x%x\n", status
);
528 if (!output
.length
|| !output
.pointer
) {
529 DEBPRINT("Run _GTM: length or ptr is NULL (0x%llx, 0x%p)\n",
530 (unsigned long long)output
.length
,
532 kfree(output
.pointer
);
536 out_obj
= output
.pointer
;
537 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
538 kfree(output
.pointer
);
539 DEBPRINT("Run _GTM: error: "
540 "expected object type of ACPI_TYPE_BUFFER, "
541 "got 0x%x\n", out_obj
->type
);
545 if (!out_obj
->buffer
.length
|| !out_obj
->buffer
.pointer
||
546 out_obj
->buffer
.length
!= sizeof(struct GTM_buffer
)) {
547 kfree(output
.pointer
);
549 "%s: unexpected _GTM length (0x%x)[should be 0x%zx] or "
551 __FUNCTION__
, out_obj
->buffer
.length
,
552 sizeof(struct GTM_buffer
), out_obj
->buffer
.pointer
);
556 memcpy(&hwif
->acpidata
->gtm
, out_obj
->buffer
.pointer
,
557 sizeof(struct GTM_buffer
));
559 DEBPRINT("_GTM info: ptr: 0x%p, len: 0x%x, exp.len: 0x%Zx\n",
560 out_obj
->buffer
.pointer
, out_obj
->buffer
.length
,
561 sizeof(struct GTM_buffer
));
563 DEBPRINT("_GTM fields: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
564 hwif
->acpidata
->gtm
.PIO_speed0
,
565 hwif
->acpidata
->gtm
.DMA_speed0
,
566 hwif
->acpidata
->gtm
.PIO_speed1
,
567 hwif
->acpidata
->gtm
.DMA_speed1
,
568 hwif
->acpidata
->gtm
.GTM_flags
);
570 kfree(output
.pointer
);
574 * ide_acpi_push_timing - set the channel (controller) timings
575 * @hwif: target IDE interface (channel)
577 * This function executes the _STM ACPI method for the target channel.
579 * _STM requires Identify Drive data, which has to passed as an argument.
580 * Unfortunately hd_driveid is a mangled version which we can't readily
581 * use; hence we'll get the information afresh.
583 void ide_acpi_push_timing(ide_hwif_t
*hwif
)
586 struct acpi_object_list input
;
587 union acpi_object in_params
[3];
588 struct ide_acpi_drive_link
*master
= &hwif
->acpidata
->master
;
589 struct ide_acpi_drive_link
*slave
= &hwif
->acpidata
->slave
;
594 DEBPRINT("ENTER:\n");
596 if (!hwif
->acpidata
) {
597 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
601 /* Give the GTM buffer + drive Identify data to the channel via the
603 /* setup input parameters buffer for _STM */
605 input
.pointer
= in_params
;
606 in_params
[0].type
= ACPI_TYPE_BUFFER
;
607 in_params
[0].buffer
.length
= sizeof(struct GTM_buffer
);
608 in_params
[0].buffer
.pointer
= (u8
*)&hwif
->acpidata
->gtm
;
609 in_params
[1].type
= ACPI_TYPE_BUFFER
;
610 in_params
[1].buffer
.length
= sizeof(struct hd_driveid
);
611 in_params
[1].buffer
.pointer
= (u8
*)&master
->idbuff
;
612 in_params
[2].type
= ACPI_TYPE_BUFFER
;
613 in_params
[2].buffer
.length
= sizeof(struct hd_driveid
);
614 in_params
[2].buffer
.pointer
= (u8
*)&slave
->idbuff
;
615 /* Output buffer: _STM has no output */
617 status
= acpi_evaluate_object(hwif
->acpidata
->obj_handle
, "_STM",
620 if (ACPI_FAILURE(status
)) {
621 DEBPRINT("Run _STM error: status = 0x%x\n", status
);
623 DEBPRINT("_STM status: %d\n", status
);
627 * ide_acpi_set_state - set the channel power state
628 * @hwif: target IDE interface
631 * This function executes the _PS0/_PS3 ACPI method to set the power state.
632 * ACPI spec requires _PS0 when IDE power on and _PS3 when power off
634 void ide_acpi_set_state(ide_hwif_t
*hwif
, int on
)
638 if (ide_noacpi
|| ide_noacpi_psx
)
641 DEBPRINT("ENTER:\n");
643 if (!hwif
->acpidata
) {
644 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
647 /* channel first and then drives for power on and verse versa for power off */
649 acpi_bus_set_power(hwif
->acpidata
->obj_handle
, ACPI_STATE_D0
);
650 for (unit
= 0; unit
< MAX_DRIVES
; ++unit
) {
651 ide_drive_t
*drive
= &hwif
->drives
[unit
];
653 if (!drive
->acpidata
->obj_handle
)
654 drive
->acpidata
->obj_handle
= ide_acpi_drive_get_handle(drive
);
656 if (drive
->acpidata
->obj_handle
&& drive
->present
) {
657 acpi_bus_set_power(drive
->acpidata
->obj_handle
,
658 on
? ACPI_STATE_D0
: ACPI_STATE_D3
);
662 acpi_bus_set_power(hwif
->acpidata
->obj_handle
, ACPI_STATE_D3
);
666 * ide_acpi_init - initialize the ACPI link for an IDE interface
667 * @hwif: target IDE interface (channel)
669 * The ACPI spec is not quite clear when the drive identify buffer
670 * should be obtained. Calling IDENTIFY DEVICE during shutdown
671 * is not the best of ideas as the drive might already being put to
672 * sleep. And obviously we can't call it during resume.
673 * So we get the information during startup; but this means that
674 * any changes during run-time will be lost after resume.
676 void ide_acpi_init(ide_hwif_t
*hwif
)
680 struct ide_acpi_drive_link
*master
;
681 struct ide_acpi_drive_link
*slave
;
683 ide_acpi_blacklist();
685 hwif
->acpidata
= kzalloc(sizeof(struct ide_acpi_hwif_link
), GFP_KERNEL
);
689 hwif
->acpidata
->obj_handle
= ide_acpi_hwif_get_handle(hwif
);
690 if (!hwif
->acpidata
->obj_handle
) {
691 DEBPRINT("no ACPI object for %s found\n", hwif
->name
);
692 kfree(hwif
->acpidata
);
693 hwif
->acpidata
= NULL
;
698 * The ACPI spec mandates that we send information
699 * for both drives, regardless whether they are connected
702 hwif
->acpidata
->master
.drive
= &hwif
->drives
[0];
703 hwif
->drives
[0].acpidata
= &hwif
->acpidata
->master
;
704 master
= &hwif
->acpidata
->master
;
706 hwif
->acpidata
->slave
.drive
= &hwif
->drives
[1];
707 hwif
->drives
[1].acpidata
= &hwif
->acpidata
->slave
;
708 slave
= &hwif
->acpidata
->slave
;
712 * Send IDENTIFY for each drive
714 if (master
->drive
->present
) {
715 err
= taskfile_lib_get_identify(master
->drive
, master
->idbuff
);
717 DEBPRINT("identify device %s failed (%d)\n",
718 master
->drive
->name
, err
);
722 if (slave
->drive
->present
) {
723 err
= taskfile_lib_get_identify(slave
->drive
, slave
->idbuff
);
725 DEBPRINT("identify device %s failed (%d)\n",
726 slave
->drive
->name
, err
);
730 if (ide_noacpionboot
) {
731 DEBPRINT("ACPI methods disabled on boot\n");
735 /* ACPI _PS0 before _STM */
736 ide_acpi_set_state(hwif
, 1);
738 * ACPI requires us to call _STM on startup
740 ide_acpi_get_timing(hwif
);
741 ide_acpi_push_timing(hwif
);
743 for (unit
= 0; unit
< MAX_DRIVES
; ++unit
) {
744 ide_drive_t
*drive
= &hwif
->drives
[unit
];
746 if (drive
->present
) {
747 /* Execute ACPI startup code */
748 ide_acpi_exec_tfs(drive
);