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>
22 #define REGS_PER_GTF 7
23 struct taskfile_array
{
24 u8 tfa
[REGS_PER_GTF
]; /* regs. 0x1f1 - 0x1f7 */
35 struct ide_acpi_drive_link
{
36 acpi_handle obj_handle
;
40 struct ide_acpi_hwif_link
{
42 acpi_handle obj_handle
;
43 struct GTM_buffer gtm
;
44 struct ide_acpi_drive_link master
;
45 struct ide_acpi_drive_link slave
;
49 /* note: adds function name and KERN_DEBUG */
51 #define DEBPRINT(fmt, args...) \
52 printk(KERN_DEBUG "%s: " fmt, __func__, ## args)
54 #define DEBPRINT(fmt, args...) do {} while (0)
55 #endif /* DEBUGGING */
57 static int ide_noacpi
;
58 module_param_named(noacpi
, ide_noacpi
, bool, 0);
59 MODULE_PARM_DESC(noacpi
, "disable IDE ACPI support");
61 static int ide_acpigtf
;
62 module_param_named(acpigtf
, ide_acpigtf
, bool, 0);
63 MODULE_PARM_DESC(acpigtf
, "enable IDE ACPI _GTF support");
65 static int ide_acpionboot
;
66 module_param_named(acpionboot
, ide_acpionboot
, bool, 0);
67 MODULE_PARM_DESC(acpionboot
, "call IDE ACPI methods on boot");
69 static bool ide_noacpi_psx
;
70 static int no_acpi_psx(const struct dmi_system_id
*id
)
72 ide_noacpi_psx
= true;
73 printk(KERN_NOTICE
"%s detected - disable ACPI _PSx.\n", id
->ident
);
77 static const struct dmi_system_id ide_acpi_dmi_table
[] = {
79 /* We should check if this is because ACPI NVS isn't save/restored. */
81 .callback
= no_acpi_psx
,
84 DMI_MATCH(DMI_BIOS_VENDOR
, "Phoenix Technologies Ltd."),
85 DMI_MATCH(DMI_BIOS_VERSION
, "KAM1.60")
89 { } /* terminate list */
92 int ide_acpi_init(void)
94 dmi_check_system(ide_acpi_dmi_table
);
99 * ide_get_dev_handle - finds acpi_handle and PCI device.function
100 * @dev: device to locate
101 * @handle: returned acpi_handle for @dev
102 * @pcidevfn: return PCI device.func for @dev
104 * Returns the ACPI object handle to the corresponding PCI device.
106 * Returns 0 on success, <0 on error.
108 static int ide_get_dev_handle(struct device
*dev
, acpi_handle
*handle
,
109 acpi_integer
*pcidevfn
)
111 struct pci_dev
*pdev
= to_pci_dev(dev
);
112 unsigned int bus
, devnum
, func
;
114 acpi_handle dev_handle
;
115 struct acpi_buffer buffer
= {.length
= ACPI_ALLOCATE_BUFFER
,
118 struct acpi_device_info
*dinfo
= NULL
;
121 bus
= pdev
->bus
->number
;
122 devnum
= PCI_SLOT(pdev
->devfn
);
123 func
= PCI_FUNC(pdev
->devfn
);
124 /* ACPI _ADR encoding for PCI bus: */
125 addr
= (acpi_integer
)(devnum
<< 16 | func
);
127 DEBPRINT("ENTER: pci %02x:%02x.%01x\n", bus
, devnum
, func
);
129 dev_handle
= DEVICE_ACPI_HANDLE(dev
);
131 DEBPRINT("no acpi handle for device\n");
135 status
= acpi_get_object_info(dev_handle
, &buffer
);
136 if (ACPI_FAILURE(status
)) {
137 DEBPRINT("get_object_info for device failed\n");
140 dinfo
= buffer
.pointer
;
141 if (dinfo
&& (dinfo
->valid
& ACPI_VALID_ADR
) &&
142 dinfo
->address
== addr
) {
144 *handle
= dev_handle
;
146 DEBPRINT("get_object_info for device has wrong "
147 " address: %llu, should be %u\n",
148 dinfo
? (unsigned long long)dinfo
->address
: -1ULL,
153 DEBPRINT("for dev=0x%x.%x, addr=0x%llx, *handle=0x%p\n",
154 devnum
, func
, (unsigned long long)addr
, *handle
);
162 * ide_acpi_hwif_get_handle - Get ACPI object handle for a given hwif
163 * @hwif: device to locate
165 * Retrieves the object handle for a given hwif.
167 * Returns handle on success, 0 on error.
169 static acpi_handle
ide_acpi_hwif_get_handle(ide_hwif_t
*hwif
)
171 struct device
*dev
= hwif
->gendev
.parent
;
172 acpi_handle
uninitialized_var(dev_handle
);
173 acpi_integer pcidevfn
;
174 acpi_handle chan_handle
;
177 DEBPRINT("ENTER: device %s\n", hwif
->name
);
180 DEBPRINT("no PCI device for %s\n", hwif
->name
);
184 err
= ide_get_dev_handle(dev
, &dev_handle
, &pcidevfn
);
186 DEBPRINT("ide_get_dev_handle failed (%d)\n", err
);
190 /* get child objects of dev_handle == channel objects,
191 * + _their_ children == drive objects */
192 /* channel is hwif->channel */
193 chan_handle
= acpi_get_child(dev_handle
, hwif
->channel
);
194 DEBPRINT("chan adr=%d: handle=0x%p\n",
195 hwif
->channel
, chan_handle
);
201 * do_drive_get_GTF - get the drive bootup default taskfile settings
202 * @drive: the drive for which the taskfile settings should be retrieved
203 * @gtf_length: number of bytes of _GTF data returned at @gtf_address
204 * @gtf_address: buffer containing _GTF taskfile arrays
206 * The _GTF method has no input parameters.
207 * It returns a variable number of register set values (registers
208 * hex 1F1..1F7, taskfiles).
209 * The <variable number> is not known in advance, so have ACPI-CA
210 * allocate the buffer as needed and return it, then free it later.
212 * The returned @gtf_length and @gtf_address are only valid if the
213 * function return value is 0.
215 static int do_drive_get_GTF(ide_drive_t
*drive
,
216 unsigned int *gtf_length
, unsigned long *gtf_address
,
217 unsigned long *obj_loc
)
220 struct acpi_buffer output
;
221 union acpi_object
*out_obj
;
228 if (!drive
->acpidata
->obj_handle
) {
229 DEBPRINT("No ACPI object found for %s\n", drive
->name
);
233 /* Setting up output buffer */
234 output
.length
= ACPI_ALLOCATE_BUFFER
;
235 output
.pointer
= NULL
; /* ACPI-CA sets this; save/free it later */
237 /* _GTF has no input parameters */
239 status
= acpi_evaluate_object(drive
->acpidata
->obj_handle
, "_GTF",
241 if (ACPI_FAILURE(status
)) {
243 "%s: Run _GTF error: status = 0x%x\n",
248 if (!output
.length
|| !output
.pointer
) {
249 DEBPRINT("Run _GTF: "
250 "length or ptr is NULL (0x%llx, 0x%p)\n",
251 (unsigned long long)output
.length
,
256 out_obj
= output
.pointer
;
257 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
258 DEBPRINT("Run _GTF: error: "
259 "expected object type of ACPI_TYPE_BUFFER, "
260 "got 0x%x\n", out_obj
->type
);
262 kfree(output
.pointer
);
266 if (!out_obj
->buffer
.length
|| !out_obj
->buffer
.pointer
||
267 out_obj
->buffer
.length
% REGS_PER_GTF
) {
269 "%s: unexpected GTF length (%d) or addr (0x%p)\n",
270 __func__
, out_obj
->buffer
.length
,
271 out_obj
->buffer
.pointer
);
273 kfree(output
.pointer
);
277 *gtf_length
= out_obj
->buffer
.length
;
278 *gtf_address
= (unsigned long)out_obj
->buffer
.pointer
;
279 *obj_loc
= (unsigned long)out_obj
;
280 DEBPRINT("returning gtf_length=%d, gtf_address=0x%lx, obj_loc=0x%lx\n",
281 *gtf_length
, *gtf_address
, *obj_loc
);
288 * taskfile_load_raw - send taskfile registers to drive
289 * @drive: drive to which output is sent
290 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
292 * Outputs IDE taskfile to the drive.
294 static int taskfile_load_raw(ide_drive_t
*drive
,
295 const struct taskfile_array
*gtf
)
300 DEBPRINT("(0x1f1-1f7): hex: "
301 "%02x %02x %02x %02x %02x %02x %02x\n",
302 gtf
->tfa
[0], gtf
->tfa
[1], gtf
->tfa
[2],
303 gtf
->tfa
[3], gtf
->tfa
[4], gtf
->tfa
[5], gtf
->tfa
[6]);
305 memset(&args
, 0, sizeof(ide_task_t
));
307 /* convert gtf to IDE Taskfile */
308 memcpy(&args
.tf_array
[7], >f
->tfa
, 7);
309 args
.tf_flags
= IDE_TFLAG_TF
| IDE_TFLAG_DEVICE
;
312 DEBPRINT("_GTF execution disabled\n");
316 err
= ide_no_data_taskfile(drive
, &args
);
318 printk(KERN_ERR
"%s: ide_no_data_taskfile failed: %u\n",
325 * do_drive_set_taskfiles - write the drive taskfile settings from _GTF
326 * @drive: the drive to which the taskfile command should be sent
327 * @gtf_length: total number of bytes of _GTF taskfiles
328 * @gtf_address: location of _GTF taskfile arrays
330 * Write {gtf_address, length gtf_length} in groups of
331 * REGS_PER_GTF bytes.
333 static int do_drive_set_taskfiles(ide_drive_t
*drive
,
334 unsigned int gtf_length
,
335 unsigned long gtf_address
)
338 int gtf_count
= gtf_length
/ REGS_PER_GTF
;
340 struct taskfile_array
*gtf
;
342 DEBPRINT("total GTF bytes=%u (0x%x), gtf_count=%d, addr=0x%lx\n",
343 gtf_length
, gtf_length
, gtf_count
, gtf_address
);
345 for (ix
= 0; ix
< gtf_count
; ix
++) {
346 gtf
= (struct taskfile_array
*)
347 (gtf_address
+ ix
* REGS_PER_GTF
);
349 /* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */
350 err
= taskfile_load_raw(drive
, gtf
);
359 * ide_acpi_exec_tfs - get then write drive taskfile settings
360 * @drive: the drive for which the taskfile settings should be
363 * According to the ACPI spec this should be called after _STM
364 * has been evaluated for the interface. Some ACPI vendors interpret
365 * that as a hard requirement and modify the taskfile according
366 * to the Identify Drive information passed down with _STM.
367 * So one should really make sure to call this only after _STM has
370 int ide_acpi_exec_tfs(ide_drive_t
*drive
)
373 unsigned int gtf_length
;
374 unsigned long gtf_address
;
375 unsigned long obj_loc
;
380 DEBPRINT("call get_GTF, drive=%s port=%d\n", drive
->name
, drive
->dn
);
382 ret
= do_drive_get_GTF(drive
, >f_length
, >f_address
, &obj_loc
);
384 DEBPRINT("get_GTF error (%d)\n", ret
);
388 DEBPRINT("call set_taskfiles, drive=%s\n", drive
->name
);
390 ret
= do_drive_set_taskfiles(drive
, gtf_length
, gtf_address
);
391 kfree((void *)obj_loc
);
393 DEBPRINT("set_taskfiles error (%d)\n", ret
);
396 DEBPRINT("ret=%d\n", ret
);
402 * ide_acpi_get_timing - get the channel (controller) timings
403 * @hwif: target IDE interface (channel)
405 * This function executes the _GTM ACPI method for the target channel.
408 void ide_acpi_get_timing(ide_hwif_t
*hwif
)
411 struct acpi_buffer output
;
412 union acpi_object
*out_obj
;
417 DEBPRINT("ENTER:\n");
419 if (!hwif
->acpidata
) {
420 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
424 /* Setting up output buffer for _GTM */
425 output
.length
= ACPI_ALLOCATE_BUFFER
;
426 output
.pointer
= NULL
; /* ACPI-CA sets this; save/free it later */
428 /* _GTM has no input parameters */
429 status
= acpi_evaluate_object(hwif
->acpidata
->obj_handle
, "_GTM",
432 DEBPRINT("_GTM status: %d, outptr: 0x%p, outlen: 0x%llx\n",
433 status
, output
.pointer
,
434 (unsigned long long)output
.length
);
436 if (ACPI_FAILURE(status
)) {
437 DEBPRINT("Run _GTM error: status = 0x%x\n", status
);
441 if (!output
.length
|| !output
.pointer
) {
442 DEBPRINT("Run _GTM: length or ptr is NULL (0x%llx, 0x%p)\n",
443 (unsigned long long)output
.length
,
445 kfree(output
.pointer
);
449 out_obj
= output
.pointer
;
450 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
451 kfree(output
.pointer
);
452 DEBPRINT("Run _GTM: error: "
453 "expected object type of ACPI_TYPE_BUFFER, "
454 "got 0x%x\n", out_obj
->type
);
458 if (!out_obj
->buffer
.length
|| !out_obj
->buffer
.pointer
||
459 out_obj
->buffer
.length
!= sizeof(struct GTM_buffer
)) {
460 kfree(output
.pointer
);
462 "%s: unexpected _GTM length (0x%x)[should be 0x%zx] or "
464 __func__
, out_obj
->buffer
.length
,
465 sizeof(struct GTM_buffer
), out_obj
->buffer
.pointer
);
469 memcpy(&hwif
->acpidata
->gtm
, out_obj
->buffer
.pointer
,
470 sizeof(struct GTM_buffer
));
472 DEBPRINT("_GTM info: ptr: 0x%p, len: 0x%x, exp.len: 0x%Zx\n",
473 out_obj
->buffer
.pointer
, out_obj
->buffer
.length
,
474 sizeof(struct GTM_buffer
));
476 DEBPRINT("_GTM fields: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
477 hwif
->acpidata
->gtm
.PIO_speed0
,
478 hwif
->acpidata
->gtm
.DMA_speed0
,
479 hwif
->acpidata
->gtm
.PIO_speed1
,
480 hwif
->acpidata
->gtm
.DMA_speed1
,
481 hwif
->acpidata
->gtm
.GTM_flags
);
483 kfree(output
.pointer
);
487 * ide_acpi_push_timing - set the channel (controller) timings
488 * @hwif: target IDE interface (channel)
490 * This function executes the _STM ACPI method for the target channel.
492 * _STM requires Identify Drive data, which has to passed as an argument.
493 * Unfortunately drive->id is a mangled version which we can't readily
494 * use; hence we'll get the information afresh.
496 void ide_acpi_push_timing(ide_hwif_t
*hwif
)
499 struct acpi_object_list input
;
500 union acpi_object in_params
[3];
501 struct ide_acpi_drive_link
*master
= &hwif
->acpidata
->master
;
502 struct ide_acpi_drive_link
*slave
= &hwif
->acpidata
->slave
;
507 DEBPRINT("ENTER:\n");
509 if (!hwif
->acpidata
) {
510 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
514 /* Give the GTM buffer + drive Identify data to the channel via the
516 /* setup input parameters buffer for _STM */
518 input
.pointer
= in_params
;
519 in_params
[0].type
= ACPI_TYPE_BUFFER
;
520 in_params
[0].buffer
.length
= sizeof(struct GTM_buffer
);
521 in_params
[0].buffer
.pointer
= (u8
*)&hwif
->acpidata
->gtm
;
522 in_params
[1].type
= ACPI_TYPE_BUFFER
;
523 in_params
[1].buffer
.length
= ATA_ID_WORDS
* 2;
524 in_params
[1].buffer
.pointer
= (u8
*)&master
->idbuff
;
525 in_params
[2].type
= ACPI_TYPE_BUFFER
;
526 in_params
[2].buffer
.length
= ATA_ID_WORDS
* 2;
527 in_params
[2].buffer
.pointer
= (u8
*)&slave
->idbuff
;
528 /* Output buffer: _STM has no output */
530 status
= acpi_evaluate_object(hwif
->acpidata
->obj_handle
, "_STM",
533 if (ACPI_FAILURE(status
)) {
534 DEBPRINT("Run _STM error: status = 0x%x\n", status
);
536 DEBPRINT("_STM status: %d\n", status
);
540 * ide_acpi_set_state - set the channel power state
541 * @hwif: target IDE interface
544 * This function executes the _PS0/_PS3 ACPI method to set the power state.
545 * ACPI spec requires _PS0 when IDE power on and _PS3 when power off
547 void ide_acpi_set_state(ide_hwif_t
*hwif
, int on
)
552 if (ide_noacpi
|| ide_noacpi_psx
)
555 DEBPRINT("ENTER:\n");
557 if (!hwif
->acpidata
) {
558 DEBPRINT("no ACPI data for %s\n", hwif
->name
);
562 /* channel first and then drives for power on and verse versa for power off */
564 acpi_bus_set_power(hwif
->acpidata
->obj_handle
, ACPI_STATE_D0
);
566 ide_port_for_each_present_dev(i
, drive
, hwif
) {
567 if (drive
->acpidata
->obj_handle
)
568 acpi_bus_set_power(drive
->acpidata
->obj_handle
,
569 on
? ACPI_STATE_D0
: ACPI_STATE_D3
);
573 acpi_bus_set_power(hwif
->acpidata
->obj_handle
, ACPI_STATE_D3
);
577 * ide_acpi_init_port - initialize the ACPI link for an IDE interface
578 * @hwif: target IDE interface (channel)
580 * The ACPI spec is not quite clear when the drive identify buffer
581 * should be obtained. Calling IDENTIFY DEVICE during shutdown
582 * is not the best of ideas as the drive might already being put to
583 * sleep. And obviously we can't call it during resume.
584 * So we get the information during startup; but this means that
585 * any changes during run-time will be lost after resume.
587 void ide_acpi_init_port(ide_hwif_t
*hwif
)
589 hwif
->acpidata
= kzalloc(sizeof(struct ide_acpi_hwif_link
), GFP_KERNEL
);
593 hwif
->acpidata
->obj_handle
= ide_acpi_hwif_get_handle(hwif
);
594 if (!hwif
->acpidata
->obj_handle
) {
595 DEBPRINT("no ACPI object for %s found\n", hwif
->name
);
596 kfree(hwif
->acpidata
);
597 hwif
->acpidata
= NULL
;
601 void ide_acpi_port_init_devices(ide_hwif_t
*hwif
)
606 if (hwif
->acpidata
== NULL
)
610 * The ACPI spec mandates that we send information
611 * for both drives, regardless whether they are connected
614 hwif
->devices
[0]->acpidata
= &hwif
->acpidata
->master
;
615 hwif
->devices
[1]->acpidata
= &hwif
->acpidata
->slave
;
617 /* get _ADR info for each device */
618 ide_port_for_each_present_dev(i
, drive
, hwif
) {
619 acpi_handle dev_handle
;
621 DEBPRINT("ENTER: %s at channel#: %d port#: %d\n",
622 drive
->name
, hwif
->channel
, drive
->dn
& 1);
624 /* TBD: could also check ACPI object VALID bits */
625 dev_handle
= acpi_get_child(hwif
->acpidata
->obj_handle
,
628 DEBPRINT("drive %s handle 0x%p\n", drive
->name
, dev_handle
);
630 drive
->acpidata
->obj_handle
= dev_handle
;
633 /* send IDENTIFY for each device */
634 ide_port_for_each_present_dev(i
, drive
, hwif
) {
635 err
= taskfile_lib_get_identify(drive
, drive
->acpidata
->idbuff
);
637 DEBPRINT("identify device %s failed (%d)\n",
641 if (!ide_acpionboot
) {
642 DEBPRINT("ACPI methods disabled on boot\n");
646 /* ACPI _PS0 before _STM */
647 ide_acpi_set_state(hwif
, 1);
649 * ACPI requires us to call _STM on startup
651 ide_acpi_get_timing(hwif
);
652 ide_acpi_push_timing(hwif
);
654 ide_port_for_each_present_dev(i
, drive
, hwif
) {
655 ide_acpi_exec_tfs(drive
);