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 |
| 31 | struct taskfile_array { |
| 32 | u8 tfa[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */ |
| 33 | }; |
| 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 | /** |
| 104 | * do_drive_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 |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 106 | * @gtf_length: number of bytes of _GTF data returned at @gtf_address |
| 107 | * @gtf_address: buffer containing _GTF taskfile arrays |
| 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 | * |
| 117 | * The returned @gtf_length and @gtf_address are only valid if the |
| 118 | * function return value is 0. |
| 119 | */ |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 120 | static int do_drive_get_GTF(struct ata_device *dev, unsigned int *gtf_length, |
| 121 | unsigned long *gtf_address, unsigned long *obj_loc) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 122 | { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 123 | struct ata_port *ap = dev->ap; |
| 124 | acpi_status status; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 125 | struct acpi_buffer output; |
| 126 | union acpi_object *out_obj; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 127 | int err = -ENODEV; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 128 | |
| 129 | *gtf_length = 0; |
| 130 | *gtf_address = 0UL; |
| 131 | *obj_loc = 0UL; |
| 132 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame^] | 133 | if (!dev->acpi_handle) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 134 | return 0; |
| 135 | |
| 136 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 137 | ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n", |
Tejun Heo | 878d4fe | 2007-02-21 16:36:33 +0900 | [diff] [blame] | 138 | __FUNCTION__, ap->port_no); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 139 | |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 140 | if (!ata_dev_enabled(dev) || (ap->flags & ATA_FLAG_DISABLED)) { |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 141 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 142 | ata_dev_printk(dev, KERN_DEBUG, "%s: ERR: " |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 143 | "ata_dev_present: %d, PORT_DISABLED: %lu\n", |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 144 | __FUNCTION__, ata_dev_enabled(dev), |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 145 | ap->flags & ATA_FLAG_DISABLED); |
| 146 | goto out; |
| 147 | } |
| 148 | |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 149 | /* Setting up output buffer */ |
| 150 | output.length = ACPI_ALLOCATE_BUFFER; |
| 151 | output.pointer = NULL; /* ACPI-CA sets this; save/free it later */ |
| 152 | |
| 153 | /* _GTF has no input parameters */ |
| 154 | err = -EIO; |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame^] | 155 | status = acpi_evaluate_object(dev->acpi_handle, "_GTF", |
| 156 | NULL, &output); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 157 | if (ACPI_FAILURE(status)) { |
| 158 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 159 | ata_dev_printk(dev, KERN_DEBUG, |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 160 | "%s: Run _GTF error: status = 0x%x\n", |
| 161 | __FUNCTION__, status); |
| 162 | goto out; |
| 163 | } |
| 164 | |
| 165 | if (!output.length || !output.pointer) { |
| 166 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 167 | ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: " |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 168 | "length or ptr is NULL (0x%llx, 0x%p)\n", |
| 169 | __FUNCTION__, |
| 170 | (unsigned long long)output.length, |
| 171 | output.pointer); |
| 172 | kfree(output.pointer); |
| 173 | goto out; |
| 174 | } |
| 175 | |
| 176 | out_obj = output.pointer; |
| 177 | if (out_obj->type != ACPI_TYPE_BUFFER) { |
| 178 | kfree(output.pointer); |
| 179 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 180 | ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: " |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 181 | "error: expected object type of " |
| 182 | " ACPI_TYPE_BUFFER, got 0x%x\n", |
| 183 | __FUNCTION__, out_obj->type); |
| 184 | err = -ENOENT; |
| 185 | goto out; |
| 186 | } |
| 187 | |
| 188 | if (!out_obj->buffer.length || !out_obj->buffer.pointer || |
| 189 | out_obj->buffer.length % REGS_PER_GTF) { |
| 190 | if (ata_msg_drv(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 191 | ata_dev_printk(dev, KERN_ERR, |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 192 | "%s: unexpected GTF length (%d) or addr (0x%p)\n", |
| 193 | __FUNCTION__, out_obj->buffer.length, |
| 194 | out_obj->buffer.pointer); |
| 195 | err = -ENOENT; |
| 196 | goto out; |
| 197 | } |
| 198 | |
| 199 | *gtf_length = out_obj->buffer.length; |
| 200 | *gtf_address = (unsigned long)out_obj->buffer.pointer; |
| 201 | *obj_loc = (unsigned long)out_obj; |
| 202 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 203 | ata_dev_printk(dev, KERN_DEBUG, "%s: returning " |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 204 | "gtf_length=%d, gtf_address=0x%lx, obj_loc=0x%lx\n", |
| 205 | __FUNCTION__, *gtf_length, *gtf_address, *obj_loc); |
| 206 | err = 0; |
| 207 | out: |
| 208 | return err; |
| 209 | } |
| 210 | |
| 211 | /** |
| 212 | * taskfile_load_raw - send taskfile registers to host controller |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 213 | * @dev: target ATA device |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 214 | * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7) |
| 215 | * |
| 216 | * Outputs ATA taskfile to standard ATA host controller using MMIO |
| 217 | * or PIO as indicated by the ATA_FLAG_MMIO flag. |
| 218 | * Writes the control, feature, nsect, lbal, lbam, and lbah registers. |
| 219 | * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect, |
| 220 | * hob_lbal, hob_lbam, and hob_lbah. |
| 221 | * |
| 222 | * This function waits for idle (!BUSY and !DRQ) after writing |
| 223 | * registers. If the control register has a new value, this |
| 224 | * function also waits for idle after writing control and before |
| 225 | * writing the remaining registers. |
| 226 | * |
| 227 | * LOCKING: TBD: |
| 228 | * Inherited from caller. |
| 229 | */ |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 230 | static void taskfile_load_raw(struct ata_device *dev, |
| 231 | const struct taskfile_array *gtf) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 232 | { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 233 | struct ata_port *ap = dev->ap; |
Jeff Garzik | fc16c25 | 2007-02-24 21:05:01 -0500 | [diff] [blame] | 234 | struct ata_taskfile tf; |
| 235 | unsigned int err; |
| 236 | |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 237 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 238 | ata_dev_printk(dev, KERN_DEBUG, "%s: (0x1f1-1f7): hex: " |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 239 | "%02x %02x %02x %02x %02x %02x %02x\n", |
| 240 | __FUNCTION__, |
| 241 | gtf->tfa[0], gtf->tfa[1], gtf->tfa[2], |
| 242 | gtf->tfa[3], gtf->tfa[4], gtf->tfa[5], gtf->tfa[6]); |
| 243 | |
| 244 | if ((gtf->tfa[0] == 0) && (gtf->tfa[1] == 0) && (gtf->tfa[2] == 0) |
| 245 | && (gtf->tfa[3] == 0) && (gtf->tfa[4] == 0) && (gtf->tfa[5] == 0) |
| 246 | && (gtf->tfa[6] == 0)) |
| 247 | return; |
| 248 | |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 249 | ata_tf_init(dev, &tf); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 250 | |
Jeff Garzik | fc16c25 | 2007-02-24 21:05:01 -0500 | [diff] [blame] | 251 | /* convert gtf to tf */ |
| 252 | tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */ |
Tejun Heo | 48be6b1 | 2007-04-23 02:06:46 +0900 | [diff] [blame] | 253 | tf.protocol = ATA_PROT_NODATA; |
Jeff Garzik | fc16c25 | 2007-02-24 21:05:01 -0500 | [diff] [blame] | 254 | tf.feature = gtf->tfa[0]; /* 0x1f1 */ |
| 255 | tf.nsect = gtf->tfa[1]; /* 0x1f2 */ |
| 256 | tf.lbal = gtf->tfa[2]; /* 0x1f3 */ |
| 257 | tf.lbam = gtf->tfa[3]; /* 0x1f4 */ |
| 258 | tf.lbah = gtf->tfa[4]; /* 0x1f5 */ |
| 259 | tf.device = gtf->tfa[5]; /* 0x1f6 */ |
| 260 | tf.command = gtf->tfa[6]; /* 0x1f7 */ |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 261 | |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 262 | err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); |
Jeff Garzik | fc16c25 | 2007-02-24 21:05:01 -0500 | [diff] [blame] | 263 | if (err && ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 264 | ata_dev_printk(dev, KERN_ERR, |
Jeff Garzik | fc16c25 | 2007-02-24 21:05:01 -0500 | [diff] [blame] | 265 | "%s: ata_exec_internal failed: %u\n", |
| 266 | __FUNCTION__, err); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 267 | } |
| 268 | |
| 269 | /** |
| 270 | * do_drive_set_taskfiles - write the drive taskfile settings from _GTF |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 271 | * @dev: target ATA device |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 272 | * @gtf_length: total number of bytes of _GTF taskfiles |
| 273 | * @gtf_address: location of _GTF taskfile arrays |
| 274 | * |
| 275 | * This applies to both PATA and SATA drives. |
| 276 | * |
| 277 | * Write {gtf_address, length gtf_length} in groups of |
| 278 | * REGS_PER_GTF bytes. |
| 279 | */ |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 280 | static int do_drive_set_taskfiles(struct ata_device *dev, |
| 281 | unsigned int gtf_length, |
| 282 | unsigned long gtf_address) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 283 | { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 284 | struct ata_port *ap = dev->ap; |
| 285 | int err = -ENODEV; |
| 286 | int gtf_count = gtf_length / REGS_PER_GTF; |
| 287 | int ix; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 288 | struct taskfile_array *gtf; |
| 289 | |
| 290 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 291 | ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n", |
Tejun Heo | 878d4fe | 2007-02-21 16:36:33 +0900 | [diff] [blame] | 292 | __FUNCTION__, ap->port_no); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 293 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame^] | 294 | if (!(ap->flags & ATA_FLAG_ACPI_SATA)) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 295 | return 0; |
| 296 | |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 297 | if (!ata_dev_enabled(dev) || (ap->flags & ATA_FLAG_DISABLED)) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 298 | goto out; |
| 299 | if (!gtf_count) /* shouldn't be here */ |
| 300 | goto out; |
| 301 | |
| 302 | if (gtf_length % REGS_PER_GTF) { |
| 303 | if (ata_msg_drv(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 304 | ata_dev_printk(dev, KERN_ERR, |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 305 | "%s: unexpected GTF length (%d)\n", |
| 306 | __FUNCTION__, gtf_length); |
| 307 | goto out; |
| 308 | } |
| 309 | |
| 310 | for (ix = 0; ix < gtf_count; ix++) { |
| 311 | gtf = (struct taskfile_array *) |
| 312 | (gtf_address + ix * REGS_PER_GTF); |
| 313 | |
| 314 | /* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */ |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 315 | taskfile_load_raw(dev, gtf); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 316 | } |
| 317 | |
| 318 | err = 0; |
| 319 | out: |
| 320 | return err; |
| 321 | } |
| 322 | |
| 323 | /** |
| 324 | * ata_acpi_exec_tfs - get then write drive taskfile settings |
| 325 | * @ap: the ata_port for the drive |
| 326 | * |
| 327 | * This applies to both PATA and SATA drives. |
| 328 | */ |
| 329 | int ata_acpi_exec_tfs(struct ata_port *ap) |
| 330 | { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 331 | int ix; |
| 332 | int ret = 0; |
| 333 | unsigned int gtf_length; |
| 334 | unsigned long gtf_address; |
| 335 | unsigned long obj_loc; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 336 | |
Kristen Accardi | df33c77 | 2007-03-09 18:15:33 -0500 | [diff] [blame] | 337 | /* |
| 338 | * TBD - implement PATA support. For now, |
| 339 | * we should not run GTF on PATA devices since some |
| 340 | * PATA require execution of GTM/STM before GTF. |
| 341 | */ |
Tejun Heo | 3cadbcc | 2007-05-15 03:28:15 +0900 | [diff] [blame] | 342 | if (!(ap->flags & ATA_FLAG_ACPI_SATA)) |
Kristen Accardi | df33c77 | 2007-03-09 18:15:33 -0500 | [diff] [blame] | 343 | return 0; |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 344 | |
| 345 | for (ix = 0; ix < ATA_MAX_DEVICES; ix++) { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 346 | struct ata_device *dev = &ap->device[ix]; |
| 347 | |
| 348 | if (!ata_dev_enabled(dev)) |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 349 | continue; |
| 350 | |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 351 | ret = do_drive_get_GTF(dev, >f_length, >f_address, |
| 352 | &obj_loc); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 353 | if (ret < 0) { |
| 354 | if (ata_msg_probe(ap)) |
| 355 | ata_port_printk(ap, KERN_DEBUG, |
| 356 | "%s: get_GTF error (%d)\n", |
| 357 | __FUNCTION__, ret); |
| 358 | break; |
| 359 | } |
| 360 | |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 361 | ret = do_drive_set_taskfiles(dev, gtf_length, gtf_address); |
Kristen Carlson Accardi | 11ef697 | 2006-09-28 11:29:01 -0700 | [diff] [blame] | 362 | kfree((void *)obj_loc); |
| 363 | if (ret < 0) { |
| 364 | if (ata_msg_probe(ap)) |
| 365 | ata_port_printk(ap, KERN_DEBUG, |
| 366 | "%s: set_taskfiles error (%d)\n", |
| 367 | __FUNCTION__, ret); |
| 368 | break; |
| 369 | } |
| 370 | } |
| 371 | |
| 372 | return ret; |
| 373 | } |
| 374 | |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 375 | /** |
| 376 | * ata_acpi_push_id - send Identify data to drive |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 377 | * @dev: target ATA device |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 378 | * |
| 379 | * _SDD ACPI object: for SATA mode only |
| 380 | * Must be after Identify (Packet) Device -- uses its data |
| 381 | * ATM this function never returns a failure. It is an optional |
| 382 | * method and if it fails for whatever reason, we should still |
| 383 | * just keep going. |
| 384 | */ |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 385 | int ata_acpi_push_id(struct ata_device *dev) |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 386 | { |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 387 | struct ata_port *ap = dev->ap; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 388 | int err; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 389 | acpi_status status; |
| 390 | struct acpi_object_list input; |
| 391 | union acpi_object in_params[1]; |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 392 | |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame^] | 393 | if (!dev->acpi_handle) |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 394 | return 0; |
| 395 | |
| 396 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 397 | ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n", |
| 398 | __FUNCTION__, dev->devno, ap->port_no); |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 399 | |
| 400 | /* Don't continue if not a SATA device. */ |
Tejun Heo | 3cadbcc | 2007-05-15 03:28:15 +0900 | [diff] [blame] | 401 | if (!(ap->flags & ATA_FLAG_ACPI_SATA)) { |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 402 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 403 | ata_dev_printk(dev, KERN_DEBUG, |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 404 | "%s: Not a SATA device\n", __FUNCTION__); |
| 405 | goto out; |
| 406 | } |
| 407 | |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 408 | /* Give the drive Identify data to the drive via the _SDD method */ |
| 409 | /* _SDD: set up input parameters */ |
| 410 | input.count = 1; |
| 411 | input.pointer = in_params; |
| 412 | in_params[0].type = ACPI_TYPE_BUFFER; |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 413 | in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS; |
| 414 | in_params[0].buffer.pointer = (u8 *)dev->id; |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 415 | /* Output buffer: _SDD has no output */ |
| 416 | |
| 417 | /* It's OK for _SDD to be missing too. */ |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 418 | swap_buf_le16(dev->id, ATA_ID_WORDS); |
Tejun Heo | fafbae8 | 2007-05-15 03:28:16 +0900 | [diff] [blame^] | 419 | status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL); |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 420 | swap_buf_le16(dev->id, ATA_ID_WORDS); |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 421 | |
| 422 | err = ACPI_FAILURE(status) ? -EIO : 0; |
| 423 | if (err < 0) { |
| 424 | if (ata_msg_probe(ap)) |
Tejun Heo | 3a32a8e | 2007-05-05 23:50:38 +0900 | [diff] [blame] | 425 | ata_dev_printk(dev, KERN_DEBUG, |
Tejun Heo | 878d4fe | 2007-02-21 16:36:33 +0900 | [diff] [blame] | 426 | "%s _SDD error: status = 0x%x\n", |
| 427 | __FUNCTION__, status); |
Kristen Carlson Accardi | 7ea1fbc | 2006-09-28 11:29:12 -0700 | [diff] [blame] | 428 | } |
| 429 | |
| 430 | /* always return success */ |
| 431 | out: |
| 432 | return 0; |
| 433 | } |
| 434 | |
| 435 | |