Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 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 | |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 27 | #define NO_PORT_MULT 0xffff |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 28 | #define SATA_ADR(root,pmp) (((root) << 16) | (pmp)) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 29 | |
| 30 | #define REGS_PER_GTF 7 |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 31 | struct ata_acpi_gtf { |
| 32 | u8 tf[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */ |
| 33 | } __packed; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 34 | |
Alan Cox | ca42663 | 2007-03-08 23:13:50 +0000 | [diff] [blame] | 35 | /* |
| 36 | * Helper - belongs in the PCI layer somewhere eventually |
| 37 | */ |
| 38 | static int is_pci_dev(struct device *dev) |
| 39 | { |
| 40 | return (dev->bus == &pci_bus_type); |
| 41 | } |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 42 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 43 | static void ata_acpi_associate_sata_port(struct ata_port *ap) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 44 | { |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 45 | acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 46 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 47 | ap->device->acpi_handle = acpi_get_child(ap->host->acpi_handle, adr); |
| 48 | } |
Alan Cox | ca42663 | 2007-03-08 23:13:50 +0000 | [diff] [blame] | 49 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 50 | static void ata_acpi_associate_ide_port(struct ata_port *ap) |
| 51 | { |
| 52 | int max_devices, i; |
| 53 | |
| 54 | ap->acpi_handle = acpi_get_child(ap->host->acpi_handle, ap->port_no); |
| 55 | if (!ap->acpi_handle) |
| 56 | return; |
| 57 | |
| 58 | max_devices = 1; |
| 59 | if (ap->flags & ATA_FLAG_SLAVE_POSS) |
| 60 | max_devices++; |
| 61 | |
| 62 | for (i = 0; i < max_devices; i++) { |
| 63 | struct ata_device *dev = &ap->device[i]; |
| 64 | |
| 65 | dev->acpi_handle = acpi_get_child(ap->acpi_handle, i); |
| 66 | } |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | /** |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 70 | * ata_acpi_associate - associate ATA host with ACPI objects |
| 71 | * @host: target ATA host |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 72 | * |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 73 | * Look up ACPI objects associated with @host and initialize |
| 74 | * acpi_handle fields of @host, its ports and devices accordingly. |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 75 | * |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 76 | * LOCKING: |
| 77 | * EH context. |
| 78 | * |
| 79 | * RETURNS: |
| 80 | * 0 on success, -errno on failure. |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 81 | */ |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 82 | void ata_acpi_associate(struct ata_host *host) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 83 | { |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 84 | int i; |
Alan Cox | ca42663 | 2007-03-08 23:13:50 +0000 | [diff] [blame] | 85 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 86 | if (!is_pci_dev(host->dev) || libata_noacpi) |
| 87 | return; |
Alan Cox | ca42663 | 2007-03-08 23:13:50 +0000 | [diff] [blame] | 88 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 89 | host->acpi_handle = DEVICE_ACPI_HANDLE(host->dev); |
| 90 | if (!host->acpi_handle) |
| 91 | return; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 92 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 93 | for (i = 0; i < host->n_ports; i++) { |
| 94 | struct ata_port *ap = host->ports[i]; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 95 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 96 | if (host->ports[0]->flags & ATA_FLAG_ACPI_SATA) |
| 97 | ata_acpi_associate_sata_port(ap); |
| 98 | else |
| 99 | ata_acpi_associate_ide_port(ap); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 100 | } |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 101 | } |
| 102 | |
| 103 | /** |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 104 | * ata_dev_get_GTF - get the drive bootup default taskfile settings |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 105 | * @dev: target ATA device |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 106 | * @gtf: output parameter for buffer containing _GTF taskfile arrays |
| 107 | * @ptr_to_free: pointer which should be freed |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 108 | * |
| 109 | * This applies to both PATA and SATA drives. |
| 110 | * |
| 111 | * The _GTF method has no input parameters. |
| 112 | * It returns a variable number of register set values (registers |
| 113 | * hex 1F1..1F7, taskfiles). |
| 114 | * The <variable number> is not known in advance, so have ACPI-CA |
| 115 | * allocate the buffer as needed and return it, then free it later. |
| 116 | * |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 117 | * LOCKING: |
| 118 | * EH context. |
| 119 | * |
| 120 | * RETURNS: |
| 121 | * Number of taskfiles on success, 0 if _GTF doesn't exist or doesn't |
| 122 | * contain valid data. -errno on other errors. |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 123 | */ |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 124 | static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf, |
| 125 | void **ptr_to_free) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 126 | { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 127 | struct ata_port *ap = dev->ap; |
| 128 | acpi_status status; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 129 | struct acpi_buffer output; |
| 130 | union acpi_object *out_obj; |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 131 | int rc = 0; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 132 | |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 133 | /* set up output buffer */ |
| 134 | output.length = ACPI_ALLOCATE_BUFFER; |
| 135 | output.pointer = NULL; /* ACPI-CA sets this; save/free it later */ |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 136 | |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 137 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 138 | ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n", |
Tejun Heo | 878d4fe | 2007-02-21 16:36:33 +0900 | [diff] [blame] | 139 | __FUNCTION__, ap->port_no); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 140 | |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 141 | /* _GTF has no input parameters */ |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 142 | status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output); |
| 143 | |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 144 | if (ACPI_FAILURE(status)) { |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 145 | if (status != AE_NOT_FOUND) { |
| 146 | ata_dev_printk(dev, KERN_WARNING, |
| 147 | "_GTF evaluation failed (AE 0x%x)\n", |
| 148 | status); |
| 149 | rc = -EIO; |
| 150 | } |
| 151 | goto out_free; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 152 | } |
| 153 | |
| 154 | if (!output.length || !output.pointer) { |
| 155 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 156 | ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: " |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 157 | "length or ptr is NULL (0x%llx, 0x%p)\n", |
| 158 | __FUNCTION__, |
| 159 | (unsigned long long)output.length, |
| 160 | output.pointer); |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 161 | goto out_free; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | out_obj = output.pointer; |
| 165 | if (out_obj->type != ACPI_TYPE_BUFFER) { |
Tejun Heo | 69b16a5 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 166 | ata_dev_printk(dev, KERN_WARNING, |
| 167 | "_GTF unexpected object type 0x%x\n", |
| 168 | out_obj->type); |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 169 | rc = -EINVAL; |
| 170 | goto out_free; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 171 | } |
| 172 | |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 173 | if (out_obj->buffer.length % REGS_PER_GTF) { |
Tejun Heo | 69b16a5 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 174 | ata_dev_printk(dev, KERN_WARNING, |
| 175 | "unexpected _GTF length (%d)\n", |
| 176 | out_obj->buffer.length); |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 177 | rc = -EINVAL; |
| 178 | goto out_free; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 179 | } |
| 180 | |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 181 | *ptr_to_free = out_obj; |
| 182 | *gtf = (void *)out_obj->buffer.pointer; |
| 183 | rc = out_obj->buffer.length / REGS_PER_GTF; |
| 184 | |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 185 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 186 | ata_dev_printk(dev, KERN_DEBUG, "%s: returning " |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 187 | "gtf=%p, gtf_count=%d, ptr_to_free=%p\n", |
| 188 | __FUNCTION__, *gtf, rc, *ptr_to_free); |
| 189 | return rc; |
| 190 | |
| 191 | out_free: |
| 192 | kfree(output.pointer); |
| 193 | return rc; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 194 | } |
| 195 | |
| 196 | /** |
| 197 | * taskfile_load_raw - send taskfile registers to host controller |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 198 | * @dev: target ATA device |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 199 | * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7) |
| 200 | * |
| 201 | * Outputs ATA taskfile to standard ATA host controller using MMIO |
| 202 | * or PIO as indicated by the ATA_FLAG_MMIO flag. |
| 203 | * Writes the control, feature, nsect, lbal, lbam, and lbah registers. |
| 204 | * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect, |
| 205 | * hob_lbal, hob_lbam, and hob_lbah. |
| 206 | * |
| 207 | * This function waits for idle (!BUSY and !DRQ) after writing |
| 208 | * registers. If the control register has a new value, this |
| 209 | * function also waits for idle after writing control and before |
| 210 | * writing the remaining registers. |
| 211 | * |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 212 | * LOCKING: |
| 213 | * EH context. |
| 214 | * |
| 215 | * RETURNS: |
| 216 | * 0 on success, -errno on failure. |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 217 | */ |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 218 | static int taskfile_load_raw(struct ata_device *dev, |
| 219 | const struct ata_acpi_gtf *gtf) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 220 | { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 221 | struct ata_port *ap = dev->ap; |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 222 | struct ata_taskfile tf, rtf; |
| 223 | unsigned int err_mask; |
Jeff Garzik | fc16c25 | 2007-02-24 21:05:01 -0500 | [diff] [blame] | 224 | |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 225 | if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0) |
| 226 | && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0) |
| 227 | && (gtf->tf[6] == 0)) |
| 228 | return 0; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 229 | |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 230 | ata_tf_init(dev, &tf); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 231 | |
Jeff Garzik | fc16c25 | 2007-02-24 21:05:01 -0500 | [diff] [blame] | 232 | /* convert gtf to tf */ |
| 233 | tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */ |
Tejun Heo | 48be6b1 | 2007-04-23 02:06:46 +0900 | [diff] [blame] | 234 | tf.protocol = ATA_PROT_NODATA; |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 235 | tf.feature = gtf->tf[0]; /* 0x1f1 */ |
| 236 | tf.nsect = gtf->tf[1]; /* 0x1f2 */ |
| 237 | tf.lbal = gtf->tf[2]; /* 0x1f3 */ |
| 238 | tf.lbam = gtf->tf[3]; /* 0x1f4 */ |
| 239 | tf.lbah = gtf->tf[4]; /* 0x1f5 */ |
| 240 | tf.device = gtf->tf[5]; /* 0x1f6 */ |
| 241 | tf.command = gtf->tf[6]; /* 0x1f7 */ |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 242 | |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 243 | if (ata_msg_probe(ap)) |
| 244 | ata_dev_printk(dev, KERN_DEBUG, "executing ACPI cmd " |
| 245 | "%02x/%02x:%02x:%02x:%02x:%02x:%02x\n", |
| 246 | tf.command, tf.feature, tf.nsect, |
| 247 | tf.lbal, tf.lbam, tf.lbah, tf.device); |
| 248 | |
| 249 | rtf = tf; |
| 250 | err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0); |
| 251 | if (err_mask) { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 252 | ata_dev_printk(dev, KERN_ERR, |
Tejun Heo | 4700c4b | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 253 | "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed " |
| 254 | "(Emask=0x%x Stat=0x%02x Err=0x%02x)\n", |
| 255 | tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam, |
| 256 | tf.lbah, tf.device, err_mask, rtf.command, rtf.feature); |
| 257 | return -EIO; |
| 258 | } |
| 259 | |
| 260 | return 0; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 261 | } |
| 262 | |
| 263 | /** |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 264 | * ata_acpi_exec_tfs - get then write drive taskfile settings |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 265 | * @dev: target ATA device |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 266 | * |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 267 | * Evaluate _GTF and excute returned taskfiles. |
Tejun Heo | 69b16a5 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 268 | * |
| 269 | * LOCKING: |
| 270 | * EH context. |
| 271 | * |
| 272 | * RETURNS: |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 273 | * Number of executed taskfiles on success, 0 if _GTF doesn't exist or |
| 274 | * doesn't contain valid data. -errno on other errors. |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 275 | */ |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 276 | static int ata_acpi_exec_tfs(struct ata_device *dev) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 277 | { |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 278 | struct ata_acpi_gtf *gtf = NULL; |
| 279 | void *ptr_to_free = NULL; |
| 280 | int gtf_count, i, rc; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 281 | |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 282 | /* get taskfiles */ |
| 283 | rc = ata_dev_get_GTF(dev, >f, &ptr_to_free); |
| 284 | if (rc < 0) |
| 285 | return rc; |
| 286 | gtf_count = rc; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 287 | |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 288 | /* execute them */ |
| 289 | for (i = 0, rc = 0; i < gtf_count; i++) { |
| 290 | int tmp; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 291 | |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 292 | /* ACPI errors are eventually ignored. Run till the |
| 293 | * end even after errors. |
| 294 | */ |
| 295 | tmp = taskfile_load_raw(dev, gtf++); |
| 296 | if (!rc) |
| 297 | rc = tmp; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 298 | } |
| 299 | |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 300 | kfree(ptr_to_free); |
| 301 | |
| 302 | if (rc == 0) |
| 303 | return gtf_count; |
| 304 | return rc; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 305 | } |
| 306 | |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 307 | /** |
| 308 | * ata_acpi_push_id - send Identify data to drive |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 309 | * @dev: target ATA device |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 310 | * |
| 311 | * _SDD ACPI object: for SATA mode only |
| 312 | * Must be after Identify (Packet) Device -- uses its data |
| 313 | * ATM this function never returns a failure. It is an optional |
| 314 | * method and if it fails for whatever reason, we should still |
| 315 | * just keep going. |
Tejun Heo | 69b16a5 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 316 | * |
| 317 | * LOCKING: |
| 318 | * EH context. |
| 319 | * |
| 320 | * RETURNS: |
| 321 | * 0 on success, -errno on failure. |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 322 | */ |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 323 | static int ata_acpi_push_id(struct ata_device *dev) |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 324 | { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 325 | struct ata_port *ap = dev->ap; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 326 | int err; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 327 | acpi_status status; |
| 328 | struct acpi_object_list input; |
| 329 | union acpi_object in_params[1]; |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 330 | |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 331 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 332 | ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n", |
| 333 | __FUNCTION__, dev->devno, ap->port_no); |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 334 | |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 335 | /* Give the drive Identify data to the drive via the _SDD method */ |
| 336 | /* _SDD: set up input parameters */ |
| 337 | input.count = 1; |
| 338 | input.pointer = in_params; |
| 339 | in_params[0].type = ACPI_TYPE_BUFFER; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 340 | in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS; |
| 341 | in_params[0].buffer.pointer = (u8 *)dev->id; |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 342 | /* Output buffer: _SDD has no output */ |
| 343 | |
| 344 | /* It's OK for _SDD to be missing too. */ |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 345 | swap_buf_le16(dev->id, ATA_ID_WORDS); |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 346 | status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL); |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 347 | swap_buf_le16(dev->id, ATA_ID_WORDS); |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 348 | |
| 349 | err = ACPI_FAILURE(status) ? -EIO : 0; |
Tejun Heo | 69b16a5 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 350 | if (err < 0) |
| 351 | ata_dev_printk(dev, KERN_WARNING, |
| 352 | "ACPI _SDD failed (AE 0x%x)\n", status); |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 353 | |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 354 | return err; |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 355 | } |
| 356 | |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 357 | /** |
| 358 | * ata_acpi_on_resume - ATA ACPI hook called on resume |
| 359 | * @ap: target ATA port |
| 360 | * |
| 361 | * This function is called when @ap is resumed - right after port |
| 362 | * itself is resumed but before any EH action is taken. |
| 363 | * |
| 364 | * LOCKING: |
| 365 | * EH context. |
| 366 | */ |
| 367 | void ata_acpi_on_resume(struct ata_port *ap) |
| 368 | { |
| 369 | int i; |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 370 | |
Tejun Heo | 6746544 | 2007-05-15 03:28:16 +0900 | [diff] [blame] | 371 | /* schedule _GTF */ |
| 372 | for (i = 0; i < ATA_MAX_DEVICES; i++) |
| 373 | ap->device[i].flags |= ATA_DFLAG_ACPI_PENDING; |
| 374 | } |
| 375 | |
| 376 | /** |
| 377 | * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration |
| 378 | * @dev: target ATA device |
| 379 | * |
| 380 | * This function is called when @dev is about to be configured. |
| 381 | * IDENTIFY data might have been modified after this hook is run. |
| 382 | * |
| 383 | * LOCKING: |
| 384 | * EH context. |
| 385 | * |
| 386 | * RETURNS: |
| 387 | * Positive number if IDENTIFY data needs to be refreshed, 0 if not, |
| 388 | * -errno on failure. |
| 389 | */ |
| 390 | int ata_acpi_on_devcfg(struct ata_device *dev) |
| 391 | { |
| 392 | struct ata_port *ap = dev->ap; |
| 393 | struct ata_eh_context *ehc = &ap->eh_context; |
| 394 | int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA; |
| 395 | int rc; |
| 396 | |
| 397 | /* XXX: _STM isn't implemented yet, skip if IDE for now */ |
| 398 | if (!acpi_sata) |
| 399 | return 0; |
| 400 | |
| 401 | if (!dev->acpi_handle) |
| 402 | return 0; |
| 403 | |
| 404 | /* do we need to do _GTF? */ |
| 405 | if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) && |
| 406 | !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET))) |
| 407 | return 0; |
| 408 | |
| 409 | /* do _SDD if SATA */ |
| 410 | if (acpi_sata) { |
| 411 | rc = ata_acpi_push_id(dev); |
| 412 | if (rc) |
| 413 | goto acpi_err; |
| 414 | } |
| 415 | |
| 416 | /* do _GTF */ |
| 417 | rc = ata_acpi_exec_tfs(dev); |
| 418 | if (rc < 0) |
| 419 | goto acpi_err; |
| 420 | |
| 421 | dev->flags &= ~ATA_DFLAG_ACPI_PENDING; |
| 422 | |
| 423 | /* refresh IDENTIFY page if any _GTF command has been executed */ |
| 424 | if (rc > 0) { |
| 425 | rc = ata_dev_reread_id(dev, 0); |
| 426 | if (rc < 0) { |
| 427 | ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY " |
| 428 | "after ACPI commands\n"); |
| 429 | return rc; |
| 430 | } |
| 431 | } |
| 432 | |
| 433 | return 0; |
| 434 | |
| 435 | acpi_err: |
| 436 | /* let EH retry on the first failure, disable ACPI on the second */ |
| 437 | if (dev->flags & ATA_DFLAG_ACPI_FAILED) { |
| 438 | ata_dev_printk(dev, KERN_WARNING, "ACPI on devcfg failed the " |
| 439 | "second time, disabling (errno=%d)\n", rc); |
| 440 | |
| 441 | dev->acpi_handle = NULL; |
| 442 | |
| 443 | /* if port is working, request IDENTIFY reload and continue */ |
| 444 | if (!(ap->pflags & ATA_PFLAG_FROZEN)) |
| 445 | rc = 1; |
| 446 | } |
| 447 | dev->flags |= ATA_DFLAG_ACPI_FAILED; |
| 448 | return rc; |
| 449 | } |