3 * Provides ACPI support for PATA/SATA.
5 * Copyright (C) 2006 Intel Corp.
6 * Copyright (C) 2006 Randy Dunlap
9 #include <linux/module.h>
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 <linux/acpi.h>
16 #include <linux/libata.h>
17 #include <linux/pci.h>
18 #include <scsi/scsi_device.h>
21 #include <acpi/acpi_bus.h>
22 #include <acpi/acnames.h>
23 #include <acpi/acnamesp.h>
24 #include <acpi/acparser.h>
25 #include <acpi/acexcep.h>
26 #include <acpi/acmacros.h>
27 #include <acpi/actypes.h>
30 ATA_ACPI_FILTER_SETXFER
= 1 << 0,
31 ATA_ACPI_FILTER_LOCK
= 1 << 1,
33 ATA_ACPI_FILTER_DEFAULT
= ATA_ACPI_FILTER_SETXFER
|
37 static unsigned int ata_acpi_gtf_filter
= ATA_ACPI_FILTER_DEFAULT
;
38 module_param_named(acpi_gtf_filter
, ata_acpi_gtf_filter
, int, 0644);
39 MODULE_PARM_DESC(acpi_gtf_filter
, "filter mask for ACPI _GTF commands, set to filter out (0x1=set xfermode, 0x2=lock/freeze lock)");
41 #define NO_PORT_MULT 0xffff
42 #define SATA_ADR(root, pmp) (((root) << 16) | (pmp))
44 #define REGS_PER_GTF 7
46 u8 tf
[REGS_PER_GTF
]; /* regs. 0x1f1 - 0x1f7 */
50 * Helper - belongs in the PCI layer somewhere eventually
52 static int is_pci_dev(struct device
*dev
)
54 return (dev
->bus
== &pci_bus_type
);
57 static void ata_acpi_clear_gtf(struct ata_device
*dev
)
59 kfree(dev
->gtf_cache
);
60 dev
->gtf_cache
= NULL
;
64 * ata_acpi_associate_sata_port - associate SATA port with ACPI objects
65 * @ap: target SATA port
67 * Look up ACPI objects associated with @ap and initialize acpi_handle
68 * fields of @ap, the port and devices accordingly.
74 * 0 on success, -errno on failure.
76 void ata_acpi_associate_sata_port(struct ata_port
*ap
)
78 WARN_ON(!(ap
->flags
& ATA_FLAG_ACPI_SATA
));
80 if (!ap
->nr_pmp_links
) {
81 acpi_integer adr
= SATA_ADR(ap
->port_no
, NO_PORT_MULT
);
83 ap
->link
.device
->acpi_handle
=
84 acpi_get_child(ap
->host
->acpi_handle
, adr
);
86 struct ata_link
*link
;
88 ap
->link
.device
->acpi_handle
= NULL
;
90 ata_port_for_each_link(link
, ap
) {
91 acpi_integer adr
= SATA_ADR(ap
->port_no
, link
->pmp
);
93 link
->device
->acpi_handle
=
94 acpi_get_child(ap
->host
->acpi_handle
, adr
);
99 static void ata_acpi_associate_ide_port(struct ata_port
*ap
)
103 ap
->acpi_handle
= acpi_get_child(ap
->host
->acpi_handle
, ap
->port_no
);
104 if (!ap
->acpi_handle
)
108 if (ap
->flags
& ATA_FLAG_SLAVE_POSS
)
111 for (i
= 0; i
< max_devices
; i
++) {
112 struct ata_device
*dev
= &ap
->link
.device
[i
];
114 dev
->acpi_handle
= acpi_get_child(ap
->acpi_handle
, i
);
117 if (ata_acpi_gtm(ap
, &ap
->__acpi_init_gtm
) == 0)
118 ap
->pflags
|= ATA_PFLAG_INIT_GTM_VALID
;
121 static void ata_acpi_handle_hotplug(struct ata_port
*ap
, struct kobject
*kobj
,
124 char event_string
[12];
125 char *envp
[] = { event_string
, NULL
};
126 struct ata_eh_info
*ehi
= &ap
->link
.eh_info
;
128 if (event
== 0 || event
== 1) {
130 spin_lock_irqsave(ap
->lock
, flags
);
131 ata_ehi_clear_desc(ehi
);
132 ata_ehi_push_desc(ehi
, "ACPI event");
133 ata_ehi_hotplugged(ehi
);
135 spin_unlock_irqrestore(ap
->lock
, flags
);
139 sprintf(event_string
, "BAY_EVENT=%d", event
);
140 kobject_uevent_env(kobj
, KOBJ_CHANGE
, envp
);
144 static void ata_acpi_dev_notify(acpi_handle handle
, u32 event
, void *data
)
146 struct ata_device
*dev
= data
;
147 struct kobject
*kobj
= NULL
;
150 kobj
= &dev
->sdev
->sdev_gendev
.kobj
;
152 ata_acpi_handle_hotplug(dev
->link
->ap
, kobj
, event
);
155 static void ata_acpi_ap_notify(acpi_handle handle
, u32 event
, void *data
)
157 struct ata_port
*ap
= data
;
159 ata_acpi_handle_hotplug(ap
, &ap
->dev
->kobj
, event
);
163 * ata_acpi_associate - associate ATA host with ACPI objects
164 * @host: target ATA host
166 * Look up ACPI objects associated with @host and initialize
167 * acpi_handle fields of @host, its ports and devices accordingly.
173 * 0 on success, -errno on failure.
175 void ata_acpi_associate(struct ata_host
*host
)
179 if (!is_pci_dev(host
->dev
) || libata_noacpi
)
182 host
->acpi_handle
= DEVICE_ACPI_HANDLE(host
->dev
);
183 if (!host
->acpi_handle
)
186 for (i
= 0; i
< host
->n_ports
; i
++) {
187 struct ata_port
*ap
= host
->ports
[i
];
189 if (host
->ports
[0]->flags
& ATA_FLAG_ACPI_SATA
)
190 ata_acpi_associate_sata_port(ap
);
192 ata_acpi_associate_ide_port(ap
);
195 acpi_install_notify_handler (ap
->acpi_handle
,
200 for (j
= 0; j
< ata_link_max_devices(&ap
->link
); j
++) {
201 struct ata_device
*dev
= &ap
->link
.device
[j
];
203 if (dev
->acpi_handle
)
204 acpi_install_notify_handler (dev
->acpi_handle
,
213 * ata_acpi_dissociate - dissociate ATA host from ACPI objects
214 * @host: target ATA host
216 * This function is called during driver detach after the whole host
222 void ata_acpi_dissociate(struct ata_host
*host
)
226 /* Restore initial _GTM values so that driver which attaches
227 * afterward can use them too.
229 for (i
= 0; i
< host
->n_ports
; i
++) {
230 struct ata_port
*ap
= host
->ports
[i
];
231 const struct ata_acpi_gtm
*gtm
= ata_acpi_init_gtm(ap
);
233 if (ap
->acpi_handle
&& gtm
)
234 ata_acpi_stm(ap
, gtm
);
239 * ata_acpi_gtm - execute _GTM
240 * @ap: target ATA port
241 * @gtm: out parameter for _GTM result
243 * Evaluate _GTM and store the result in @gtm.
249 * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
251 int ata_acpi_gtm(struct ata_port
*ap
, struct ata_acpi_gtm
*gtm
)
253 struct acpi_buffer output
= { .length
= ACPI_ALLOCATE_BUFFER
};
254 union acpi_object
*out_obj
;
258 status
= acpi_evaluate_object(ap
->acpi_handle
, "_GTM", NULL
, &output
);
261 if (status
== AE_NOT_FOUND
)
265 if (ACPI_FAILURE(status
)) {
266 ata_port_printk(ap
, KERN_ERR
,
267 "ACPI get timing mode failed (AE 0x%x)\n",
272 out_obj
= output
.pointer
;
273 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
274 ata_port_printk(ap
, KERN_WARNING
,
275 "_GTM returned unexpected object type 0x%x\n",
281 if (out_obj
->buffer
.length
!= sizeof(struct ata_acpi_gtm
)) {
282 ata_port_printk(ap
, KERN_ERR
,
283 "_GTM returned invalid length %d\n",
284 out_obj
->buffer
.length
);
288 memcpy(gtm
, out_obj
->buffer
.pointer
, sizeof(struct ata_acpi_gtm
));
291 kfree(output
.pointer
);
295 EXPORT_SYMBOL_GPL(ata_acpi_gtm
);
298 * ata_acpi_stm - execute _STM
299 * @ap: target ATA port
300 * @stm: timing parameter to _STM
302 * Evaluate _STM with timing parameter @stm.
308 * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
310 int ata_acpi_stm(struct ata_port
*ap
, const struct ata_acpi_gtm
*stm
)
313 struct ata_acpi_gtm stm_buf
= *stm
;
314 struct acpi_object_list input
;
315 union acpi_object in_params
[3];
317 in_params
[0].type
= ACPI_TYPE_BUFFER
;
318 in_params
[0].buffer
.length
= sizeof(struct ata_acpi_gtm
);
319 in_params
[0].buffer
.pointer
= (u8
*)&stm_buf
;
320 /* Buffers for id may need byteswapping ? */
321 in_params
[1].type
= ACPI_TYPE_BUFFER
;
322 in_params
[1].buffer
.length
= 512;
323 in_params
[1].buffer
.pointer
= (u8
*)ap
->link
.device
[0].id
;
324 in_params
[2].type
= ACPI_TYPE_BUFFER
;
325 in_params
[2].buffer
.length
= 512;
326 in_params
[2].buffer
.pointer
= (u8
*)ap
->link
.device
[1].id
;
329 input
.pointer
= in_params
;
331 status
= acpi_evaluate_object(ap
->acpi_handle
, "_STM", &input
, NULL
);
333 if (status
== AE_NOT_FOUND
)
335 if (ACPI_FAILURE(status
)) {
336 ata_port_printk(ap
, KERN_ERR
,
337 "ACPI set timing mode failed (status=0x%x)\n", status
);
343 EXPORT_SYMBOL_GPL(ata_acpi_stm
);
346 * ata_dev_get_GTF - get the drive bootup default taskfile settings
347 * @dev: target ATA device
348 * @gtf: output parameter for buffer containing _GTF taskfile arrays
350 * This applies to both PATA and SATA drives.
352 * The _GTF method has no input parameters.
353 * It returns a variable number of register set values (registers
354 * hex 1F1..1F7, taskfiles).
355 * The <variable number> is not known in advance, so have ACPI-CA
356 * allocate the buffer as needed and return it, then free it later.
362 * Number of taskfiles on success, 0 if _GTF doesn't exist. -EINVAL
363 * if _GTF is invalid.
365 static int ata_dev_get_GTF(struct ata_device
*dev
, struct ata_acpi_gtf
**gtf
)
367 struct ata_port
*ap
= dev
->link
->ap
;
369 struct acpi_buffer output
;
370 union acpi_object
*out_obj
;
373 /* if _GTF is cached, use the cached value */
374 if (dev
->gtf_cache
) {
375 out_obj
= dev
->gtf_cache
;
379 /* set up output buffer */
380 output
.length
= ACPI_ALLOCATE_BUFFER
;
381 output
.pointer
= NULL
; /* ACPI-CA sets this; save/free it later */
383 if (ata_msg_probe(ap
))
384 ata_dev_printk(dev
, KERN_DEBUG
, "%s: ENTER: port#: %d\n",
385 __FUNCTION__
, ap
->port_no
);
387 /* _GTF has no input parameters */
388 status
= acpi_evaluate_object(dev
->acpi_handle
, "_GTF", NULL
, &output
);
389 out_obj
= dev
->gtf_cache
= output
.pointer
;
391 if (ACPI_FAILURE(status
)) {
392 if (status
!= AE_NOT_FOUND
) {
393 ata_dev_printk(dev
, KERN_WARNING
,
394 "_GTF evaluation failed (AE 0x%x)\n",
401 if (!output
.length
|| !output
.pointer
) {
402 if (ata_msg_probe(ap
))
403 ata_dev_printk(dev
, KERN_DEBUG
, "%s: Run _GTF: "
404 "length or ptr is NULL (0x%llx, 0x%p)\n",
406 (unsigned long long)output
.length
,
412 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
413 ata_dev_printk(dev
, KERN_WARNING
,
414 "_GTF unexpected object type 0x%x\n",
420 if (out_obj
->buffer
.length
% REGS_PER_GTF
) {
421 ata_dev_printk(dev
, KERN_WARNING
,
422 "unexpected _GTF length (%d)\n",
423 out_obj
->buffer
.length
);
429 rc
= out_obj
->buffer
.length
/ REGS_PER_GTF
;
431 *gtf
= (void *)out_obj
->buffer
.pointer
;
432 if (ata_msg_probe(ap
))
433 ata_dev_printk(dev
, KERN_DEBUG
,
434 "%s: returning gtf=%p, gtf_count=%d\n",
435 __FUNCTION__
, *gtf
, rc
);
440 ata_acpi_clear_gtf(dev
);
444 /* Welcome to ACPI, bring a bucket */
445 const unsigned int ata_acpi_pio_cycle
[7] = {
446 600, 383, 240, 180, 120, 100, 80
448 EXPORT_SYMBOL_GPL(ata_acpi_pio_cycle
);
450 const unsigned int ata_acpi_mwdma_cycle
[5] = {
451 480, 150, 120, 100, 80
453 EXPORT_SYMBOL_GPL(ata_acpi_mwdma_cycle
);
455 const unsigned int ata_acpi_udma_cycle
[7] = {
456 120, 80, 60, 45, 30, 20, 15
458 EXPORT_SYMBOL_GPL(ata_acpi_udma_cycle
);
461 * ata_acpi_gtm_xfermode - determine xfermode from GTM parameter
462 * @dev: target device
463 * @gtm: GTM parameter to use
465 * Determine xfermask for @dev from @gtm.
471 * Determined xfermask.
473 unsigned long ata_acpi_gtm_xfermask(struct ata_device
*dev
,
474 const struct ata_acpi_gtm
*gtm
)
476 unsigned long pio_mask
= 0, mwdma_mask
= 0, udma_mask
= 0;
480 /* we always use the 0 slot for crap hardware */
482 if (!(gtm
->flags
& 0x10))
485 /* Values larger than the longest cycle results in 0 mask
486 * while values equal to smaller than the shortest cycle
487 * results in mask which includes all supported modes.
488 * Disabled transfer method has the value of 0xffffffff which
489 * will always result in 0 mask.
492 /* start by scanning for PIO modes */
493 t
= gtm
->drive
[unit
].pio
;
494 for (i
= 0; i
< ARRAY_SIZE(ata_acpi_pio_cycle
); i
++)
495 if (t
> ata_acpi_pio_cycle
[i
])
497 pio_mask
= (1 << i
) - 1;
499 /* See if we have MWDMA or UDMA data. We don't bother with
500 * MWDMA if UDMA is available as this means the BIOS set UDMA
501 * and our error changedown if it works is UDMA to PIO anyway.
503 t
= gtm
->drive
[unit
].dma
;
504 if (!(gtm
->flags
& (1 << (2 * unit
)))) {
506 for (i
= 0; i
< ARRAY_SIZE(ata_acpi_mwdma_cycle
); i
++)
507 if (t
> ata_acpi_mwdma_cycle
[i
])
509 mwdma_mask
= (1 << i
) - 1;
512 for (i
= 0; i
< ARRAY_SIZE(ata_acpi_udma_cycle
); i
++)
513 if (t
> ata_acpi_udma_cycle
[i
])
515 udma_mask
= (1 << i
) - 1;
518 return ata_pack_xfermask(pio_mask
, mwdma_mask
, udma_mask
);
520 EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask
);
523 * ata_acpi_cbl_80wire - Check for 80 wire cable
526 * Return 1 if the ACPI mode data for this port indicates the BIOS selected
530 int ata_acpi_cbl_80wire(struct ata_port
*ap
)
532 const struct ata_acpi_gtm
*gtm
= ata_acpi_init_gtm(ap
);
538 /* Split timing, DMA enabled */
539 if ((gtm
->flags
& 0x11) == 0x11 && gtm
->drive
[0].dma
< 55)
541 if ((gtm
->flags
& 0x14) == 0x14 && gtm
->drive
[1].dma
< 55)
543 /* Shared timing, DMA enabled */
544 if ((gtm
->flags
& 0x11) == 0x01 && gtm
->drive
[0].dma
< 55)
546 if ((gtm
->flags
& 0x14) == 0x04 && gtm
->drive
[0].dma
< 55)
550 if ((valid
& 1) && ata_dev_enabled(&ap
->link
.device
[0]))
552 if ((valid
& 2) && ata_dev_enabled(&ap
->link
.device
[1]))
557 EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire
);
559 static void ata_acpi_gtf_to_tf(struct ata_device
*dev
,
560 const struct ata_acpi_gtf
*gtf
,
561 struct ata_taskfile
*tf
)
563 ata_tf_init(dev
, tf
);
565 tf
->flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
;
566 tf
->protocol
= ATA_PROT_NODATA
;
567 tf
->feature
= gtf
->tf
[0]; /* 0x1f1 */
568 tf
->nsect
= gtf
->tf
[1]; /* 0x1f2 */
569 tf
->lbal
= gtf
->tf
[2]; /* 0x1f3 */
570 tf
->lbam
= gtf
->tf
[3]; /* 0x1f4 */
571 tf
->lbah
= gtf
->tf
[4]; /* 0x1f5 */
572 tf
->device
= gtf
->tf
[5]; /* 0x1f6 */
573 tf
->command
= gtf
->tf
[6]; /* 0x1f7 */
576 static int ata_acpi_filter_tf(const struct ata_taskfile
*tf
,
577 const struct ata_taskfile
*ptf
)
579 if (ata_acpi_gtf_filter
& ATA_ACPI_FILTER_SETXFER
) {
580 /* libata doesn't use ACPI to configure transfer mode.
581 * It will only confuse device configuration. Skip.
583 if (tf
->command
== ATA_CMD_SET_FEATURES
&&
584 tf
->feature
== SETFEATURES_XFER
)
588 if (ata_acpi_gtf_filter
& ATA_ACPI_FILTER_LOCK
) {
589 /* BIOS writers, sorry but we don't wanna lock
590 * features unless the user explicitly said so.
593 /* DEVICE CONFIGURATION FREEZE LOCK */
594 if (tf
->command
== ATA_CMD_CONF_OVERLAY
&&
595 tf
->feature
== ATA_DCO_FREEZE_LOCK
)
598 /* SECURITY FREEZE LOCK */
599 if (tf
->command
== ATA_CMD_SEC_FREEZE_LOCK
)
602 /* SET MAX LOCK and SET MAX FREEZE LOCK */
603 if ((!ptf
|| ptf
->command
!= ATA_CMD_READ_NATIVE_MAX
) &&
604 tf
->command
== ATA_CMD_SET_MAX
&&
605 (tf
->feature
== ATA_SET_MAX_LOCK
||
606 tf
->feature
== ATA_SET_MAX_FREEZE_LOCK
))
614 * ata_acpi_run_tf - send taskfile registers to host controller
615 * @dev: target ATA device
616 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
618 * Outputs ATA taskfile to standard ATA host controller using MMIO
619 * or PIO as indicated by the ATA_FLAG_MMIO flag.
620 * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
621 * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
622 * hob_lbal, hob_lbam, and hob_lbah.
624 * This function waits for idle (!BUSY and !DRQ) after writing
625 * registers. If the control register has a new value, this
626 * function also waits for idle after writing control and before
627 * writing the remaining registers.
633 * 1 if command is executed successfully. 0 if ignored, rejected or
634 * filtered out, -errno on other errors.
636 static int ata_acpi_run_tf(struct ata_device
*dev
,
637 const struct ata_acpi_gtf
*gtf
,
638 const struct ata_acpi_gtf
*prev_gtf
)
640 struct ata_taskfile
*pptf
= NULL
;
641 struct ata_taskfile tf
, ptf
, rtf
;
642 unsigned int err_mask
;
647 if ((gtf
->tf
[0] == 0) && (gtf
->tf
[1] == 0) && (gtf
->tf
[2] == 0)
648 && (gtf
->tf
[3] == 0) && (gtf
->tf
[4] == 0) && (gtf
->tf
[5] == 0)
649 && (gtf
->tf
[6] == 0))
652 ata_acpi_gtf_to_tf(dev
, gtf
, &tf
);
654 ata_acpi_gtf_to_tf(dev
, prev_gtf
, &ptf
);
658 if (!ata_acpi_filter_tf(&tf
, pptf
)) {
660 err_mask
= ata_exec_internal(dev
, &rtf
, NULL
,
661 DMA_NONE
, NULL
, 0, 0);
666 snprintf(msg
, sizeof(msg
), "succeeded");
672 snprintf(msg
, sizeof(msg
),
673 "rejected by device (Stat=0x%02x Err=0x%02x)",
674 rtf
.command
, rtf
.feature
);
680 snprintf(msg
, sizeof(msg
),
681 "failed (Emask=0x%x Stat=0x%02x Err=0x%02x)",
682 err_mask
, rtf
.command
, rtf
.feature
);
688 snprintf(msg
, sizeof(msg
), "filtered out");
692 ata_dev_printk(dev
, level
,
693 "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x %s\n",
694 tf
.command
, tf
.feature
, tf
.nsect
, tf
.lbal
,
695 tf
.lbam
, tf
.lbah
, tf
.device
, msg
);
701 * ata_acpi_exec_tfs - get then write drive taskfile settings
702 * @dev: target ATA device
703 * @nr_executed: out paramter for the number of executed commands
705 * Evaluate _GTF and excute returned taskfiles.
711 * Number of executed taskfiles on success, 0 if _GTF doesn't exist.
712 * -errno on other errors.
714 static int ata_acpi_exec_tfs(struct ata_device
*dev
, int *nr_executed
)
716 struct ata_acpi_gtf
*gtf
= NULL
, *pgtf
= NULL
;
717 int gtf_count
, i
, rc
;
720 rc
= ata_dev_get_GTF(dev
, >f
);
726 for (i
= 0; i
< gtf_count
; i
++, gtf
++) {
727 rc
= ata_acpi_run_tf(dev
, gtf
, pgtf
);
736 ata_acpi_clear_gtf(dev
);
744 * ata_acpi_push_id - send Identify data to drive
745 * @dev: target ATA device
747 * _SDD ACPI object: for SATA mode only
748 * Must be after Identify (Packet) Device -- uses its data
749 * ATM this function never returns a failure. It is an optional
750 * method and if it fails for whatever reason, we should still
757 * 0 on success, -errno on failure.
759 static int ata_acpi_push_id(struct ata_device
*dev
)
761 struct ata_port
*ap
= dev
->link
->ap
;
764 struct acpi_object_list input
;
765 union acpi_object in_params
[1];
767 if (ata_msg_probe(ap
))
768 ata_dev_printk(dev
, KERN_DEBUG
, "%s: ix = %d, port#: %d\n",
769 __FUNCTION__
, dev
->devno
, ap
->port_no
);
771 /* Give the drive Identify data to the drive via the _SDD method */
772 /* _SDD: set up input parameters */
774 input
.pointer
= in_params
;
775 in_params
[0].type
= ACPI_TYPE_BUFFER
;
776 in_params
[0].buffer
.length
= sizeof(dev
->id
[0]) * ATA_ID_WORDS
;
777 in_params
[0].buffer
.pointer
= (u8
*)dev
->id
;
778 /* Output buffer: _SDD has no output */
780 /* It's OK for _SDD to be missing too. */
781 swap_buf_le16(dev
->id
, ATA_ID_WORDS
);
782 status
= acpi_evaluate_object(dev
->acpi_handle
, "_SDD", &input
, NULL
);
783 swap_buf_le16(dev
->id
, ATA_ID_WORDS
);
785 err
= ACPI_FAILURE(status
) ? -EIO
: 0;
787 ata_dev_printk(dev
, KERN_WARNING
,
788 "ACPI _SDD failed (AE 0x%x)\n", status
);
794 * ata_acpi_on_suspend - ATA ACPI hook called on suspend
795 * @ap: target ATA port
797 * This function is called when @ap is about to be suspended. All
798 * devices are already put to sleep but the port_suspend() callback
799 * hasn't been executed yet. Error return from this function aborts
806 * 0 on success, -errno on failure.
808 int ata_acpi_on_suspend(struct ata_port
*ap
)
815 * ata_acpi_on_resume - ATA ACPI hook called on resume
816 * @ap: target ATA port
818 * This function is called when @ap is resumed - right after port
819 * itself is resumed but before any EH action is taken.
824 void ata_acpi_on_resume(struct ata_port
*ap
)
826 const struct ata_acpi_gtm
*gtm
= ata_acpi_init_gtm(ap
);
827 struct ata_device
*dev
;
829 if (ap
->acpi_handle
&& gtm
) {
832 /* restore timing parameters */
833 ata_acpi_stm(ap
, gtm
);
835 /* _GTF should immediately follow _STM so that it can
836 * use values set by _STM. Cache _GTF result and
839 ata_link_for_each_dev(dev
, &ap
->link
) {
840 ata_acpi_clear_gtf(dev
);
841 if (ata_dev_get_GTF(dev
, NULL
) >= 0)
842 dev
->flags
|= ATA_DFLAG_ACPI_PENDING
;
845 /* SATA _GTF needs to be evaulated after _SDD and
846 * there's no reason to evaluate IDE _GTF early
847 * without _STM. Clear cache and schedule _GTF.
849 ata_link_for_each_dev(dev
, &ap
->link
) {
850 ata_acpi_clear_gtf(dev
);
851 dev
->flags
|= ATA_DFLAG_ACPI_PENDING
;
857 * ata_acpi_set_state - set the port power state
858 * @ap: target ATA port
859 * @state: state, on/off
861 * This function executes the _PS0/_PS3 ACPI method to set the power state.
862 * ACPI spec requires _PS0 when IDE power on and _PS3 when power off
864 void ata_acpi_set_state(struct ata_port
*ap
, pm_message_t state
)
866 struct ata_device
*dev
;
868 if (!ap
->acpi_handle
|| (ap
->flags
& ATA_FLAG_ACPI_SATA
))
871 /* channel first and then drives for power on and vica versa
873 if (state
.event
== PM_EVENT_ON
)
874 acpi_bus_set_power(ap
->acpi_handle
, ACPI_STATE_D0
);
876 ata_link_for_each_dev(dev
, &ap
->link
) {
877 if (dev
->acpi_handle
&& ata_dev_enabled(dev
))
878 acpi_bus_set_power(dev
->acpi_handle
,
879 state
.event
== PM_EVENT_ON
?
880 ACPI_STATE_D0
: ACPI_STATE_D3
);
882 if (state
.event
!= PM_EVENT_ON
)
883 acpi_bus_set_power(ap
->acpi_handle
, ACPI_STATE_D3
);
887 * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
888 * @dev: target ATA device
890 * This function is called when @dev is about to be configured.
891 * IDENTIFY data might have been modified after this hook is run.
897 * Positive number if IDENTIFY data needs to be refreshed, 0 if not,
900 int ata_acpi_on_devcfg(struct ata_device
*dev
)
902 struct ata_port
*ap
= dev
->link
->ap
;
903 struct ata_eh_context
*ehc
= &ap
->link
.eh_context
;
904 int acpi_sata
= ap
->flags
& ATA_FLAG_ACPI_SATA
;
908 if (!dev
->acpi_handle
)
911 /* do we need to do _GTF? */
912 if (!(dev
->flags
& ATA_DFLAG_ACPI_PENDING
) &&
913 !(acpi_sata
&& (ehc
->i
.flags
& ATA_EHI_DID_HARDRESET
)))
916 /* do _SDD if SATA */
918 rc
= ata_acpi_push_id(dev
);
924 rc
= ata_acpi_exec_tfs(dev
, &nr_executed
);
928 dev
->flags
&= ~ATA_DFLAG_ACPI_PENDING
;
930 /* refresh IDENTIFY page if any _GTF command has been executed */
932 rc
= ata_dev_reread_id(dev
, 0);
934 ata_dev_printk(dev
, KERN_ERR
, "failed to IDENTIFY "
935 "after ACPI commands\n");
943 /* ignore evaluation failure if we can continue safely */
944 if (rc
== -EINVAL
&& !nr_executed
&& !(ap
->pflags
& ATA_PFLAG_FROZEN
))
947 /* fail and let EH retry once more for unknown IO errors */
948 if (!(dev
->flags
& ATA_DFLAG_ACPI_FAILED
)) {
949 dev
->flags
|= ATA_DFLAG_ACPI_FAILED
;
953 ata_dev_printk(dev
, KERN_WARNING
,
954 "ACPI: failed the second time, disabled\n");
955 dev
->acpi_handle
= NULL
;
957 /* We can safely continue if no _GTF command has been executed
958 * and port is not frozen.
960 if (!nr_executed
&& !(ap
->pflags
& ATA_PFLAG_FROZEN
))
967 * ata_acpi_on_disable - ATA ACPI hook called when a device is disabled
968 * @dev: target ATA device
970 * This function is called when @dev is about to be disabled.
975 void ata_acpi_on_disable(struct ata_device
*dev
)
977 ata_acpi_clear_gtf(dev
);