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 24unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT; 25module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644); 26MODULE_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 32struct 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 */ 39static int is_pci_dev(struct device *dev) 40{ 41 return (dev->bus == &pci_bus_type); 42} 43 44static 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 */ 63void 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 86static 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() */ 109static 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 */ 142static 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 177static 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 184static 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 191static 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 210static void ata_acpi_ap_uevent(acpi_handle handle, u32 event, void *data) 211{ 212 ata_acpi_uevent(data, NULL, event); 213} 214 215static 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 221static struct acpi_dock_ops ata_acpi_dev_dock_ops = { 222 .handler = ata_acpi_dev_notify_dock, 223 .uevent = ata_acpi_dev_uevent, 224}; 225 226static 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 */ 244void 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 */ 291void 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 */ 320int 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_printk(ap, KERN_ERR, 336 "ACPI get timing mode failed (AE 0x%x)\n", 337 status); 338 goto out_free; 339 } 340 341 out_obj = output.pointer; 342 if (out_obj->type != ACPI_TYPE_BUFFER) { 343 ata_port_printk(ap, KERN_WARNING, 344 "_GTM returned unexpected object type 0x%x\n", 345 out_obj->type); 346 347 goto out_free; 348 } 349 350 if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) { 351 ata_port_printk(ap, KERN_ERR, 352 "_GTM returned invalid length %d\n", 353 out_obj->buffer.length); 354 goto out_free; 355 } 356 357 memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm)); 358 rc = 0; 359 out_free: 360 kfree(output.pointer); 361 return rc; 362} 363 364EXPORT_SYMBOL_GPL(ata_acpi_gtm); 365 366/** 367 * ata_acpi_stm - execute _STM 368 * @ap: target ATA port 369 * @stm: timing parameter to _STM 370 * 371 * Evaluate _STM with timing parameter @stm. 372 * 373 * LOCKING: 374 * EH context. 375 * 376 * RETURNS: 377 * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure. 378 */ 379int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm) 380{ 381 acpi_status status; 382 struct ata_acpi_gtm stm_buf = *stm; 383 struct acpi_object_list input; 384 union acpi_object in_params[3]; 385 386 in_params[0].type = ACPI_TYPE_BUFFER; 387 in_params[0].buffer.length = sizeof(struct ata_acpi_gtm); 388 in_params[0].buffer.pointer = (u8 *)&stm_buf; 389 /* Buffers for id may need byteswapping ? */ 390 in_params[1].type = ACPI_TYPE_BUFFER; 391 in_params[1].buffer.length = 512; 392 in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id; 393 in_params[2].type = ACPI_TYPE_BUFFER; 394 in_params[2].buffer.length = 512; 395 in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id; 396 397 input.count = 3; 398 input.pointer = in_params; 399 400 status = acpi_evaluate_object(ap->acpi_handle, "_STM", &input, NULL); 401 402 if (status == AE_NOT_FOUND) 403 return -ENOENT; 404 if (ACPI_FAILURE(status)) { 405 ata_port_printk(ap, KERN_ERR, 406 "ACPI set timing mode failed (status=0x%x)\n", status); 407 return -EINVAL; 408 } 409 return 0; 410} 411 412EXPORT_SYMBOL_GPL(ata_acpi_stm); 413 414/** 415 * ata_dev_get_GTF - get the drive bootup default taskfile settings 416 * @dev: target ATA device 417 * @gtf: output parameter for buffer containing _GTF taskfile arrays 418 * 419 * This applies to both PATA and SATA drives. 420 * 421 * The _GTF method has no input parameters. 422 * It returns a variable number of register set values (registers 423 * hex 1F1..1F7, taskfiles). 424 * The <variable number> is not known in advance, so have ACPI-CA 425 * allocate the buffer as needed and return it, then free it later. 426 * 427 * LOCKING: 428 * EH context. 429 * 430 * RETURNS: 431 * Number of taskfiles on success, 0 if _GTF doesn't exist. -EINVAL 432 * if _GTF is invalid. 433 */ 434static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf) 435{ 436 struct ata_port *ap = dev->link->ap; 437 acpi_status status; 438 struct acpi_buffer output; 439 union acpi_object *out_obj; 440 int rc = 0; 441 442 /* if _GTF is cached, use the cached value */ 443 if (dev->gtf_cache) { 444 out_obj = dev->gtf_cache; 445 goto done; 446 } 447 448 /* set up output buffer */ 449 output.length = ACPI_ALLOCATE_BUFFER; 450 output.pointer = NULL; /* ACPI-CA sets this; save/free it later */ 451 452 if (ata_msg_probe(ap)) 453 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n", 454 __func__, ap->port_no); 455 456 /* _GTF has no input parameters */ 457 status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output); 458 out_obj = dev->gtf_cache = output.pointer; 459 460 if (ACPI_FAILURE(status)) { 461 if (status != AE_NOT_FOUND) { 462 ata_dev_printk(dev, KERN_WARNING, 463 "_GTF evaluation failed (AE 0x%x)\n", 464 status); 465 rc = -EINVAL; 466 } 467 goto out_free; 468 } 469 470 if (!output.length || !output.pointer) { 471 if (ata_msg_probe(ap)) 472 ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: " 473 "length or ptr is NULL (0x%llx, 0x%p)\n", 474 __func__, 475 (unsigned long long)output.length, 476 output.pointer); 477 rc = -EINVAL; 478 goto out_free; 479 } 480 481 if (out_obj->type != ACPI_TYPE_BUFFER) { 482 ata_dev_printk(dev, KERN_WARNING, 483 "_GTF unexpected object type 0x%x\n", 484 out_obj->type); 485 rc = -EINVAL; 486 goto out_free; 487 } 488 489 if (out_obj->buffer.length % REGS_PER_GTF) { 490 ata_dev_printk(dev, KERN_WARNING, 491 "unexpected _GTF length (%d)\n", 492 out_obj->buffer.length); 493 rc = -EINVAL; 494 goto out_free; 495 } 496 497 done: 498 rc = out_obj->buffer.length / REGS_PER_GTF; 499 if (gtf) { 500 *gtf = (void *)out_obj->buffer.pointer; 501 if (ata_msg_probe(ap)) 502 ata_dev_printk(dev, KERN_DEBUG, 503 "%s: returning gtf=%p, gtf_count=%d\n", 504 __func__, *gtf, rc); 505 } 506 return rc; 507 508 out_free: 509 ata_acpi_clear_gtf(dev); 510 return rc; 511} 512 513/** 514 * ata_acpi_gtm_xfermode - determine xfermode from GTM parameter 515 * @dev: target device 516 * @gtm: GTM parameter to use 517 * 518 * Determine xfermask for @dev from @gtm. 519 * 520 * LOCKING: 521 * None. 522 * 523 * RETURNS: 524 * Determined xfermask. 525 */ 526unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev, 527 const struct ata_acpi_gtm *gtm) 528{ 529 unsigned long xfer_mask = 0; 530 unsigned int type; 531 int unit; 532 u8 mode; 533 534 /* we always use the 0 slot for crap hardware */ 535 unit = dev->devno; 536 if (!(gtm->flags & 0x10)) 537 unit = 0; 538 539 /* PIO */ 540 mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio); 541 xfer_mask |= ata_xfer_mode2mask(mode); 542 543 /* See if we have MWDMA or UDMA data. We don't bother with 544 * MWDMA if UDMA is available as this means the BIOS set UDMA 545 * and our error changedown if it works is UDMA to PIO anyway. 546 */ 547 if (!(gtm->flags & (1 << (2 * unit)))) 548 type = ATA_SHIFT_MWDMA; 549 else 550 type = ATA_SHIFT_UDMA; 551 552 mode = ata_timing_cycle2mode(type, gtm->drive[unit].dma); 553 xfer_mask |= ata_xfer_mode2mask(mode); 554 555 return xfer_mask; 556} 557EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask); 558 559/** 560 * ata_acpi_cbl_80wire - Check for 80 wire cable 561 * @ap: Port to check 562 * @gtm: GTM data to use 563 * 564 * Return 1 if the @gtm indicates the BIOS selected an 80wire mode. 565 */ 566int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm) 567{ 568 struct ata_device *dev; 569 570 ata_for_each_dev(dev, &ap->link, ENABLED) { 571 unsigned long xfer_mask, udma_mask; 572 573 xfer_mask = ata_acpi_gtm_xfermask(dev, gtm); 574 ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask); 575 576 if (udma_mask & ~ATA_UDMA_MASK_40C) 577 return 1; 578 } 579 580 return 0; 581} 582EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire); 583 584static void ata_acpi_gtf_to_tf(struct ata_device *dev, 585 const struct ata_acpi_gtf *gtf, 586 struct ata_taskfile *tf) 587{ 588 ata_tf_init(dev, tf); 589 590 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 591 tf->protocol = ATA_PROT_NODATA; 592 tf->feature = gtf->tf[0]; /* 0x1f1 */ 593 tf->nsect = gtf->tf[1]; /* 0x1f2 */ 594 tf->lbal = gtf->tf[2]; /* 0x1f3 */ 595 tf->lbam = gtf->tf[3]; /* 0x1f4 */ 596 tf->lbah = gtf->tf[4]; /* 0x1f5 */ 597 tf->device = gtf->tf[5]; /* 0x1f6 */ 598 tf->command = gtf->tf[6]; /* 0x1f7 */ 599} 600 601static int ata_acpi_filter_tf(struct ata_device *dev, 602 const struct ata_taskfile *tf, 603 const struct ata_taskfile *ptf) 604{ 605 if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) { 606 /* libata doesn't use ACPI to configure transfer mode. 607 * It will only confuse device configuration. Skip. 608 */ 609 if (tf->command == ATA_CMD_SET_FEATURES && 610 tf->feature == SETFEATURES_XFER) 611 return 1; 612 } 613 614 if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) { 615 /* BIOS writers, sorry but we don't wanna lock 616 * features unless the user explicitly said so. 617 */ 618 619 /* DEVICE CONFIGURATION FREEZE LOCK */ 620 if (tf->command == ATA_CMD_CONF_OVERLAY && 621 tf->feature == ATA_DCO_FREEZE_LOCK) 622 return 1; 623 624 /* SECURITY FREEZE LOCK */ 625 if (tf->command == ATA_CMD_SEC_FREEZE_LOCK) 626 return 1; 627 628 /* SET MAX LOCK and SET MAX FREEZE LOCK */ 629 if ((!ptf || ptf->command != ATA_CMD_READ_NATIVE_MAX) && 630 tf->command == ATA_CMD_SET_MAX && 631 (tf->feature == ATA_SET_MAX_LOCK || 632 tf->feature == ATA_SET_MAX_FREEZE_LOCK)) 633 return 1; 634 } 635 636 if (tf->command == ATA_CMD_SET_FEATURES && 637 tf->feature == SETFEATURES_SATA_ENABLE) { 638 /* inhibit enabling DIPM */ 639 if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM && 640 tf->nsect == SATA_DIPM) 641 return 1; 642 643 /* inhibit FPDMA non-zero offset */ 644 if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET && 645 (tf->nsect == SATA_FPDMA_OFFSET || 646 tf->nsect == SATA_FPDMA_IN_ORDER)) 647 return 1; 648 649 /* inhibit FPDMA auto activation */ 650 if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA && 651 tf->nsect == SATA_FPDMA_AA) 652 return 1; 653 } 654 655 return 0; 656} 657 658/** 659 * ata_acpi_run_tf - send taskfile registers to host controller 660 * @dev: target ATA device 661 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7) 662 * 663 * Outputs ATA taskfile to standard ATA host controller using MMIO 664 * or PIO as indicated by the ATA_FLAG_MMIO flag. 665 * Writes the control, feature, nsect, lbal, lbam, and lbah registers. 666 * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect, 667 * hob_lbal, hob_lbam, and hob_lbah. 668 * 669 * This function waits for idle (!BUSY and !DRQ) after writing 670 * registers. If the control register has a new value, this 671 * function also waits for idle after writing control and before 672 * writing the remaining registers. 673 * 674 * LOCKING: 675 * EH context. 676 * 677 * RETURNS: 678 * 1 if command is executed successfully. 0 if ignored, rejected or 679 * filtered out, -errno on other errors. 680 */ 681static int ata_acpi_run_tf(struct ata_device *dev, 682 const struct ata_acpi_gtf *gtf, 683 const struct ata_acpi_gtf *prev_gtf) 684{ 685 struct ata_taskfile *pptf = NULL; 686 struct ata_taskfile tf, ptf, rtf; 687 unsigned int err_mask; 688 const char *level; 689 const char *descr; 690 char msg[60]; 691 int rc; 692 693 if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0) 694 && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0) 695 && (gtf->tf[6] == 0)) 696 return 0; 697 698 ata_acpi_gtf_to_tf(dev, gtf, &tf); 699 if (prev_gtf) { 700 ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf); 701 pptf = &ptf; 702 } 703 704 if (!ata_acpi_filter_tf(dev, &tf, pptf)) { 705 rtf = tf; 706 err_mask = ata_exec_internal(dev, &rtf, NULL, 707 DMA_NONE, NULL, 0, 0); 708 709 switch (err_mask) { 710 case 0: 711 level = KERN_DEBUG; 712 snprintf(msg, sizeof(msg), "succeeded"); 713 rc = 1; 714 break; 715 716 case AC_ERR_DEV: 717 level = KERN_INFO; 718 snprintf(msg, sizeof(msg), 719 "rejected by device (Stat=0x%02x Err=0x%02x)", 720 rtf.command, rtf.feature); 721 rc = 0; 722 break; 723 724 default: 725 level = KERN_ERR; 726 snprintf(msg, sizeof(msg), 727 "failed (Emask=0x%x Stat=0x%02x Err=0x%02x)", 728 err_mask, rtf.command, rtf.feature); 729 rc = -EIO; 730 break; 731 } 732 } else { 733 level = KERN_INFO; 734 snprintf(msg, sizeof(msg), "filtered out"); 735 rc = 0; 736 } 737 descr = ata_get_cmd_descript(tf.command); 738 739 ata_dev_printk(dev, level, 740 "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n", 741 tf.command, tf.feature, tf.nsect, tf.lbal, 742 tf.lbam, tf.lbah, tf.device, 743 (descr ? descr : "unknown"), msg); 744 745 return rc; 746} 747 748/** 749 * ata_acpi_exec_tfs - get then write drive taskfile settings 750 * @dev: target ATA device 751 * @nr_executed: out parameter for the number of executed commands 752 * 753 * Evaluate _GTF and execute returned taskfiles. 754 * 755 * LOCKING: 756 * EH context. 757 * 758 * RETURNS: 759 * Number of executed taskfiles on success, 0 if _GTF doesn't exist. 760 * -errno on other errors. 761 */ 762static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed) 763{ 764 struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL; 765 int gtf_count, i, rc; 766 767 /* get taskfiles */ 768 rc = ata_dev_get_GTF(dev, >f); 769 if (rc < 0) 770 return rc; 771 gtf_count = rc; 772 773 /* execute them */ 774 for (i = 0; i < gtf_count; i++, gtf++) { 775 rc = ata_acpi_run_tf(dev, gtf, pgtf); 776 if (rc < 0) 777 break; 778 if (rc) { 779 (*nr_executed)++; 780 pgtf = gtf; 781 } 782 } 783 784 ata_acpi_clear_gtf(dev); 785 786 if (rc < 0) 787 return rc; 788 return 0; 789} 790 791/** 792 * ata_acpi_push_id - send Identify data to drive 793 * @dev: target ATA device 794 * 795 * _SDD ACPI object: for SATA mode only 796 * Must be after Identify (Packet) Device -- uses its data 797 * ATM this function never returns a failure. It is an optional 798 * method and if it fails for whatever reason, we should still 799 * just keep going. 800 * 801 * LOCKING: 802 * EH context. 803 * 804 * RETURNS: 805 * 0 on success, -ENOENT if _SDD doesn't exist, -errno on failure. 806 */ 807static int ata_acpi_push_id(struct ata_device *dev) 808{ 809 struct ata_port *ap = dev->link->ap; 810 acpi_status status; 811 struct acpi_object_list input; 812 union acpi_object in_params[1]; 813 814 if (ata_msg_probe(ap)) 815 ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n", 816 __func__, dev->devno, ap->port_no); 817 818 /* Give the drive Identify data to the drive via the _SDD method */ 819 /* _SDD: set up input parameters */ 820 input.count = 1; 821 input.pointer = in_params; 822 in_params[0].type = ACPI_TYPE_BUFFER; 823 in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS; 824 in_params[0].buffer.pointer = (u8 *)dev->id; 825 /* Output buffer: _SDD has no output */ 826 827 /* It's OK for _SDD to be missing too. */ 828 swap_buf_le16(dev->id, ATA_ID_WORDS); 829 status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL); 830 swap_buf_le16(dev->id, ATA_ID_WORDS); 831 832 if (status == AE_NOT_FOUND) 833 return -ENOENT; 834 835 if (ACPI_FAILURE(status)) { 836 ata_dev_printk(dev, KERN_WARNING, 837 "ACPI _SDD failed (AE 0x%x)\n", status); 838 return -EIO; 839 } 840 841 return 0; 842} 843 844/** 845 * ata_acpi_on_suspend - ATA ACPI hook called on suspend 846 * @ap: target ATA port 847 * 848 * This function is called when @ap is about to be suspended. All 849 * devices are already put to sleep but the port_suspend() callback 850 * hasn't been executed yet. Error return from this function aborts 851 * suspend. 852 * 853 * LOCKING: 854 * EH context. 855 * 856 * RETURNS: 857 * 0 on success, -errno on failure. 858 */ 859int ata_acpi_on_suspend(struct ata_port *ap) 860{ 861 /* nada */ 862 return 0; 863} 864 865/** 866 * ata_acpi_on_resume - ATA ACPI hook called on resume 867 * @ap: target ATA port 868 * 869 * This function is called when @ap is resumed - right after port 870 * itself is resumed but before any EH action is taken. 871 * 872 * LOCKING: 873 * EH context. 874 */ 875void ata_acpi_on_resume(struct ata_port *ap) 876{ 877 const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap); 878 struct ata_device *dev; 879 880 if (ap->acpi_handle && gtm) { 881 /* _GTM valid */ 882 883 /* restore timing parameters */ 884 ata_acpi_stm(ap, gtm); 885 886 /* _GTF should immediately follow _STM so that it can 887 * use values set by _STM. Cache _GTF result and 888 * schedule _GTF. 889 */ 890 ata_for_each_dev(dev, &ap->link, ALL) { 891 ata_acpi_clear_gtf(dev); 892 if (ata_dev_enabled(dev) && 893 ata_dev_get_GTF(dev, NULL) >= 0) 894 dev->flags |= ATA_DFLAG_ACPI_PENDING; 895 } 896 } else { 897 /* SATA _GTF needs to be evaulated after _SDD and 898 * there's no reason to evaluate IDE _GTF early 899 * without _STM. Clear cache and schedule _GTF. 900 */ 901 ata_for_each_dev(dev, &ap->link, ALL) { 902 ata_acpi_clear_gtf(dev); 903 if (ata_dev_enabled(dev)) 904 dev->flags |= ATA_DFLAG_ACPI_PENDING; 905 } 906 } 907} 908 909/** 910 * ata_acpi_set_state - set the port power state 911 * @ap: target ATA port 912 * @state: state, on/off 913 * 914 * This function executes the _PS0/_PS3 ACPI method to set the power state. 915 * ACPI spec requires _PS0 when IDE power on and _PS3 when power off 916 */ 917void ata_acpi_set_state(struct ata_port *ap, pm_message_t state) 918{ 919 struct ata_device *dev; 920 921 if (!ap->acpi_handle || (ap->flags & ATA_FLAG_ACPI_SATA)) 922 return; 923 924 /* channel first and then drives for power on and vica versa 925 for power off */ 926 if (state.event == PM_EVENT_ON) 927 acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D0); 928 929 ata_for_each_dev(dev, &ap->link, ENABLED) { 930 if (dev->acpi_handle) 931 acpi_bus_set_power(dev->acpi_handle, 932 state.event == PM_EVENT_ON ? 933 ACPI_STATE_D0 : ACPI_STATE_D3); 934 } 935 if (state.event != PM_EVENT_ON) 936 acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D3); 937} 938 939/** 940 * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration 941 * @dev: target ATA device 942 * 943 * This function is called when @dev is about to be configured. 944 * IDENTIFY data might have been modified after this hook is run. 945 * 946 * LOCKING: 947 * EH context. 948 * 949 * RETURNS: 950 * Positive number if IDENTIFY data needs to be refreshed, 0 if not, 951 * -errno on failure. 952 */ 953int ata_acpi_on_devcfg(struct ata_device *dev) 954{ 955 struct ata_port *ap = dev->link->ap; 956 struct ata_eh_context *ehc = &ap->link.eh_context; 957 int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA; 958 int nr_executed = 0; 959 int rc; 960 961 if (!dev->acpi_handle) 962 return 0; 963 964 /* do we need to do _GTF? */ 965 if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) && 966 !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET))) 967 return 0; 968 969 /* do _SDD if SATA */ 970 if (acpi_sata) { 971 rc = ata_acpi_push_id(dev); 972 if (rc && rc != -ENOENT) 973 goto acpi_err; 974 } 975 976 /* do _GTF */ 977 rc = ata_acpi_exec_tfs(dev, &nr_executed); 978 if (rc) 979 goto acpi_err; 980 981 dev->flags &= ~ATA_DFLAG_ACPI_PENDING; 982 983 /* refresh IDENTIFY page if any _GTF command has been executed */ 984 if (nr_executed) { 985 rc = ata_dev_reread_id(dev, 0); 986 if (rc < 0) { 987 ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY " 988 "after ACPI commands\n"); 989 return rc; 990 } 991 } 992 993 return 0; 994 995 acpi_err: 996 /* ignore evaluation failure if we can continue safely */ 997 if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN)) 998 return 0; 999 1000 /* fail and let EH retry once more for unknown IO errors */ 1001 if (!(dev->flags & ATA_DFLAG_ACPI_FAILED)) { 1002 dev->flags |= ATA_DFLAG_ACPI_FAILED; 1003 return rc; 1004 } 1005 1006 ata_dev_printk(dev, KERN_WARNING, 1007 "ACPI: failed the second time, disabled\n"); 1008 dev->acpi_handle = NULL; 1009 1010 /* We can safely continue if no _GTF command has been executed 1011 * and port is not frozen. 1012 */ 1013 if (!nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN)) 1014 return 0; 1015 1016 return rc; 1017} 1018 1019/** 1020 * ata_acpi_on_disable - ATA ACPI hook called when a device is disabled 1021 * @dev: target ATA device 1022 * 1023 * This function is called when @dev is about to be disabled. 1024 * 1025 * LOCKING: 1026 * EH context. 1027 */ 1028void ata_acpi_on_disable(struct ata_device *dev) 1029{ 1030 ata_acpi_clear_gtf(dev); 1031} 1032