git.oblomov.eu Git - 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/ata.h>
  10 #include <linux/delay.h>
  11 #include <linux/device.h>
  12 #include <linux/errno.h>
  13 #include <linux/kernel.h>
  14 #include <linux/acpi.h>
  15 #include <linux/libata.h>
  16 #include <linux/pci.h>
  17 #include <scsi/scsi_device.h>
  18 #include "libata.h"
  19
  20 #include <acpi/acpi_bus.h>
  21 #include <acpi/acnames.h>
  22 #include <acpi/acnamesp.h>
  23 #include <acpi/acparser.h>
  24 #include <acpi/acexcep.h>
  25 #include <acpi/acmacros.h>
  26 #include <acpi/actypes.h>
  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 /**
  45  * ata_acpi_associate_sata_port - associate SATA port with ACPI objects
  46  * @ap: target SATA port
  47  *
  48  * Look up ACPI objects associated with @ap and initialize acpi_handle
  49  * fields of @ap, the port and devices accordingly.
  50  *
  51  * LOCKING:
  52  * EH context.
  53  *
  54  * RETURNS:
  55  * 0 on success, -errno on failure.
  56  */
  57 void ata_acpi_associate_sata_port(struct ata_port *ap)
  58 {
  59         WARN_ON(!(ap->flags & ATA_FLAG_ACPI_SATA));
  60
  61         if (!ap->nr_pmp_links) {
  62                 acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
  63
  64                 ap->link.device->acpi_handle =
  65                         acpi_get_child(ap->host->acpi_handle, adr);
  66         } else {
  67                 struct ata_link *link;
  68
  69                 ap->link.device->acpi_handle = NULL;
  70
  71                 ata_port_for_each_link(link, ap) {
  72                         acpi_integer adr = SATA_ADR(ap->port_no, link->pmp);
  73
  74                         link->device->acpi_handle =
  75                                 acpi_get_child(ap->host->acpi_handle, adr);
  76                 }
  77         }
  78 }
  79
  80 static void ata_acpi_associate_ide_port(struct ata_port *ap)
  81 {
  82         int max_devices, i;
  83
  84         ap->acpi_handle = acpi_get_child(ap->host->acpi_handle, ap->port_no);
  85         if (!ap->acpi_handle)
  86                 return;
  87
  88         max_devices = 1;
  89         if (ap->flags & ATA_FLAG_SLAVE_POSS)
  90                 max_devices++;
  91
  92         for (i = 0; i < max_devices; i++) {
  93                 struct ata_device *dev = &ap->link.device[i];
  94
  95                 dev->acpi_handle = acpi_get_child(ap->acpi_handle, i);
  96         }
  97 }
  98
  99 static void ata_acpi_handle_hotplug (struct ata_port *ap, struct kobject *kobj,
 100                                      u32 event)
 101 {
 102         char event_string[12];
 103         char *envp[] = { event_string, NULL };
 104         struct ata_eh_info *ehi = &ap->link.eh_info;
 105
 106         if (event == 0 || event == 1) {
 107                unsigned long flags;
 108                spin_lock_irqsave(ap->lock, flags);
 109                ata_ehi_clear_desc(ehi);
 110                ata_ehi_push_desc(ehi, "ACPI event");
 111                ata_ehi_hotplugged(ehi);
 112                ata_port_freeze(ap);
 113                spin_unlock_irqrestore(ap->lock, flags);
 114         }
 115
 116         if (kobj) {
 117                 sprintf(event_string, "BAY_EVENT=%d", event);
 118                 kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
 119         }
 120 }
 121
 122 static void ata_acpi_dev_notify(acpi_handle handle, u32 event, void *data)
 123 {
 124         struct ata_device *dev = data;
 125         struct kobject *kobj = NULL;
 126
 127         if (dev->sdev)
 128                 kobj = &dev->sdev->sdev_gendev.kobj;
 129
 130         ata_acpi_handle_hotplug (dev->link->ap, kobj, event);
 131 }
 132
 133 static void ata_acpi_ap_notify(acpi_handle handle, u32 event, void *data)
 134 {
 135         struct ata_port *ap = data;
 136
 137         ata_acpi_handle_hotplug (ap, &ap->dev->kobj, event);
 138 }
 139
 140 /**
 141  * ata_acpi_associate - associate ATA host with ACPI objects
 142  * @host: target ATA host
 143  *
 144  * Look up ACPI objects associated with @host and initialize
 145  * acpi_handle fields of @host, its ports and devices accordingly.
 146  *
 147  * LOCKING:
 148  * EH context.
 149  *
 150  * RETURNS:
 151  * 0 on success, -errno on failure.
 152  */
 153 void ata_acpi_associate(struct ata_host *host)
 154 {
 155         int i, j;
 156
 157         if (!is_pci_dev(host->dev) || libata_noacpi)
 158                 return;
 159
 160         host->acpi_handle = DEVICE_ACPI_HANDLE(host->dev);
 161         if (!host->acpi_handle)
 162                 return;
 163
 164         for (i = 0; i < host->n_ports; i++) {
 165                 struct ata_port *ap = host->ports[i];
 166
 167                 if (host->ports[0]->flags & ATA_FLAG_ACPI_SATA)
 168                         ata_acpi_associate_sata_port(ap);
 169                 else
 170                         ata_acpi_associate_ide_port(ap);
 171
 172                 if (ap->acpi_handle)
 173                         acpi_install_notify_handler (ap->acpi_handle,
 174                                                      ACPI_SYSTEM_NOTIFY,
 175                                                      ata_acpi_ap_notify,
 176                                                      ap);
 177
 178                 for (j = 0; j < ata_link_max_devices(&ap->link); j++) {
 179                         struct ata_device *dev = &ap->link.device[j];
 180
 181                         if (dev->acpi_handle)
 182                                 acpi_install_notify_handler (dev->acpi_handle,
 183                                                              ACPI_SYSTEM_NOTIFY,
 184                                                              ata_acpi_dev_notify,
 185                                                              dev);
 186                 }
 187         }
 188 }
 189
 190 /**
 191  * ata_acpi_gtm - execute _GTM
 192  * @ap: target ATA port
 193  * @gtm: out parameter for _GTM result
 194  *
 195  * Evaluate _GTM and store the result in @gtm.
 196  *
 197  * LOCKING:
 198  * EH context.
 199  *
 200  * RETURNS:
 201  * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
 202  */
 203 int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
 204 {
 205         struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
 206         union acpi_object *out_obj;
 207         acpi_status status;
 208         int rc = 0;
 209
 210         status = acpi_evaluate_object(ap->acpi_handle, "_GTM", NULL, &output);
 211
 212         rc = -ENOENT;
 213         if (status == AE_NOT_FOUND)
 214                 goto out_free;
 215
 216         rc = -EINVAL;
 217         if (ACPI_FAILURE(status)) {
 218                 ata_port_printk(ap, KERN_ERR,
 219                                 "ACPI get timing mode failed (AE 0x%x)\n",
 220                                 status);
 221                 goto out_free;
 222         }
 223
 224         out_obj = output.pointer;
 225         if (out_obj->type != ACPI_TYPE_BUFFER) {
 226                 ata_port_printk(ap, KERN_WARNING,
 227                                 "_GTM returned unexpected object type 0x%x\n",
 228                                 out_obj->type);
 229
 230                 goto out_free;
 231         }
 232
 233         if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) {
 234                 ata_port_printk(ap, KERN_ERR,
 235                                 "_GTM returned invalid length %d\n",
 236                                 out_obj->buffer.length);
 237                 goto out_free;
 238         }
 239
 240         memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm));
 241         rc = 0;
 242  out_free:
 243         kfree(output.pointer);
 244         return rc;
 245 }
 246
 247 EXPORT_SYMBOL_GPL(ata_acpi_gtm);
 248
 249 /**
 250  * ata_acpi_stm - execute _STM
 251  * @ap: target ATA port
 252  * @stm: timing parameter to _STM
 253  *
 254  * Evaluate _STM with timing parameter @stm.
 255  *
 256  * LOCKING:
 257  * EH context.
 258  *
 259  * RETURNS:
 260  * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
 261  */
 262 int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
 263 {
 264         acpi_status status;
 265         struct acpi_object_list         input;
 266         union acpi_object               in_params[3];
 267
 268         in_params[0].type = ACPI_TYPE_BUFFER;
 269         in_params[0].buffer.length = sizeof(struct ata_acpi_gtm);
 270         in_params[0].buffer.pointer = (u8 *)stm;
 271         /* Buffers for id may need byteswapping ? */
 272         in_params[1].type = ACPI_TYPE_BUFFER;
 273         in_params[1].buffer.length = 512;
 274         in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
 275         in_params[2].type = ACPI_TYPE_BUFFER;
 276         in_params[2].buffer.length = 512;
 277         in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
 278
 279         input.count = 3;
 280         input.pointer = in_params;
 281
 282         status = acpi_evaluate_object(ap->acpi_handle, "_STM", &input, NULL);
 283
 284         if (status == AE_NOT_FOUND)
 285                 return -ENOENT;
 286         if (ACPI_FAILURE(status)) {
 287                 ata_port_printk(ap, KERN_ERR,
 288                         "ACPI set timing mode failed (status=0x%x)\n", status);
 289                 return -EINVAL;
 290         }
 291         return 0;
 292 }
 293
 294 EXPORT_SYMBOL_GPL(ata_acpi_stm);
 295
 296 /**
 297  * ata_dev_get_GTF - get the drive bootup default taskfile settings
 298  * @dev: target ATA device
 299  * @gtf: output parameter for buffer containing _GTF taskfile arrays
 300  * @ptr_to_free: pointer which should be freed
 301  *
 302  * This applies to both PATA and SATA drives.
 303  *
 304  * The _GTF method has no input parameters.
 305  * It returns a variable number of register set values (registers
 306  * hex 1F1..1F7, taskfiles).
 307  * The <variable number> is not known in advance, so have ACPI-CA
 308  * allocate the buffer as needed and return it, then free it later.
 309  *
 310  * LOCKING:
 311  * EH context.
 312  *
 313  * RETURNS:
 314  * Number of taskfiles on success, 0 if _GTF doesn't exist or doesn't
 315  * contain valid data.  -errno on other errors.
 316  */
 317 static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
 318                            void **ptr_to_free)
 319 {
 320         struct ata_port *ap = dev->link->ap;
 321         acpi_status status;
 322         struct acpi_buffer output;
 323         union acpi_object *out_obj;
 324         int rc = 0;
 325
 326         /* set up output buffer */
 327         output.length = ACPI_ALLOCATE_BUFFER;
 328         output.pointer = NULL;  /* ACPI-CA sets this; save/free it later */
 329
 330         if (ata_msg_probe(ap))
 331                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
 332                                __FUNCTION__, ap->port_no);
 333
 334         /* _GTF has no input parameters */
 335         status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output);
 336
 337         if (ACPI_FAILURE(status)) {
 338                 if (status != AE_NOT_FOUND) {
 339                         ata_dev_printk(dev, KERN_WARNING,
 340                                        "_GTF evaluation failed (AE 0x%x)\n",
 341                                        status);
 342                         rc = -EIO;
 343                 }
 344                 goto out_free;
 345         }
 346
 347         if (!output.length || !output.pointer) {
 348                 if (ata_msg_probe(ap))
 349                         ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
 350                                 "length or ptr is NULL (0x%llx, 0x%p)\n",
 351                                 __FUNCTION__,
 352                                 (unsigned long long)output.length,
 353                                 output.pointer);
 354                 goto out_free;
 355         }
 356
 357         out_obj = output.pointer;
 358         if (out_obj->type != ACPI_TYPE_BUFFER) {
 359                 ata_dev_printk(dev, KERN_WARNING,
 360                                "_GTF unexpected object type 0x%x\n",
 361                                out_obj->type);
 362                 rc = -EINVAL;
 363                 goto out_free;
 364         }
 365
 366         if (out_obj->buffer.length % REGS_PER_GTF) {
 367                 ata_dev_printk(dev, KERN_WARNING,
 368                                "unexpected _GTF length (%d)\n",
 369                                out_obj->buffer.length);
 370                 rc = -EINVAL;
 371                 goto out_free;
 372         }
 373
 374         *ptr_to_free = out_obj;
 375         *gtf = (void *)out_obj->buffer.pointer;
 376         rc = out_obj->buffer.length / REGS_PER_GTF;
 377
 378         if (ata_msg_probe(ap))
 379                 ata_dev_printk(dev, KERN_DEBUG, "%s: returning "
 380                         "gtf=%p, gtf_count=%d, ptr_to_free=%p\n",
 381                         __FUNCTION__, *gtf, rc, *ptr_to_free);
 382         return rc;
 383
 384  out_free:
 385         kfree(output.pointer);
 386         return rc;
 387 }
 388
 389 /**
 390  * ata_acpi_cbl_80wire          -       Check for 80 wire cable
 391  * @ap: Port to check
 392  *
 393  * Return 1 if the ACPI mode data for this port indicates the BIOS selected
 394  * an 80wire mode.
 395  */
 396
 397 int ata_acpi_cbl_80wire(struct ata_port *ap)
 398 {
 399         struct ata_acpi_gtm gtm;
 400         int valid = 0;
 401
 402         /* No _GTM data, no information */
 403         if (ata_acpi_gtm(ap, &gtm) < 0)
 404                 return 0;
 405
 406         /* Split timing, DMA enabled */
 407         if ((gtm.flags & 0x11) == 0x11 && gtm.drive[0].dma < 55)
 408                 valid |= 1;
 409         if ((gtm.flags & 0x14) == 0x14 && gtm.drive[1].dma < 55)
 410                 valid |= 2;
 411         /* Shared timing, DMA enabled */
 412         if ((gtm.flags & 0x11) == 0x01 && gtm.drive[0].dma < 55)
 413                 valid |= 1;
 414         if ((gtm.flags & 0x14) == 0x04 && gtm.drive[0].dma < 55)
 415                 valid |= 2;
 416
 417         /* Drive check */
 418         if ((valid & 1) && ata_dev_enabled(&ap->link.device[0]))
 419                 return 1;
 420         if ((valid & 2) && ata_dev_enabled(&ap->link.device[1]))
 421                 return 1;
 422         return 0;
 423 }
 424
 425 EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
 426
 427 /**
 428  * taskfile_load_raw - send taskfile registers to host controller
 429  * @dev: target ATA device
 430  * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
 431  *
 432  * Outputs ATA taskfile to standard ATA host controller using MMIO
 433  * or PIO as indicated by the ATA_FLAG_MMIO flag.
 434  * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
 435  * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
 436  * hob_lbal, hob_lbam, and hob_lbah.
 437  *
 438  * This function waits for idle (!BUSY and !DRQ) after writing
 439  * registers.  If the control register has a new value, this
 440  * function also waits for idle after writing control and before
 441  * writing the remaining registers.
 442  *
 443  * LOCKING:
 444  * EH context.
 445  *
 446  * RETURNS:
 447  * 0 on success, -errno on failure.
 448  */
 449 static int taskfile_load_raw(struct ata_device *dev,
 450                               const struct ata_acpi_gtf *gtf)
 451 {
 452         struct ata_port *ap = dev->link->ap;
 453         struct ata_taskfile tf, rtf;
 454         unsigned int err_mask;
 455
 456         if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
 457             && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
 458             && (gtf->tf[6] == 0))
 459                 return 0;
 460
 461         ata_tf_init(dev, &tf);
 462
 463         /* convert gtf to tf */
 464         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */
 465         tf.protocol = ATA_PROT_NODATA;
 466         tf.feature = gtf->tf[0];        /* 0x1f1 */
 467         tf.nsect   = gtf->tf[1];        /* 0x1f2 */
 468         tf.lbal    = gtf->tf[2];        /* 0x1f3 */
 469         tf.lbam    = gtf->tf[3];        /* 0x1f4 */
 470         tf.lbah    = gtf->tf[4];        /* 0x1f5 */
 471         tf.device  = gtf->tf[5];        /* 0x1f6 */
 472         tf.command = gtf->tf[6];        /* 0x1f7 */
 473
 474         if (ata_msg_probe(ap))
 475                 ata_dev_printk(dev, KERN_DEBUG, "executing ACPI cmd "
 476                                "%02x/%02x:%02x:%02x:%02x:%02x:%02x\n",
 477                                tf.command, tf.feature, tf.nsect,
 478                                tf.lbal, tf.lbam, tf.lbah, tf.device);
 479
 480         rtf = tf;
 481         err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0, 0);
 482         if (err_mask) {
 483                 ata_dev_printk(dev, KERN_ERR,
 484                         "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
 485                         "(Emask=0x%x Stat=0x%02x Err=0x%02x)\n",
 486                         tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam,
 487                         tf.lbah, tf.device, err_mask, rtf.command, rtf.feature);
 488                 return -EIO;
 489         }
 490
 491         return 0;
 492 }
 493
 494 /**
 495  * ata_acpi_exec_tfs - get then write drive taskfile settings
 496  * @dev: target ATA device
 497  *
 498  * Evaluate _GTF and excute returned taskfiles.
 499  *
 500  * LOCKING:
 501  * EH context.
 502  *
 503  * RETURNS:
 504  * Number of executed taskfiles on success, 0 if _GTF doesn't exist or
 505  * doesn't contain valid data.  -errno on other errors.
 506  */
 507 static int ata_acpi_exec_tfs(struct ata_device *dev)
 508 {
 509         struct ata_acpi_gtf *gtf = NULL;
 510         void *ptr_to_free = NULL;
 511         int gtf_count, i, rc;
 512
 513         /* get taskfiles */
 514         rc = ata_dev_get_GTF(dev, &gtf, &ptr_to_free);
 515         if (rc < 0)
 516                 return rc;
 517         gtf_count = rc;
 518
 519         /* execute them */
 520         for (i = 0, rc = 0; i < gtf_count; i++) {
 521                 int tmp;
 522
 523                 /* ACPI errors are eventually ignored.  Run till the
 524                  * end even after errors.
 525                  */
 526                 tmp = taskfile_load_raw(dev, gtf++);
 527                 if (!rc)
 528                         rc = tmp;
 529         }
 530
 531         kfree(ptr_to_free);
 532
 533         if (rc == 0)
 534                 return gtf_count;
 535         return rc;
 536 }
 537
 538 /**
 539  * ata_acpi_push_id - send Identify data to drive
 540  * @dev: target ATA device
 541  *
 542  * _SDD ACPI object: for SATA mode only
 543  * Must be after Identify (Packet) Device -- uses its data
 544  * ATM this function never returns a failure.  It is an optional
 545  * method and if it fails for whatever reason, we should still
 546  * just keep going.
 547  *
 548  * LOCKING:
 549  * EH context.
 550  *
 551  * RETURNS:
 552  * 0 on success, -errno on failure.
 553  */
 554 static int ata_acpi_push_id(struct ata_device *dev)
 555 {
 556         struct ata_port *ap = dev->link->ap;
 557         int err;
 558         acpi_status status;
 559         struct acpi_object_list input;
 560         union acpi_object in_params[1];
 561
 562         if (ata_msg_probe(ap))
 563                 ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
 564                                __FUNCTION__, dev->devno, ap->port_no);
 565
 566         /* Give the drive Identify data to the drive via the _SDD method */
 567         /* _SDD: set up input parameters */
 568         input.count = 1;
 569         input.pointer = in_params;
 570         in_params[0].type = ACPI_TYPE_BUFFER;
 571         in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
 572         in_params[0].buffer.pointer = (u8 *)dev->id;
 573         /* Output buffer: _SDD has no output */
 574
 575         /* It's OK for _SDD to be missing too. */
 576         swap_buf_le16(dev->id, ATA_ID_WORDS);
 577         status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL);
 578         swap_buf_le16(dev->id, ATA_ID_WORDS);
 579
 580         err = ACPI_FAILURE(status) ? -EIO : 0;
 581         if (err < 0)
 582                 ata_dev_printk(dev, KERN_WARNING,
 583                                "ACPI _SDD failed (AE 0x%x)\n", status);
 584
 585         return err;
 586 }
 587
 588 /**
 589  * ata_acpi_on_suspend - ATA ACPI hook called on suspend
 590  * @ap: target ATA port
 591  *
 592  * This function is called when @ap is about to be suspended.  All
 593  * devices are already put to sleep but the port_suspend() callback
 594  * hasn't been executed yet.  Error return from this function aborts
 595  * suspend.
 596  *
 597  * LOCKING:
 598  * EH context.
 599  *
 600  * RETURNS:
 601  * 0 on success, -errno on failure.
 602  */
 603 int ata_acpi_on_suspend(struct ata_port *ap)
 604 {
 605         unsigned long flags;
 606         int rc;
 607
 608         /* proceed iff per-port acpi_handle is valid */
 609         if (!ap->acpi_handle)
 610                 return 0;
 611         BUG_ON(ap->flags & ATA_FLAG_ACPI_SATA);
 612
 613         /* store timing parameters */
 614         rc = ata_acpi_gtm(ap, &ap->acpi_gtm);
 615
 616         spin_lock_irqsave(ap->lock, flags);
 617         if (rc == 0)
 618                 ap->pflags |= ATA_PFLAG_GTM_VALID;
 619         else
 620                 ap->pflags &= ~ATA_PFLAG_GTM_VALID;
 621         spin_unlock_irqrestore(ap->lock, flags);
 622
 623         if (rc == -ENOENT)
 624                 rc = 0;
 625         return rc;
 626 }
 627
 628 /**
 629  * ata_acpi_on_resume - ATA ACPI hook called on resume
 630  * @ap: target ATA port
 631  *
 632  * This function is called when @ap is resumed - right after port
 633  * itself is resumed but before any EH action is taken.
 634  *
 635  * LOCKING:
 636  * EH context.
 637  */
 638 void ata_acpi_on_resume(struct ata_port *ap)
 639 {
 640         struct ata_device *dev;
 641
 642         if (ap->acpi_handle && (ap->pflags & ATA_PFLAG_GTM_VALID)) {
 643                 BUG_ON(ap->flags & ATA_FLAG_ACPI_SATA);
 644
 645                 /* restore timing parameters */
 646                 ata_acpi_stm(ap, &ap->acpi_gtm);
 647         }
 648
 649         /* schedule _GTF */
 650         ata_link_for_each_dev(dev, &ap->link)
 651                 dev->flags |= ATA_DFLAG_ACPI_PENDING;
 652 }
 653
 654 /**
 655  * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
 656  * @dev: target ATA device
 657  *
 658  * This function is called when @dev is about to be configured.
 659  * IDENTIFY data might have been modified after this hook is run.
 660  *
 661  * LOCKING:
 662  * EH context.
 663  *
 664  * RETURNS:
 665  * Positive number if IDENTIFY data needs to be refreshed, 0 if not,
 666  * -errno on failure.
 667  */
 668 int ata_acpi_on_devcfg(struct ata_device *dev)
 669 {
 670         struct ata_port *ap = dev->link->ap;
 671         struct ata_eh_context *ehc = &ap->link.eh_context;
 672         int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
 673         int rc;
 674
 675         if (!dev->acpi_handle)
 676                 return 0;
 677
 678         /* do we need to do _GTF? */
 679         if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
 680             !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
 681                 return 0;
 682
 683         /* do _SDD if SATA */
 684         if (acpi_sata) {
 685                 rc = ata_acpi_push_id(dev);
 686                 if (rc)
 687                         goto acpi_err;
 688         }
 689
 690         /* do _GTF */
 691         rc = ata_acpi_exec_tfs(dev);
 692         if (rc < 0)
 693                 goto acpi_err;
 694
 695         dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
 696
 697         /* refresh IDENTIFY page if any _GTF command has been executed */
 698         if (rc > 0) {
 699                 rc = ata_dev_reread_id(dev, 0);
 700                 if (rc < 0) {
 701                         ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY "
 702                                        "after ACPI commands\n");
 703                         return rc;
 704                 }
 705         }
 706
 707         return 0;
 708
 709  acpi_err:
 710         /* let EH retry on the first failure, disable ACPI on the second */
 711         if (dev->flags & ATA_DFLAG_ACPI_FAILED) {
 712                 ata_dev_printk(dev, KERN_WARNING, "ACPI on devcfg failed the "
 713                                "second time, disabling (errno=%d)\n", rc);
 714
 715                 dev->acpi_handle = NULL;
 716
 717                 /* if port is working, request IDENTIFY reload and continue */
 718                 if (!(ap->pflags & ATA_PFLAG_FROZEN))
 719                         rc = 1;
 720         }
 721         dev->flags |= ATA_DFLAG_ACPI_FAILED;
 722         return rc;
 723 }