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