SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/ata/libata-acpi.c

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