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