drivers/ide/ide-acpi.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
no_acpi_psx
ide_acpi_init
ide_port_acpi
acpi_get_child
ide_get_dev_handle
ide_acpi_hwif_get_handle
do_drive_get_GTF
do_drive_set_taskfiles
ide_acpi_exec_tfs
ide_acpi_get_timing
ide_acpi_push_timing
ide_acpi_set_state
ide_acpi_init_port
ide_acpi_port_init_devices
   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Provides ACPI support for IDE drives.
   4  *
   5  * Copyright (C) 2005 Intel Corp.
   6  * Copyright (C) 2005 Randy Dunlap
   7  * Copyright (C) 2006 SUSE Linux Products GmbH
   8  * Copyright (C) 2006 Hannes Reinecke
   9  */
  10 
  11 #include <linux/acpi.h>
  12 #include <linux/ata.h>
  13 #include <linux/delay.h>
  14 #include <linux/device.h>
  15 #include <linux/errno.h>
  16 #include <linux/kernel.h>
  17 #include <linux/slab.h>
  18 #include <linux/ide.h>
  19 #include <linux/pci.h>
  20 #include <linux/dmi.h>
  21 #include <linux/module.h>
  22 
  23 #define REGS_PER_GTF            7
  24 
  25 struct GTM_buffer {
  26         u32     PIO_speed0;
  27         u32     DMA_speed0;
  28         u32     PIO_speed1;
  29         u32     DMA_speed1;
  30         u32     GTM_flags;
  31 };
  32 
  33 struct ide_acpi_drive_link {
  34         acpi_handle      obj_handle;
  35         u8               idbuff[512];
  36 };
  37 
  38 struct ide_acpi_hwif_link {
  39         ide_hwif_t                      *hwif;
  40         acpi_handle                      obj_handle;
  41         struct GTM_buffer                gtm;
  42         struct ide_acpi_drive_link       master;
  43         struct ide_acpi_drive_link       slave;
  44 };
  45 
  46 #undef DEBUGGING
  47 /* note: adds function name and KERN_DEBUG */
  48 #ifdef DEBUGGING
  49 #define DEBPRINT(fmt, args...)  \
  50                 printk(KERN_DEBUG "%s: " fmt, __func__, ## args)
  51 #else
  52 #define DEBPRINT(fmt, args...)  do {} while (0)
  53 #endif  /* DEBUGGING */
  54 
  55 static bool ide_noacpi;
  56 module_param_named(noacpi, ide_noacpi, bool, 0);
  57 MODULE_PARM_DESC(noacpi, "disable IDE ACPI support");
  58 
  59 static bool ide_acpigtf;
  60 module_param_named(acpigtf, ide_acpigtf, bool, 0);
  61 MODULE_PARM_DESC(acpigtf, "enable IDE ACPI _GTF support");
  62 
  63 static bool ide_acpionboot;
  64 module_param_named(acpionboot, ide_acpionboot, bool, 0);
  65 MODULE_PARM_DESC(acpionboot, "call IDE ACPI methods on boot");
  66 
  67 static bool ide_noacpi_psx;
  68 static int no_acpi_psx(const struct dmi_system_id *id)
  69 {
  70         ide_noacpi_psx = true;
  71         printk(KERN_NOTICE"%s detected - disable ACPI _PSx.\n", id->ident);
  72         return 0;
  73 }
  74 
  75 static const struct dmi_system_id ide_acpi_dmi_table[] = {
  76         /* Bug 9673. */
  77         /* We should check if this is because ACPI NVS isn't save/restored. */
  78         {
  79                 .callback = no_acpi_psx,
  80                 .ident    = "HP nx9005",
  81                 .matches  = {
  82                         DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies Ltd."),
  83                         DMI_MATCH(DMI_BIOS_VERSION, "KAM1.60")
  84                 },
  85         },
  86 
  87         { }     /* terminate list */
  88 };
  89 
  90 int ide_acpi_init(void)
  91 {
  92         dmi_check_system(ide_acpi_dmi_table);
  93         return 0;
  94 }
  95 
  96 bool ide_port_acpi(ide_hwif_t *hwif)
  97 {
  98         return ide_noacpi == 0 && hwif->acpidata;
  99 }
 100 
 101 static acpi_handle acpi_get_child(acpi_handle handle, u64 addr)
 102 {
 103         struct acpi_device *adev;
 104 
 105         if (!handle || acpi_bus_get_device(handle, &adev))
 106                 return NULL;
 107 
 108         adev = acpi_find_child_device(adev, addr, false);
 109         return adev ? adev->handle : NULL;
 110 }
 111 
 112 /**
 113  * ide_get_dev_handle - finds acpi_handle and PCI device.function
 114  * @dev: device to locate
 115  * @handle: returned acpi_handle for @dev
 116  * @pcidevfn: return PCI device.func for @dev
 117  *
 118  * Returns the ACPI object handle to the corresponding PCI device.
 119  *
 120  * Returns 0 on success, <0 on error.
 121  */
 122 static int ide_get_dev_handle(struct device *dev, acpi_handle *handle,
 123                                u64 *pcidevfn)
 124 {
 125         struct pci_dev *pdev = to_pci_dev(dev);
 126         unsigned int bus, devnum, func;
 127         u64 addr;
 128         acpi_handle dev_handle;
 129         acpi_status status;
 130         struct acpi_device_info *dinfo = NULL;
 131         int ret = -ENODEV;
 132 
 133         bus = pdev->bus->number;
 134         devnum = PCI_SLOT(pdev->devfn);
 135         func = PCI_FUNC(pdev->devfn);
 136         /* ACPI _ADR encoding for PCI bus: */
 137         addr = (u64)(devnum << 16 | func);
 138 
 139         DEBPRINT("ENTER: pci %02x:%02x.%01x\n", bus, devnum, func);
 140 
 141         dev_handle = ACPI_HANDLE(dev);
 142         if (!dev_handle) {
 143                 DEBPRINT("no acpi handle for device\n");
 144                 goto err;
 145         }
 146 
 147         status = acpi_get_object_info(dev_handle, &dinfo);
 148         if (ACPI_FAILURE(status)) {
 149                 DEBPRINT("get_object_info for device failed\n");
 150                 goto err;
 151         }
 152         if (dinfo && (dinfo->valid & ACPI_VALID_ADR) &&
 153             dinfo->address == addr) {
 154                 *pcidevfn = addr;
 155                 *handle = dev_handle;
 156         } else {
 157                 DEBPRINT("get_object_info for device has wrong "
 158                         " address: %llu, should be %u\n",
 159                         dinfo ? (unsigned long long)dinfo->address : -1ULL,
 160                         (unsigned int)addr);
 161                 goto err;
 162         }
 163 
 164         DEBPRINT("for dev=0x%x.%x, addr=0x%llx, *handle=0x%p\n",
 165                  devnum, func, (unsigned long long)addr, *handle);
 166         ret = 0;
 167 err:
 168         kfree(dinfo);
 169         return ret;
 170 }
 171 
 172 /**
 173  * ide_acpi_hwif_get_handle - Get ACPI object handle for a given hwif
 174  * @hwif: device to locate
 175  *
 176  * Retrieves the object handle for a given hwif.
 177  *
 178  * Returns handle on success, 0 on error.
 179  */
 180 static acpi_handle ide_acpi_hwif_get_handle(ide_hwif_t *hwif)
 181 {
 182         struct device           *dev = hwif->gendev.parent;
 183         acpi_handle             uninitialized_var(dev_handle);
 184         u64                     pcidevfn;
 185         acpi_handle             chan_handle;
 186         int                     err;
 187 
 188         DEBPRINT("ENTER: device %s\n", hwif->name);
 189 
 190         if (!dev) {
 191                 DEBPRINT("no PCI device for %s\n", hwif->name);
 192                 return NULL;
 193         }
 194 
 195         err = ide_get_dev_handle(dev, &dev_handle, &pcidevfn);
 196         if (err < 0) {
 197                 DEBPRINT("ide_get_dev_handle failed (%d)\n", err);
 198                 return NULL;
 199         }
 200 
 201         /* get child objects of dev_handle == channel objects,
 202          * + _their_ children == drive objects */
 203         /* channel is hwif->channel */
 204         chan_handle = acpi_get_child(dev_handle, hwif->channel);
 205         DEBPRINT("chan adr=%d: handle=0x%p\n",
 206                  hwif->channel, chan_handle);
 207 
 208         return chan_handle;
 209 }
 210 
 211 /**
 212  * do_drive_get_GTF - get the drive bootup default taskfile settings
 213  * @drive: the drive for which the taskfile settings should be retrieved
 214  * @gtf_length: number of bytes of _GTF data returned at @gtf_address
 215  * @gtf_address: buffer containing _GTF taskfile arrays
 216  *
 217  * The _GTF method has no input parameters.
 218  * It returns a variable number of register set values (registers
 219  * hex 1F1..1F7, taskfiles).
 220  * The <variable number> is not known in advance, so have ACPI-CA
 221  * allocate the buffer as needed and return it, then free it later.
 222  *
 223  * The returned @gtf_length and @gtf_address are only valid if the
 224  * function return value is 0.
 225  */
 226 static int do_drive_get_GTF(ide_drive_t *drive,
 227                      unsigned int *gtf_length, unsigned long *gtf_address,
 228                      unsigned long *obj_loc)
 229 {
 230         acpi_status                     status;
 231         struct acpi_buffer              output;
 232         union acpi_object               *out_obj;
 233         int                             err = -ENODEV;
 234 
 235         *gtf_length = 0;
 236         *gtf_address = 0UL;
 237         *obj_loc = 0UL;
 238 
 239         if (!drive->acpidata->obj_handle) {
 240                 DEBPRINT("No ACPI object found for %s\n", drive->name);
 241                 goto out;
 242         }
 243 
 244         /* Setting up output buffer */
 245         output.length = ACPI_ALLOCATE_BUFFER;
 246         output.pointer = NULL;  /* ACPI-CA sets this; save/free it later */
 247 
 248         /* _GTF has no input parameters */
 249         err = -EIO;
 250         status = acpi_evaluate_object(drive->acpidata->obj_handle, "_GTF",
 251                                       NULL, &output);
 252         if (ACPI_FAILURE(status)) {
 253                 printk(KERN_DEBUG
 254                        "%s: Run _GTF error: status = 0x%x\n",
 255                        __func__, status);
 256                 goto out;
 257         }
 258 
 259         if (!output.length || !output.pointer) {
 260                 DEBPRINT("Run _GTF: "
 261                        "length or ptr is NULL (0x%llx, 0x%p)\n",
 262                        (unsigned long long)output.length,
 263                        output.pointer);
 264                 goto out;
 265         }
 266 
 267         out_obj = output.pointer;
 268         if (out_obj->type != ACPI_TYPE_BUFFER) {
 269                 DEBPRINT("Run _GTF: error: "
 270                        "expected object type of ACPI_TYPE_BUFFER, "
 271                        "got 0x%x\n", out_obj->type);
 272                 err = -ENOENT;
 273                 kfree(output.pointer);
 274                 goto out;
 275         }
 276 
 277         if (!out_obj->buffer.length || !out_obj->buffer.pointer ||
 278             out_obj->buffer.length % REGS_PER_GTF) {
 279                 printk(KERN_ERR
 280                        "%s: unexpected GTF length (%d) or addr (0x%p)\n",
 281                        __func__, out_obj->buffer.length,
 282                        out_obj->buffer.pointer);
 283                 err = -ENOENT;
 284                 kfree(output.pointer);
 285                 goto out;
 286         }
 287 
 288         *gtf_length = out_obj->buffer.length;
 289         *gtf_address = (unsigned long)out_obj->buffer.pointer;
 290         *obj_loc = (unsigned long)out_obj;
 291         DEBPRINT("returning gtf_length=%d, gtf_address=0x%lx, obj_loc=0x%lx\n",
 292                  *gtf_length, *gtf_address, *obj_loc);
 293         err = 0;
 294 out:
 295         return err;
 296 }
 297 
 298 /**
 299  * do_drive_set_taskfiles - write the drive taskfile settings from _GTF
 300  * @drive: the drive to which the taskfile command should be sent
 301  * @gtf_length: total number of bytes of _GTF taskfiles
 302  * @gtf_address: location of _GTF taskfile arrays
 303  *
 304  * Write {gtf_address, length gtf_length} in groups of
 305  * REGS_PER_GTF bytes.
 306  */
 307 static int do_drive_set_taskfiles(ide_drive_t *drive,
 308                                   unsigned int gtf_length,
 309                                   unsigned long gtf_address)
 310 {
 311         int                     rc = 0, err;
 312         int                     gtf_count = gtf_length / REGS_PER_GTF;
 313         int                     ix;
 314 
 315         DEBPRINT("total GTF bytes=%u (0x%x), gtf_count=%d, addr=0x%lx\n",
 316                  gtf_length, gtf_length, gtf_count, gtf_address);
 317 
 318         /* send all taskfile registers (0x1f1-0x1f7) *in*that*order* */
 319         for (ix = 0; ix < gtf_count; ix++) {
 320                 u8 *gtf = (u8 *)(gtf_address + ix * REGS_PER_GTF);
 321                 struct ide_cmd cmd;
 322 
 323                 DEBPRINT("(0x1f1-1f7): "
 324                          "hex: %02x %02x %02x %02x %02x %02x %02x\n",
 325                          gtf[0], gtf[1], gtf[2],
 326                          gtf[3], gtf[4], gtf[5], gtf[6]);
 327 
 328                 if (!ide_acpigtf) {
 329                         DEBPRINT("_GTF execution disabled\n");
 330                         continue;
 331                 }
 332 
 333                 /* convert GTF to taskfile */
 334                 memset(&cmd, 0, sizeof(cmd));
 335                 memcpy(&cmd.tf.feature, gtf, REGS_PER_GTF);
 336                 cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
 337                 cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
 338 
 339                 err = ide_no_data_taskfile(drive, &cmd);
 340                 if (err) {
 341                         printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n",
 342                                         __func__, err);
 343                         rc = err;
 344                 }
 345         }
 346 
 347         return rc;
 348 }
 349 
 350 /**
 351  * ide_acpi_exec_tfs - get then write drive taskfile settings
 352  * @drive: the drive for which the taskfile settings should be
 353  *         written.
 354  *
 355  * According to the ACPI spec this should be called after _STM
 356  * has been evaluated for the interface. Some ACPI vendors interpret
 357  * that as a hard requirement and modify the taskfile according
 358  * to the Identify Drive information passed down with _STM.
 359  * So one should really make sure to call this only after _STM has
 360  * been executed.
 361  */
 362 int ide_acpi_exec_tfs(ide_drive_t *drive)
 363 {
 364         int             ret;
 365         unsigned int    gtf_length;
 366         unsigned long   gtf_address;
 367         unsigned long   obj_loc;
 368 
 369         DEBPRINT("call get_GTF, drive=%s port=%d\n", drive->name, drive->dn);
 370 
 371         ret = do_drive_get_GTF(drive, &gtf_length, &gtf_address, &obj_loc);
 372         if (ret < 0) {
 373                 DEBPRINT("get_GTF error (%d)\n", ret);
 374                 return ret;
 375         }
 376 
 377         DEBPRINT("call set_taskfiles, drive=%s\n", drive->name);
 378 
 379         ret = do_drive_set_taskfiles(drive, gtf_length, gtf_address);
 380         kfree((void *)obj_loc);
 381         if (ret < 0) {
 382                 DEBPRINT("set_taskfiles error (%d)\n", ret);
 383         }
 384 
 385         DEBPRINT("ret=%d\n", ret);
 386 
 387         return ret;
 388 }
 389 
 390 /**
 391  * ide_acpi_get_timing - get the channel (controller) timings
 392  * @hwif: target IDE interface (channel)
 393  *
 394  * This function executes the _GTM ACPI method for the target channel.
 395  *
 396  */
 397 void ide_acpi_get_timing(ide_hwif_t *hwif)
 398 {
 399         acpi_status             status;
 400         struct acpi_buffer      output;
 401         union acpi_object       *out_obj;
 402 
 403         /* Setting up output buffer for _GTM */
 404         output.length = ACPI_ALLOCATE_BUFFER;
 405         output.pointer = NULL;  /* ACPI-CA sets this; save/free it later */
 406 
 407         /* _GTM has no input parameters */
 408         status = acpi_evaluate_object(hwif->acpidata->obj_handle, "_GTM",
 409                                       NULL, &output);
 410 
 411         DEBPRINT("_GTM status: %d, outptr: 0x%p, outlen: 0x%llx\n",
 412                  status, output.pointer,
 413                  (unsigned long long)output.length);
 414 
 415         if (ACPI_FAILURE(status)) {
 416                 DEBPRINT("Run _GTM error: status = 0x%x\n", status);
 417                 return;
 418         }
 419 
 420         if (!output.length || !output.pointer) {
 421                 DEBPRINT("Run _GTM: length or ptr is NULL (0x%llx, 0x%p)\n",
 422                        (unsigned long long)output.length,
 423                        output.pointer);
 424                 kfree(output.pointer);
 425                 return;
 426         }
 427 
 428         out_obj = output.pointer;
 429         if (out_obj->type != ACPI_TYPE_BUFFER) {
 430                 DEBPRINT("Run _GTM: error: "
 431                        "expected object type of ACPI_TYPE_BUFFER, "
 432                        "got 0x%x\n", out_obj->type);
 433                 kfree(output.pointer);
 434                 return;
 435         }
 436 
 437         if (!out_obj->buffer.length || !out_obj->buffer.pointer ||
 438             out_obj->buffer.length != sizeof(struct GTM_buffer)) {
 439                 printk(KERN_ERR
 440                         "%s: unexpected _GTM length (0x%x)[should be 0x%zx] or "
 441                         "addr (0x%p)\n",
 442                         __func__, out_obj->buffer.length,
 443                         sizeof(struct GTM_buffer), out_obj->buffer.pointer);
 444                 kfree(output.pointer);
 445                 return;
 446         }
 447 
 448         memcpy(&hwif->acpidata->gtm, out_obj->buffer.pointer,
 449                sizeof(struct GTM_buffer));
 450 
 451         DEBPRINT("_GTM info: ptr: 0x%p, len: 0x%x, exp.len: 0x%zx\n",
 452                  out_obj->buffer.pointer, out_obj->buffer.length,
 453                  sizeof(struct GTM_buffer));
 454 
 455         DEBPRINT("_GTM fields: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
 456                  hwif->acpidata->gtm.PIO_speed0,
 457                  hwif->acpidata->gtm.DMA_speed0,
 458                  hwif->acpidata->gtm.PIO_speed1,
 459                  hwif->acpidata->gtm.DMA_speed1,
 460                  hwif->acpidata->gtm.GTM_flags);
 461 
 462         kfree(output.pointer);
 463 }
 464 
 465 /**
 466  * ide_acpi_push_timing - set the channel (controller) timings
 467  * @hwif: target IDE interface (channel)
 468  *
 469  * This function executes the _STM ACPI method for the target channel.
 470  *
 471  * _STM requires Identify Drive data, which has to passed as an argument.
 472  * Unfortunately drive->id is a mangled version which we can't readily
 473  * use; hence we'll get the information afresh.
 474  */
 475 void ide_acpi_push_timing(ide_hwif_t *hwif)
 476 {
 477         acpi_status             status;
 478         struct acpi_object_list input;
 479         union acpi_object       in_params[3];
 480         struct ide_acpi_drive_link      *master = &hwif->acpidata->master;
 481         struct ide_acpi_drive_link      *slave = &hwif->acpidata->slave;
 482 
 483         /* Give the GTM buffer + drive Identify data to the channel via the
 484          * _STM method: */
 485         /* setup input parameters buffer for _STM */
 486         input.count = 3;
 487         input.pointer = in_params;
 488         in_params[0].type = ACPI_TYPE_BUFFER;
 489         in_params[0].buffer.length = sizeof(struct GTM_buffer);
 490         in_params[0].buffer.pointer = (u8 *)&hwif->acpidata->gtm;
 491         in_params[1].type = ACPI_TYPE_BUFFER;
 492         in_params[1].buffer.length = ATA_ID_WORDS * 2;
 493         in_params[1].buffer.pointer = (u8 *)&master->idbuff;
 494         in_params[2].type = ACPI_TYPE_BUFFER;
 495         in_params[2].buffer.length = ATA_ID_WORDS * 2;
 496         in_params[2].buffer.pointer = (u8 *)&slave->idbuff;
 497         /* Output buffer: _STM has no output */
 498 
 499         status = acpi_evaluate_object(hwif->acpidata->obj_handle, "_STM",
 500                                       &input, NULL);
 501 
 502         if (ACPI_FAILURE(status)) {
 503                 DEBPRINT("Run _STM error: status = 0x%x\n", status);
 504         }
 505         DEBPRINT("_STM status: %d\n", status);
 506 }
 507 
 508 /**
 509  * ide_acpi_set_state - set the channel power state
 510  * @hwif: target IDE interface
 511  * @on: state, on/off
 512  *
 513  * This function executes the _PS0/_PS3 ACPI method to set the power state.
 514  * ACPI spec requires _PS0 when IDE power on and _PS3 when power off
 515  */
 516 void ide_acpi_set_state(ide_hwif_t *hwif, int on)
 517 {
 518         ide_drive_t *drive;
 519         int i;
 520 
 521         if (ide_noacpi_psx)
 522                 return;
 523 
 524         DEBPRINT("ENTER:\n");
 525 
 526         /* channel first and then drives for power on and verse versa for power off */
 527         if (on)
 528                 acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D0);
 529 
 530         ide_port_for_each_present_dev(i, drive, hwif) {
 531                 if (drive->acpidata->obj_handle)
 532                         acpi_bus_set_power(drive->acpidata->obj_handle,
 533                                 on ? ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
 534         }
 535 
 536         if (!on)
 537                 acpi_bus_set_power(hwif->acpidata->obj_handle,
 538                                    ACPI_STATE_D3_COLD);
 539 }
 540 
 541 /**
 542  * ide_acpi_init_port - initialize the ACPI link for an IDE interface
 543  * @hwif: target IDE interface (channel)
 544  *
 545  * The ACPI spec is not quite clear when the drive identify buffer
 546  * should be obtained. Calling IDENTIFY DEVICE during shutdown
 547  * is not the best of ideas as the drive might already being put to
 548  * sleep. And obviously we can't call it during resume.
 549  * So we get the information during startup; but this means that
 550  * any changes during run-time will be lost after resume.
 551  */
 552 void ide_acpi_init_port(ide_hwif_t *hwif)
 553 {
 554         hwif->acpidata = kzalloc(sizeof(struct ide_acpi_hwif_link), GFP_KERNEL);
 555         if (!hwif->acpidata)
 556                 return;
 557 
 558         hwif->acpidata->obj_handle = ide_acpi_hwif_get_handle(hwif);
 559         if (!hwif->acpidata->obj_handle) {
 560                 DEBPRINT("no ACPI object for %s found\n", hwif->name);
 561                 kfree(hwif->acpidata);
 562                 hwif->acpidata = NULL;
 563         }
 564 }
 565 
 566 void ide_acpi_port_init_devices(ide_hwif_t *hwif)
 567 {
 568         ide_drive_t *drive;
 569         int i, err;
 570 
 571         if (hwif->acpidata == NULL)
 572                 return;
 573 
 574         /*
 575          * The ACPI spec mandates that we send information
 576          * for both drives, regardless whether they are connected
 577          * or not.
 578          */
 579         hwif->devices[0]->acpidata = &hwif->acpidata->master;
 580         hwif->devices[1]->acpidata = &hwif->acpidata->slave;
 581 
 582         /* get _ADR info for each device */
 583         ide_port_for_each_present_dev(i, drive, hwif) {
 584                 acpi_handle dev_handle;
 585 
 586                 DEBPRINT("ENTER: %s at channel#: %d port#: %d\n",
 587                          drive->name, hwif->channel, drive->dn & 1);
 588 
 589                 /* TBD: could also check ACPI object VALID bits */
 590                 dev_handle = acpi_get_child(hwif->acpidata->obj_handle,
 591                                             drive->dn & 1);
 592 
 593                 DEBPRINT("drive %s handle 0x%p\n", drive->name, dev_handle);
 594 
 595                 drive->acpidata->obj_handle = dev_handle;
 596         }
 597 
 598         /* send IDENTIFY for each device */
 599         ide_port_for_each_present_dev(i, drive, hwif) {
 600                 err = taskfile_lib_get_identify(drive, drive->acpidata->idbuff);
 601                 if (err)
 602                         DEBPRINT("identify device %s failed (%d)\n",
 603                                  drive->name, err);
 604         }
 605 
 606         if (ide_noacpi || ide_acpionboot == 0) {
 607                 DEBPRINT("ACPI methods disabled on boot\n");
 608                 return;
 609         }
 610 
 611         /* ACPI _PS0 before _STM */
 612         ide_acpi_set_state(hwif, 1);
 613         /*
 614          * ACPI requires us to call _STM on startup
 615          */
 616         ide_acpi_get_timing(hwif);
 617         ide_acpi_push_timing(hwif);
 618 
 619         ide_port_for_each_present_dev(i, drive, hwif) {
 620                 ide_acpi_exec_tfs(drive);
 621         }
 622 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/ide/ide-acpi.c

DEFINITIONS
