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/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 <linux/slab.h> 19 #include <scsi/scsi_device.h> 20 #include "libata.h" 21 22 #include <acpi/acpi_bus.h> 23 24 unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT; 25 module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644); 26 MODULE_PARM_DESC(acpi_gtf_filter, "filter mask for ACPI _GTF commands, set to filter out (0x1=set xfermode, 0x2=lock/freeze lock, 0x4=DIPM, 0x8=FPDMA non-zero offset, 0x10=FPDMA DMA Setup FIS auto-activate)"); 27 28 #define NO_PORT_MULT 0xffff 29 #define SATA_ADR(root, pmp) (((root) << 16) | (pmp)) 30 31 #define REGS_PER_GTF 7 32 struct ata_acpi_gtf { 33 u8 tf[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */ 34 } __packed; 35 36 /* 37 * Helper - belongs in the PCI layer somewhere eventually 38 */ 39 static int is_pci_dev(struct device *dev) 40 { 41 return (dev->bus == &pci_bus_type); 42 } 43 44 static void ata_acpi_clear_gtf(struct ata_device *dev) 45 { 46 kfree(dev->gtf_cache); 47 dev->gtf_cache = NULL; 48 } 49 50 /** 51 * ata_acpi_associate_sata_port - associate SATA port with ACPI objects 52 * @ap: target SATA port 53 * 54 * Look up ACPI objects associated with @ap and initialize acpi_handle 55 * fields of @ap, the port and devices accordingly. 56 * 57 * LOCKING: 58 * EH context. 59 * 60 * RETURNS: 61 * 0 on success, -errno on failure. 62 */ 63 void ata_acpi_associate_sata_port(struct ata_port *ap) 64 { 65 WARN_ON(!(ap->flags & ATA_FLAG_ACPI_SATA)); 66 67 if (!sata_pmp_attached(ap)) { 68 u64 adr = SATA_ADR(ap->port_no, NO_PORT_MULT); 69 70 ap->link.device->acpi_handle = 71 acpi_get_child(ap->host->acpi_handle, adr); 72 } else { 73 struct ata_link *link; 74 75 ap->link.device->acpi_handle = NULL; 76 77 ata_for_each_link(link, ap, EDGE) { 78 u64 adr = SATA_ADR(ap->port_no, link->pmp); 79 80 link->device->acpi_handle = 81 acpi_get_child(ap->host->acpi_handle, adr); 82 } 83 } 84 } 85 86 static void ata_acpi_associate_ide_port(struct ata_port *ap) 87 { 88 int max_devices, i; 89 90 ap->acpi_handle = acpi_get_child(ap->host->acpi_handle, ap->port_no); 91 if (!ap->acpi_handle) 92 return; 93 94 max_devices = 1; 95 if (ap->flags & ATA_FLAG_SLAVE_POSS) 96 max_devices++; 97 98 for (i = 0; i < max_devices; i++) { 99 struct ata_device *dev = &ap->link.device[i]; 100 101 dev->acpi_handle = acpi_get_child(ap->acpi_handle, i); 102 } 103 104 if (ata_acpi_gtm(ap, &ap->__acpi_init_gtm) == 0) 105 ap->pflags |= ATA_PFLAG_INIT_GTM_VALID; 106 } 107 108 /* @ap and @dev are the same as ata_acpi_handle_hotplug() */ 109 static void ata_acpi_detach_device(struct ata_port *ap, struct ata_device *dev) 110 { 111 if (dev) 112 dev->flags |= ATA_DFLAG_DETACH; 113 else { 114 struct ata_link *tlink; 115 struct ata_device *tdev; 116 117 ata_for_each_link(tlink, ap, EDGE) 118 ata_for_each_dev(tdev, tlink, ALL) 119 tdev->flags |= ATA_DFLAG_DETACH; 120 } 121 122 ata_port_schedule_eh(ap); 123 } 124 125 /** 126 * ata_acpi_handle_hotplug - ACPI event handler backend 127 * @ap: ATA port ACPI event occurred 128 * @dev: ATA device ACPI event occurred (can be NULL) 129 * @event: ACPI event which occurred 130 * 131 * All ACPI bay / device realted events end up in this function. If 132 * the event is port-wide @dev is NULL. If the event is specific to a 133 * device, @dev points to it. 134 * 135 * Hotplug (as opposed to unplug) notification is always handled as 136 * port-wide while unplug only kills the target device on device-wide 137 * event. 138 * 139 * LOCKING: 140 * ACPI notify handler context. May sleep. 141 */ 142 static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev, 143 u32 event) 144 { 145 struct ata_eh_info *ehi = &ap->link.eh_info; 146 int wait = 0; 147 unsigned long flags; 148 149 spin_lock_irqsave(ap->lock, flags); 150 /* 151 * When dock driver calls into the routine, it will always use 152 * ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and 153 * ACPI_NOTIFY_EJECT_REQUEST for remove 154 */ 155 switch (event) { 156 case ACPI_NOTIFY_BUS_CHECK: 157 case ACPI_NOTIFY_DEVICE_CHECK: 158 ata_ehi_push_desc(ehi, "ACPI event"); 159 160 ata_ehi_hotplugged(ehi); 161 ata_port_freeze(ap); 162 break; 163 case ACPI_NOTIFY_EJECT_REQUEST: 164 ata_ehi_push_desc(ehi, "ACPI event"); 165 166 ata_acpi_detach_device(ap, dev); 167 wait = 1; 168 break; 169 } 170 171 spin_unlock_irqrestore(ap->lock, flags); 172 173 if (wait) 174 ata_port_wait_eh(ap); 175 } 176 177 static void ata_acpi_dev_notify_dock(acpi_handle handle, u32 event, void *data) 178 { 179 struct ata_device *dev = data; 180 181 ata_acpi_handle_hotplug(dev->link->ap, dev, event); 182 } 183 184 static void ata_acpi_ap_notify_dock(acpi_handle handle, u32 event, void *data) 185 { 186 struct ata_port *ap = data; 187 188 ata_acpi_handle_hotplug(ap, NULL, event); 189 } 190 191 static void ata_acpi_uevent(struct ata_port *ap, struct ata_device *dev, 192 u32 event) 193 { 194 struct kobject *kobj = NULL; 195 char event_string[20]; 196 char *envp[] = { event_string, NULL }; 197 198 if (dev) { 199 if (dev->sdev) 200 kobj = &dev->sdev->sdev_gendev.kobj; 201 } else 202 kobj = &ap->dev->kobj; 203 204 if (kobj) { 205 snprintf(event_string, 20, "BAY_EVENT=%d", event); 206 kobject_uevent_env(kobj, KOBJ_CHANGE, envp); 207 } 208 } 209 210 static void ata_acpi_ap_uevent(acpi_handle handle, u32 event, void *data) 211 { 212 ata_acpi_uevent(data, NULL, event); 213 } 214 215 static void ata_acpi_dev_uevent(acpi_handle handle, u32 event, void *data) 216 { 217 struct ata_device *dev = data; 218 ata_acpi_uevent(dev->link->ap, dev, event); 219 } 220 221 static const struct acpi_dock_ops ata_acpi_dev_dock_ops = { 222 .handler = ata_acpi_dev_notify_dock, 223 .uevent = ata_acpi_dev_uevent, 224 }; 225 226 static const struct acpi_dock_ops ata_acpi_ap_dock_ops = { 227 .handler = ata_acpi_ap_notify_dock, 228 .uevent = ata_acpi_ap_uevent, 229 }; 230 231 /** 232 * ata_acpi_associate - associate ATA host with ACPI objects 233 * @host: target ATA host 234 * 235 * Look up ACPI objects associated with @host and initialize 236 * acpi_handle fields of @host, its ports and devices accordingly. 237 * 238 * LOCKING: 239 * EH context. 240 * 241 * RETURNS: 242 * 0 on success, -errno on failure. 243 */ 244 void ata_acpi_associate(struct ata_host *host) 245 { 246 int i, j; 247 248 if (!is_pci_dev(host->dev) || libata_noacpi) 249 return; 250 251 host->acpi_handle = DEVICE_ACPI_HANDLE(host->dev); 252 if (!host->acpi_handle) 253 return; 254 255 for (i = 0; i < host->n_ports; i++) { 256 struct ata_port *ap = host->ports[i]; 257 258 if (host->ports[0]->flags & ATA_FLAG_ACPI_SATA) 259 ata_acpi_associate_sata_port(ap); 260 else 261 ata_acpi_associate_ide_port(ap); 262 263 if (ap->acpi_handle) { 264 /* we might be on a docking station */ 265 register_hotplug_dock_device(ap->acpi_handle, 266 &ata_acpi_ap_dock_ops, ap); 267 } 268 269 for (j = 0; j < ata_link_max_devices(&ap->link); j++) { 270 struct ata_device *dev = &ap->link.device[j]; 271 272 if (dev->acpi_handle) { 273 /* we might be on a docking station */ 274 register_hotplug_dock_device(dev->acpi_handle, 275 &ata_acpi_dev_dock_ops, dev); 276 } 277 } 278 } 279 } 280 281 /** 282 * ata_acpi_dissociate - dissociate ATA host from ACPI objects 283 * @host: target ATA host 284 * 285 * This function is called during driver detach after the whole host 286 * is shut down. 287 * 288 * LOCKING: 289 * EH context. 290 */ 291 void ata_acpi_dissociate(struct ata_host *host) 292 { 293 int i; 294 295 /* Restore initial _GTM values so that driver which attaches 296 * afterward can use them too. 297 */ 298 for (i = 0; i < host->n_ports; i++) { 299 struct ata_port *ap = host->ports[i]; 300 const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap); 301 302 if (ap->acpi_handle && gtm) 303 ata_acpi_stm(ap, gtm); 304 } 305 } 306 307 /** 308 * ata_acpi_gtm - execute _GTM 309 * @ap: target ATA port 310 * @gtm: out parameter for _GTM result 311 * 312 * Evaluate _GTM and store the result in @gtm. 313 * 314 * LOCKING: 315 * EH context. 316 * 317 * RETURNS: 318 * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure. 319 */ 320 int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *gtm) 321 { 322 struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER }; 323 union acpi_object *out_obj; 324 acpi_status status; 325 int rc = 0; 326 327 status = acpi_evaluate_object(ap->acpi_handle, "_GTM", NULL, &output); 328 329 rc = -ENOENT; 330 if (status == AE_NOT_FOUND) 331 goto out_free; 332 333 rc = -EINVAL; 334 if (ACPI_FAILURE(status)) { 335 ata_port_err(ap, "ACPI get timing mode failed (AE 0x%x)\n", 336 status); 337 goto out_free; 338 } 339 340 out_obj = output.pointer; 341 if (out_obj->type != ACPI_TYPE_BUFFER) { 342 ata_port_warn(ap, "_GTM returned unexpected object type 0x%x\n", 343 out_obj->type); 344 345 goto out_free; 346 } 347 348 if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) { 349 ata_port_err(ap, "_GTM returned invalid length %d\n", 350 out_obj->buffer.length); 351 goto out_free; 352 } 353 354 memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm)); 355 rc = 0; 356 out_free: 357 kfree(output.pointer); 358 return rc; 359 } 360 361 EXPORT_SYMBOL_GPL(ata_acpi_gtm); 362 363 /** 364 * ata_acpi_stm - execute _STM 365 * @ap: target ATA port 366 * @stm: timing parameter to _STM 367 * 368 * Evaluate _STM with timing parameter @stm. 369 * 370 * LOCKING: 371 * EH context. 372 * 373 * RETURNS: 374 * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure. 375 */ 376 int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm) 377 { 378 acpi_status status; 379 struct ata_acpi_gtm stm_buf = *stm; 380 struct acpi_object_list input; 381 union acpi_object in_params[3]; 382 383 in_params[0].type = ACPI_TYPE_BUFFER; 384 in_params[0].buffer.length = sizeof(struct ata_acpi_gtm); 385 in_params[0].buffer.pointer = (u8 *)&stm_buf; 386 /* Buffers for id may need byteswapping ? */ 387 in_params[1].type = ACPI_TYPE_BUFFER; 388 in_params[1].buffer.length = 512; 389 in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id; 390 in_params[2].type = ACPI_TYPE_BUFFER; 391 in_params[2].buffer.length = 512; 392 in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id; 393 394 input.count = 3; 395 input.pointer = in_params; 396 397 status = acpi_evaluate_object(ap->acpi_handle, "_STM", &input, NULL); 398 399 if (status == AE_NOT_FOUND) 400 return -ENOENT; 401 if (ACPI_FAILURE(status)) { 402 ata_port_err(ap, "ACPI set timing mode failed (status=0x%x)\n", 403 status); 404 return -EINVAL; 405 } 406 return 0; 407 } 408 409 EXPORT_SYMBOL_GPL(ata_acpi_stm); 410 411 /** 412 * ata_dev_get_GTF - get the drive bootup default taskfile settings 413 * @dev: target ATA device 414 * @gtf: output parameter for buffer containing _GTF taskfile arrays 415 * 416 * This applies to both PATA and SATA drives. 417 * 418 * The _GTF method has no input parameters. 419 * It returns a variable number of register set values (registers 420 * hex 1F1..1F7, taskfiles). 421 * The <variable number> is not known in advance, so have ACPI-CA 422 * allocate the buffer as needed and return it, then free it later. 423 * 424 * LOCKING: 425 * EH context. 426 * 427 * RETURNS: 428 * Number of taskfiles on success, 0 if _GTF doesn't exist. -EINVAL 429 * if _GTF is invalid. 430 */ 431 static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf) 432 { 433 struct ata_port *ap = dev->link->ap; 434 acpi_status status; 435 struct acpi_buffer output; 436 union acpi_object *out_obj; 437 int rc = 0; 438 439 /* if _GTF is cached, use the cached value */ 440 if (dev->gtf_cache) { 441 out_obj = dev->gtf_cache; 442 goto done; 443 } 444 445 /* set up output buffer */ 446 output.length = ACPI_ALLOCATE_BUFFER; 447 output.pointer = NULL; /* ACPI-CA sets this; save/free it later */ 448 449 if (ata_msg_probe(ap)) 450 ata_dev_dbg(dev, "%s: ENTER: port#: %d\n", 451 __func__, ap->port_no); 452 453 /* _GTF has no input parameters */ 454 status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output); 455 out_obj = dev->gtf_cache = output.pointer; 456 457 if (ACPI_FAILURE(status)) { 458 if (status != AE_NOT_FOUND) { 459 ata_dev_warn(dev, "_GTF evaluation failed (AE 0x%x)\n", 460 status); 461 rc = -EINVAL; 462 } 463 goto out_free; 464 } 465 466 if (!output.length || !output.pointer) { 467 if (ata_msg_probe(ap)) 468 ata_dev_dbg(dev, "%s: Run _GTF: length or ptr is NULL (0x%llx, 0x%p)\n", 469 __func__, 470 (unsigned long long)output.length, 471 output.pointer); 472 rc = -EINVAL; 473 goto out_free; 474 } 475 476 if (out_obj->type != ACPI_TYPE_BUFFER) { 477 ata_dev_warn(dev, "_GTF unexpected object type 0x%x\n", 478 out_obj->type); 479 rc = -EINVAL; 480 goto out_free; 481 } 482 483 if (out_obj->buffer.length % REGS_PER_GTF) { 484 ata_dev_warn(dev, "unexpected _GTF length (%d)\n", 485 out_obj->buffer.length); 486 rc = -EINVAL; 487 goto out_free; 488 } 489 490 done: 491 rc = out_obj->buffer.length / REGS_PER_GTF; 492 if (gtf) { 493 *gtf = (void *)out_obj->buffer.pointer; 494 if (ata_msg_probe(ap)) 495 ata_dev_dbg(dev, "%s: returning gtf=%p, gtf_count=%d\n", 496 __func__, *gtf, rc); 497 } 498 return rc; 499 500 out_free: 501 ata_acpi_clear_gtf(dev); 502 return rc; 503 } 504 505 /** 506 * ata_acpi_gtm_xfermode - determine xfermode from GTM parameter 507 * @dev: target device 508 * @gtm: GTM parameter to use 509 * 510 * Determine xfermask for @dev from @gtm. 511 * 512 * LOCKING: 513 * None. 514 * 515 * RETURNS: 516 * Determined xfermask. 517 */ 518 unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev, 519 const struct ata_acpi_gtm *gtm) 520 { 521 unsigned long xfer_mask = 0; 522 unsigned int type; 523 int unit; 524 u8 mode; 525 526 /* we always use the 0 slot for crap hardware */ 527 unit = dev->devno; 528 if (!(gtm->flags & 0x10)) 529 unit = 0; 530 531 /* PIO */ 532 mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio); 533 xfer_mask |= ata_xfer_mode2mask(mode); 534 535 /* See if we have MWDMA or UDMA data. We don't bother with 536 * MWDMA if UDMA is available as this means the BIOS set UDMA 537 * and our error changedown if it works is UDMA to PIO anyway. 538 */ 539 if (!(gtm->flags & (1 << (2 * unit)))) 540 type = ATA_SHIFT_MWDMA; 541 else 542 type = ATA_SHIFT_UDMA; 543 544 mode = ata_timing_cycle2mode(type, gtm->drive[unit].dma); 545 xfer_mask |= ata_xfer_mode2mask(mode); 546 547 return xfer_mask; 548 } 549 EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask); 550 551 /** 552 * ata_acpi_cbl_80wire - Check for 80 wire cable 553 * @ap: Port to check 554 * @gtm: GTM data to use 555 * 556 * Return 1 if the @gtm indicates the BIOS selected an 80wire mode. 557 */ 558 int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm) 559 { 560 struct ata_device *dev; 561 562 ata_for_each_dev(dev, &ap->link, ENABLED) { 563 unsigned long xfer_mask, udma_mask; 564 565 xfer_mask = ata_acpi_gtm_xfermask(dev, gtm); 566 ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask); 567 568 if (udma_mask & ~ATA_UDMA_MASK_40C) 569 return 1; 570 } 571 572 return 0; 573 } 574 EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire); 575 576 static void ata_acpi_gtf_to_tf(struct ata_device *dev, 577 const struct ata_acpi_gtf *gtf, 578 struct ata_taskfile *tf) 579 { 580 ata_tf_init(dev, tf); 581 582 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 583 tf->protocol = ATA_PROT_NODATA; 584 tf->feature = gtf->tf[0]; /* 0x1f1 */ 585 tf->nsect = gtf->tf[1]; /* 0x1f2 */ 586 tf->lbal = gtf->tf[2]; /* 0x1f3 */ 587 tf->lbam = gtf->tf[3]; /* 0x1f4 */ 588 tf->lbah = gtf->tf[4]; /* 0x1f5 */ 589 tf->device = gtf->tf[5]; /* 0x1f6 */ 590 tf->command = gtf->tf[6]; /* 0x1f7 */ 591 } 592 593 static int ata_acpi_filter_tf(struct ata_device *dev, 594 const struct ata_taskfile *tf, 595 const struct ata_taskfile *ptf) 596 { 597 if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) { 598 /* libata doesn't use ACPI to configure transfer mode. 599 * It will only confuse device configuration. Skip. 600 */ 601 if (tf->command == ATA_CMD_SET_FEATURES && 602 tf->feature == SETFEATURES_XFER) 603 return 1; 604 } 605 606 if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) { 607 /* BIOS writers, sorry but we don't wanna lock 608 * features unless the user explicitly said so. 609 */ 610 611 /* DEVICE CONFIGURATION FREEZE LOCK */ 612 if (tf->command == ATA_CMD_CONF_OVERLAY && 613 tf->feature == ATA_DCO_FREEZE_LOCK) 614 return 1; 615 616 /* SECURITY FREEZE LOCK */ 617 if (tf->command == ATA_CMD_SEC_FREEZE_LOCK) 618 return 1; 619 620 /* SET MAX LOCK and SET MAX FREEZE LOCK */ 621 if ((!ptf || ptf->command != ATA_CMD_READ_NATIVE_MAX) && 622 tf->command == ATA_CMD_SET_MAX && 623 (tf->feature == ATA_SET_MAX_LOCK || 624 tf->feature == ATA_SET_MAX_FREEZE_LOCK)) 625 return 1; 626 } 627 628 if (tf->command == ATA_CMD_SET_FEATURES && 629 tf->feature == SETFEATURES_SATA_ENABLE) { 630 /* inhibit enabling DIPM */ 631 if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM && 632 tf->nsect == SATA_DIPM) 633 return 1; 634 635 /* inhibit FPDMA non-zero offset */ 636 if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET && 637 (tf->nsect == SATA_FPDMA_OFFSET || 638 tf->nsect == SATA_FPDMA_IN_ORDER)) 639 return 1; 640 641 /* inhibit FPDMA auto activation */ 642 if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA && 643 tf->nsect == SATA_FPDMA_AA) 644 return 1; 645 } 646 647 return 0; 648 } 649 650 /** 651 * ata_acpi_run_tf - send taskfile registers to host controller 652 * @dev: target ATA device 653 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7) 654 * 655 * Outputs ATA taskfile to standard ATA host controller. 656 * Writes the control, feature, nsect, lbal, lbam, and lbah registers. 657 * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect, 658 * hob_lbal, hob_lbam, and hob_lbah. 659 * 660 * This function waits for idle (!BUSY and !DRQ) after writing 661 * registers. If the control register has a new value, this 662 * function also waits for idle after writing control and before 663 * writing the remaining registers. 664 * 665 * LOCKING: 666 * EH context. 667 * 668 * RETURNS: 669 * 1 if command is executed successfully. 0 if ignored, rejected or 670 * filtered out, -errno on other errors. 671 */ 672 static int ata_acpi_run_tf(struct ata_device *dev, 673 const struct ata_acpi_gtf *gtf, 674 const struct ata_acpi_gtf *prev_gtf) 675 { 676 struct ata_taskfile *pptf = NULL; 677 struct ata_taskfile tf, ptf, rtf; 678 unsigned int err_mask; 679 const char *level; 680 const char *descr; 681 char msg[60]; 682 int rc; 683 684 if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0) 685 && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0) 686 && (gtf->tf[6] == 0)) 687 return 0; 688 689 ata_acpi_gtf_to_tf(dev, gtf, &tf); 690 if (prev_gtf) { 691 ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf); 692 pptf = &ptf; 693 } 694 695 if (!ata_acpi_filter_tf(dev, &tf, pptf)) { 696 rtf = tf; 697 err_mask = ata_exec_internal(dev, &rtf, NULL, 698 DMA_NONE, NULL, 0, 0); 699 700 switch (err_mask) { 701 case 0: 702 level = KERN_DEBUG; 703 snprintf(msg, sizeof(msg), "succeeded"); 704 rc = 1; 705 break; 706 707 case AC_ERR_DEV: 708 level = KERN_INFO; 709 snprintf(msg, sizeof(msg), 710 "rejected by device (Stat=0x%02x Err=0x%02x)", 711 rtf.command, rtf.feature); 712 rc = 0; 713 break; 714 715 default: 716 level = KERN_ERR; 717 snprintf(msg, sizeof(msg), 718 "failed (Emask=0x%x Stat=0x%02x Err=0x%02x)", 719 err_mask, rtf.command, rtf.feature); 720 rc = -EIO; 721 break; 722 } 723 } else { 724 level = KERN_INFO; 725 snprintf(msg, sizeof(msg), "filtered out"); 726 rc = 0; 727 } 728 descr = ata_get_cmd_descript(tf.command); 729 730 ata_dev_printk(dev, level, 731 "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n", 732 tf.command, tf.feature, tf.nsect, tf.lbal, 733 tf.lbam, tf.lbah, tf.device, 734 (descr ? descr : "unknown"), msg); 735 736 return rc; 737 } 738 739 /** 740 * ata_acpi_exec_tfs - get then write drive taskfile settings 741 * @dev: target ATA device 742 * @nr_executed: out parameter for the number of executed commands 743 * 744 * Evaluate _GTF and execute returned taskfiles. 745 * 746 * LOCKING: 747 * EH context. 748 * 749 * RETURNS: 750 * Number of executed taskfiles on success, 0 if _GTF doesn't exist. 751 * -errno on other errors. 752 */ 753 static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed) 754 { 755 struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL; 756 int gtf_count, i, rc; 757 758 /* get taskfiles */ 759 rc = ata_dev_get_GTF(dev, >f); 760 if (rc < 0) 761 return rc; 762 gtf_count = rc; 763 764 /* execute them */ 765 for (i = 0; i < gtf_count; i++, gtf++) { 766 rc = ata_acpi_run_tf(dev, gtf, pgtf); 767 if (rc < 0) 768 break; 769 if (rc) { 770 (*nr_executed)++; 771 pgtf = gtf; 772 } 773 } 774 775 ata_acpi_clear_gtf(dev); 776 777 if (rc < 0) 778 return rc; 779 return 0; 780 } 781 782 /** 783 * ata_acpi_push_id - send Identify data to drive 784 * @dev: target ATA device 785 * 786 * _SDD ACPI object: for SATA mode only 787 * Must be after Identify (Packet) Device -- uses its data 788 * ATM this function never returns a failure. It is an optional 789 * method and if it fails for whatever reason, we should still 790 * just keep going. 791 * 792 * LOCKING: 793 * EH context. 794 * 795 * RETURNS: 796 * 0 on success, -ENOENT if _SDD doesn't exist, -errno on failure. 797 */ 798 static int ata_acpi_push_id(struct ata_device *dev) 799 { 800 struct ata_port *ap = dev->link->ap; 801 acpi_status status; 802 struct acpi_object_list input; 803 union acpi_object in_params[1]; 804 805 if (ata_msg_probe(ap)) 806 ata_dev_dbg(dev, "%s: ix = %d, port#: %d\n", 807 __func__, dev->devno, ap->port_no); 808 809 /* Give the drive Identify data to the drive via the _SDD method */ 810 /* _SDD: set up input parameters */ 811 input.count = 1; 812 input.pointer = in_params; 813 in_params[0].type = ACPI_TYPE_BUFFER; 814 in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS; 815 in_params[0].buffer.pointer = (u8 *)dev->id; 816 /* Output buffer: _SDD has no output */ 817 818 /* It's OK for _SDD to be missing too. */ 819 swap_buf_le16(dev->id, ATA_ID_WORDS); 820 status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL); 821 swap_buf_le16(dev->id, ATA_ID_WORDS); 822 823 if (status == AE_NOT_FOUND) 824 return -ENOENT; 825 826 if (ACPI_FAILURE(status)) { 827 ata_dev_warn(dev, "ACPI _SDD failed (AE 0x%x)\n", status); 828 return -EIO; 829 } 830 831 return 0; 832 } 833 834 /** 835 * ata_acpi_on_suspend - ATA ACPI hook called on suspend 836 * @ap: target ATA port 837 * 838 * This function is called when @ap is about to be suspended. All 839 * devices are already put to sleep but the port_suspend() callback 840 * hasn't been executed yet. Error return from this function aborts 841 * suspend. 842 * 843 * LOCKING: 844 * EH context. 845 * 846 * RETURNS: 847 * 0 on success, -errno on failure. 848 */ 849 int ata_acpi_on_suspend(struct ata_port *ap) 850 { 851 /* nada */ 852 return 0; 853 } 854 855 /** 856 * ata_acpi_on_resume - ATA ACPI hook called on resume 857 * @ap: target ATA port 858 * 859 * This function is called when @ap is resumed - right after port 860 * itself is resumed but before any EH action is taken. 861 * 862 * LOCKING: 863 * EH context. 864 */ 865 void ata_acpi_on_resume(struct ata_port *ap) 866 { 867 const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap); 868 struct ata_device *dev; 869 870 if (ap->acpi_handle && gtm) { 871 /* _GTM valid */ 872 873 /* restore timing parameters */ 874 ata_acpi_stm(ap, gtm); 875 876 /* _GTF should immediately follow _STM so that it can 877 * use values set by _STM. Cache _GTF result and 878 * schedule _GTF. 879 */ 880 ata_for_each_dev(dev, &ap->link, ALL) { 881 ata_acpi_clear_gtf(dev); 882 if (ata_dev_enabled(dev) && 883 ata_dev_get_GTF(dev, NULL) >= 0) 884 dev->flags |= ATA_DFLAG_ACPI_PENDING; 885 } 886 } else { 887 /* SATA _GTF needs to be evaulated after _SDD and 888 * there's no reason to evaluate IDE _GTF early 889 * without _STM. Clear cache and schedule _GTF. 890 */ 891 ata_for_each_dev(dev, &ap->link, ALL) { 892 ata_acpi_clear_gtf(dev); 893 if (ata_dev_enabled(dev)) 894 dev->flags |= ATA_DFLAG_ACPI_PENDING; 895 } 896 } 897 } 898 899 /** 900 * ata_acpi_set_state - set the port power state 901 * @ap: target ATA port 902 * @state: state, on/off 903 * 904 * This function executes the _PS0/_PS3 ACPI method to set the power state. 905 * ACPI spec requires _PS0 when IDE power on and _PS3 when power off 906 */ 907 void ata_acpi_set_state(struct ata_port *ap, pm_message_t state) 908 { 909 struct ata_device *dev; 910 911 if (!ap->acpi_handle || (ap->flags & ATA_FLAG_ACPI_SATA)) 912 return; 913 914 /* channel first and then drives for power on and vica versa 915 for power off */ 916 if (state.event == PM_EVENT_ON) 917 acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D0); 918 919 ata_for_each_dev(dev, &ap->link, ENABLED) { 920 if (dev->acpi_handle) 921 acpi_bus_set_power(dev->acpi_handle, 922 state.event == PM_EVENT_ON ? 923 ACPI_STATE_D0 : ACPI_STATE_D3); 924 } 925 if (state.event != PM_EVENT_ON) 926 acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D3); 927 } 928 929 /** 930 * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration 931 * @dev: target ATA device 932 * 933 * This function is called when @dev is about to be configured. 934 * IDENTIFY data might have been modified after this hook is run. 935 * 936 * LOCKING: 937 * EH context. 938 * 939 * RETURNS: 940 * Positive number if IDENTIFY data needs to be refreshed, 0 if not, 941 * -errno on failure. 942 */ 943 int ata_acpi_on_devcfg(struct ata_device *dev) 944 { 945 struct ata_port *ap = dev->link->ap; 946 struct ata_eh_context *ehc = &ap->link.eh_context; 947 int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA; 948 int nr_executed = 0; 949 int rc; 950 951 if (!dev->acpi_handle) 952 return 0; 953 954 /* do we need to do _GTF? */ 955 if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) && 956 !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET))) 957 return 0; 958 959 /* do _SDD if SATA */ 960 if (acpi_sata) { 961 rc = ata_acpi_push_id(dev); 962 if (rc && rc != -ENOENT) 963 goto acpi_err; 964 } 965 966 /* do _GTF */ 967 rc = ata_acpi_exec_tfs(dev, &nr_executed); 968 if (rc) 969 goto acpi_err; 970 971 dev->flags &= ~ATA_DFLAG_ACPI_PENDING; 972 973 /* refresh IDENTIFY page if any _GTF command has been executed */ 974 if (nr_executed) { 975 rc = ata_dev_reread_id(dev, 0); 976 if (rc < 0) { 977 ata_dev_err(dev, 978 "failed to IDENTIFY after ACPI commands\n"); 979 return rc; 980 } 981 } 982 983 return 0; 984 985 acpi_err: 986 /* ignore evaluation failure if we can continue safely */ 987 if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN)) 988 return 0; 989 990 /* fail and let EH retry once more for unknown IO errors */ 991 if (!(dev->flags & ATA_DFLAG_ACPI_FAILED)) { 992 dev->flags |= ATA_DFLAG_ACPI_FAILED; 993 return rc; 994 } 995 996 ata_dev_warn(dev, "ACPI: failed the second time, disabled\n"); 997 dev->acpi_handle = NULL; 998 999 /* We can safely continue if no _GTF command has been executed 1000 * and port is not frozen. 1001 */ 1002 if (!nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN)) 1003 return 0; 1004 1005 return rc; 1006 } 1007 1008 /** 1009 * ata_acpi_on_disable - ATA ACPI hook called when a device is disabled 1010 * @dev: target ATA device 1011 * 1012 * This function is called when @dev is about to be disabled. 1013 * 1014 * LOCKING: 1015 * EH context. 1016 */ 1017 void ata_acpi_on_disable(struct ata_device *dev) 1018 { 1019 ata_acpi_clear_gtf(dev); 1020 } 1021