ide-acpi.c revision 650d841d9e053a618dd8ce753422f91b493cf2f6
1/* 2 * ide-acpi.c 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/ata.h> 12#include <linux/delay.h> 13#include <linux/device.h> 14#include <linux/errno.h> 15#include <linux/kernel.h> 16#include <acpi/acpi.h> 17#include <linux/ide.h> 18#include <linux/pci.h> 19#include <linux/dmi.h> 20 21#include <acpi/acpi_bus.h> 22#include <acpi/acnames.h> 23#include <acpi/acnamesp.h> 24#include <acpi/acparser.h> 25#include <acpi/acexcep.h> 26#include <acpi/acmacros.h> 27#include <acpi/actypes.h> 28 29#define REGS_PER_GTF 7 30struct taskfile_array { 31 u8 tfa[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */ 32}; 33 34struct GTM_buffer { 35 u32 PIO_speed0; 36 u32 DMA_speed0; 37 u32 PIO_speed1; 38 u32 DMA_speed1; 39 u32 GTM_flags; 40}; 41 42struct ide_acpi_drive_link { 43 ide_drive_t *drive; 44 acpi_handle obj_handle; 45 u8 idbuff[512]; 46}; 47 48struct ide_acpi_hwif_link { 49 ide_hwif_t *hwif; 50 acpi_handle obj_handle; 51 struct GTM_buffer gtm; 52 struct ide_acpi_drive_link master; 53 struct ide_acpi_drive_link slave; 54}; 55 56#undef DEBUGGING 57/* note: adds function name and KERN_DEBUG */ 58#ifdef DEBUGGING 59#define DEBPRINT(fmt, args...) \ 60 printk(KERN_DEBUG "%s: " fmt, __FUNCTION__, ## args) 61#else 62#define DEBPRINT(fmt, args...) do {} while (0) 63#endif /* DEBUGGING */ 64 65extern int ide_noacpi; 66extern int ide_noacpitfs; 67extern int ide_noacpionboot; 68 69static bool ide_noacpi_psx; 70static int no_acpi_psx(const struct dmi_system_id *id) 71{ 72 ide_noacpi_psx = true; 73 printk(KERN_NOTICE"%s detected - disable ACPI _PSx.\n", id->ident); 74 return 0; 75} 76 77static const struct dmi_system_id ide_acpi_dmi_table[] = { 78 /* Bug 9673. */ 79 /* We should check if this is because ACPI NVS isn't save/restored. */ 80 { 81 .callback = no_acpi_psx, 82 .ident = "HP nx9005", 83 .matches = { 84 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies Ltd."), 85 DMI_MATCH(DMI_BIOS_VERSION, "KAM1.60") 86 }, 87 }, 88 89 { } /* terminate list */ 90}; 91 92static int ide_acpi_blacklist(void) 93{ 94 static int done; 95 if (done) 96 return 0; 97 done = 1; 98 dmi_check_system(ide_acpi_dmi_table); 99 return 0; 100} 101 102/** 103 * ide_get_dev_handle - finds acpi_handle and PCI device.function 104 * @dev: device to locate 105 * @handle: returned acpi_handle for @dev 106 * @pcidevfn: return PCI device.func for @dev 107 * 108 * Returns the ACPI object handle to the corresponding PCI device. 109 * 110 * Returns 0 on success, <0 on error. 111 */ 112static int ide_get_dev_handle(struct device *dev, acpi_handle *handle, 113 acpi_integer *pcidevfn) 114{ 115 struct pci_dev *pdev = to_pci_dev(dev); 116 unsigned int bus, devnum, func; 117 acpi_integer addr; 118 acpi_handle dev_handle; 119 struct acpi_buffer buffer = {.length = ACPI_ALLOCATE_BUFFER, 120 .pointer = NULL}; 121 acpi_status status; 122 struct acpi_device_info *dinfo = NULL; 123 int ret = -ENODEV; 124 125 bus = pdev->bus->number; 126 devnum = PCI_SLOT(pdev->devfn); 127 func = PCI_FUNC(pdev->devfn); 128 /* ACPI _ADR encoding for PCI bus: */ 129 addr = (acpi_integer)(devnum << 16 | func); 130 131 DEBPRINT("ENTER: pci %02x:%02x.%01x\n", bus, devnum, func); 132 133 dev_handle = DEVICE_ACPI_HANDLE(dev); 134 if (!dev_handle) { 135 DEBPRINT("no acpi handle for device\n"); 136 goto err; 137 } 138 139 status = acpi_get_object_info(dev_handle, &buffer); 140 if (ACPI_FAILURE(status)) { 141 DEBPRINT("get_object_info for device failed\n"); 142 goto err; 143 } 144 dinfo = buffer.pointer; 145 if (dinfo && (dinfo->valid & ACPI_VALID_ADR) && 146 dinfo->address == addr) { 147 *pcidevfn = addr; 148 *handle = dev_handle; 149 } else { 150 DEBPRINT("get_object_info for device has wrong " 151 " address: %llu, should be %u\n", 152 dinfo ? (unsigned long long)dinfo->address : -1ULL, 153 (unsigned int)addr); 154 goto err; 155 } 156 157 DEBPRINT("for dev=0x%x.%x, addr=0x%llx, *handle=0x%p\n", 158 devnum, func, (unsigned long long)addr, *handle); 159 ret = 0; 160err: 161 kfree(dinfo); 162 return ret; 163} 164 165/** 166 * ide_acpi_hwif_get_handle - Get ACPI object handle for a given hwif 167 * @hwif: device to locate 168 * 169 * Retrieves the object handle for a given hwif. 170 * 171 * Returns handle on success, 0 on error. 172 */ 173static acpi_handle ide_acpi_hwif_get_handle(ide_hwif_t *hwif) 174{ 175 struct device *dev = hwif->gendev.parent; 176 acpi_handle dev_handle; 177 acpi_integer pcidevfn; 178 acpi_handle chan_handle; 179 int err; 180 181 DEBPRINT("ENTER: device %s\n", hwif->name); 182 183 if (!dev) { 184 DEBPRINT("no PCI device for %s\n", hwif->name); 185 return NULL; 186 } 187 188 err = ide_get_dev_handle(dev, &dev_handle, &pcidevfn); 189 if (err < 0) { 190 DEBPRINT("ide_get_dev_handle failed (%d)\n", err); 191 return NULL; 192 } 193 194 /* get child objects of dev_handle == channel objects, 195 * + _their_ children == drive objects */ 196 /* channel is hwif->channel */ 197 chan_handle = acpi_get_child(dev_handle, hwif->channel); 198 DEBPRINT("chan adr=%d: handle=0x%p\n", 199 hwif->channel, chan_handle); 200 201 return chan_handle; 202} 203 204/** 205 * ide_acpi_drive_get_handle - Get ACPI object handle for a given drive 206 * @drive: device to locate 207 * 208 * Retrieves the object handle of a given drive. According to the ACPI 209 * spec the drive is a child of the hwif. 210 * 211 * Returns handle on success, 0 on error. 212 */ 213static acpi_handle ide_acpi_drive_get_handle(ide_drive_t *drive) 214{ 215 ide_hwif_t *hwif = HWIF(drive); 216 int port; 217 acpi_handle drive_handle; 218 219 if (!hwif->acpidata) 220 return NULL; 221 222 if (!hwif->acpidata->obj_handle) 223 return NULL; 224 225 port = hwif->channel ? drive->dn - 2: drive->dn; 226 227 DEBPRINT("ENTER: %s at channel#: %d port#: %d\n", 228 drive->name, hwif->channel, port); 229 230 231 /* TBD: could also check ACPI object VALID bits */ 232 drive_handle = acpi_get_child(hwif->acpidata->obj_handle, port); 233 DEBPRINT("drive %s handle 0x%p\n", drive->name, drive_handle); 234 235 return drive_handle; 236} 237 238/** 239 * do_drive_get_GTF - get the drive bootup default taskfile settings 240 * @drive: the drive for which the taskfile settings should be retrieved 241 * @gtf_length: number of bytes of _GTF data returned at @gtf_address 242 * @gtf_address: buffer containing _GTF taskfile arrays 243 * 244 * The _GTF method has no input parameters. 245 * It returns a variable number of register set values (registers 246 * hex 1F1..1F7, taskfiles). 247 * The <variable number> is not known in advance, so have ACPI-CA 248 * allocate the buffer as needed and return it, then free it later. 249 * 250 * The returned @gtf_length and @gtf_address are only valid if the 251 * function return value is 0. 252 */ 253static int do_drive_get_GTF(ide_drive_t *drive, 254 unsigned int *gtf_length, unsigned long *gtf_address, 255 unsigned long *obj_loc) 256{ 257 acpi_status status; 258 struct acpi_buffer output; 259 union acpi_object *out_obj; 260 ide_hwif_t *hwif = HWIF(drive); 261 struct device *dev = hwif->gendev.parent; 262 int err = -ENODEV; 263 int port; 264 265 *gtf_length = 0; 266 *gtf_address = 0UL; 267 *obj_loc = 0UL; 268 269 if (ide_noacpi) 270 return 0; 271 272 if (!dev) { 273 DEBPRINT("no PCI device for %s\n", hwif->name); 274 goto out; 275 } 276 277 if (!hwif->acpidata) { 278 DEBPRINT("no ACPI data for %s\n", hwif->name); 279 goto out; 280 } 281 282 port = hwif->channel ? drive->dn - 2: drive->dn; 283 284 if (!drive->acpidata) { 285 if (port == 0) { 286 drive->acpidata = &hwif->acpidata->master; 287 hwif->acpidata->master.drive = drive; 288 } else { 289 drive->acpidata = &hwif->acpidata->slave; 290 hwif->acpidata->slave.drive = drive; 291 } 292 } 293 294 DEBPRINT("ENTER: %s at %s, port#: %d, hard_port#: %d\n", 295 hwif->name, dev->bus_id, port, hwif->channel); 296 297 if (!drive->present) { 298 DEBPRINT("%s drive %d:%d not present\n", 299 hwif->name, hwif->channel, port); 300 goto out; 301 } 302 303 /* Get this drive's _ADR info. if not already known. */ 304 if (!drive->acpidata->obj_handle) { 305 drive->acpidata->obj_handle = ide_acpi_drive_get_handle(drive); 306 if (!drive->acpidata->obj_handle) { 307 DEBPRINT("No ACPI object found for %s\n", 308 drive->name); 309 goto out; 310 } 311 } 312 313 /* Setting up output buffer */ 314 output.length = ACPI_ALLOCATE_BUFFER; 315 output.pointer = NULL; /* ACPI-CA sets this; save/free it later */ 316 317 /* _GTF has no input parameters */ 318 err = -EIO; 319 status = acpi_evaluate_object(drive->acpidata->obj_handle, "_GTF", 320 NULL, &output); 321 if (ACPI_FAILURE(status)) { 322 printk(KERN_DEBUG 323 "%s: Run _GTF error: status = 0x%x\n", 324 __FUNCTION__, status); 325 goto out; 326 } 327 328 if (!output.length || !output.pointer) { 329 DEBPRINT("Run _GTF: " 330 "length or ptr is NULL (0x%llx, 0x%p)\n", 331 (unsigned long long)output.length, 332 output.pointer); 333 goto out; 334 } 335 336 out_obj = output.pointer; 337 if (out_obj->type != ACPI_TYPE_BUFFER) { 338 DEBPRINT("Run _GTF: error: " 339 "expected object type of ACPI_TYPE_BUFFER, " 340 "got 0x%x\n", out_obj->type); 341 err = -ENOENT; 342 kfree(output.pointer); 343 goto out; 344 } 345 346 if (!out_obj->buffer.length || !out_obj->buffer.pointer || 347 out_obj->buffer.length % REGS_PER_GTF) { 348 printk(KERN_ERR 349 "%s: unexpected GTF length (%d) or addr (0x%p)\n", 350 __FUNCTION__, out_obj->buffer.length, 351 out_obj->buffer.pointer); 352 err = -ENOENT; 353 kfree(output.pointer); 354 goto out; 355 } 356 357 *gtf_length = out_obj->buffer.length; 358 *gtf_address = (unsigned long)out_obj->buffer.pointer; 359 *obj_loc = (unsigned long)out_obj; 360 DEBPRINT("returning gtf_length=%d, gtf_address=0x%lx, obj_loc=0x%lx\n", 361 *gtf_length, *gtf_address, *obj_loc); 362 err = 0; 363out: 364 return err; 365} 366 367/** 368 * taskfile_load_raw - send taskfile registers to drive 369 * @drive: drive to which output is sent 370 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7) 371 * 372 * Outputs IDE taskfile to the drive. 373 */ 374static int taskfile_load_raw(ide_drive_t *drive, 375 const struct taskfile_array *gtf) 376{ 377 ide_task_t args; 378 int err = 0; 379 380 DEBPRINT("(0x1f1-1f7): hex: " 381 "%02x %02x %02x %02x %02x %02x %02x\n", 382 gtf->tfa[0], gtf->tfa[1], gtf->tfa[2], 383 gtf->tfa[3], gtf->tfa[4], gtf->tfa[5], gtf->tfa[6]); 384 385 memset(&args, 0, sizeof(ide_task_t)); 386 args.command_type = IDE_DRIVE_TASK_NO_DATA; 387 args.data_phase = TASKFILE_NO_DATA; 388 args.handler = &task_no_data_intr; 389 390 /* convert gtf to IDE Taskfile */ 391 memcpy(&args.tf_array[7], >f->tfa, 7); 392 393 if (ide_noacpitfs) { 394 DEBPRINT("_GTF execution disabled\n"); 395 return err; 396 } 397 398 err = ide_raw_taskfile(drive, &args, NULL); 399 if (err) 400 printk(KERN_ERR "%s: ide_raw_taskfile failed: %u\n", 401 __FUNCTION__, err); 402 403 return err; 404} 405 406/** 407 * do_drive_set_taskfiles - write the drive taskfile settings from _GTF 408 * @drive: the drive to which the taskfile command should be sent 409 * @gtf_length: total number of bytes of _GTF taskfiles 410 * @gtf_address: location of _GTF taskfile arrays 411 * 412 * Write {gtf_address, length gtf_length} in groups of 413 * REGS_PER_GTF bytes. 414 */ 415static int do_drive_set_taskfiles(ide_drive_t *drive, 416 unsigned int gtf_length, 417 unsigned long gtf_address) 418{ 419 int rc = -ENODEV, err; 420 int gtf_count = gtf_length / REGS_PER_GTF; 421 int ix; 422 struct taskfile_array *gtf; 423 424 if (ide_noacpi) 425 return 0; 426 427 DEBPRINT("ENTER: %s, hard_port#: %d\n", drive->name, drive->dn); 428 429 if (!drive->present) 430 goto out; 431 if (!gtf_count) /* shouldn't be here */ 432 goto out; 433 434 DEBPRINT("total GTF bytes=%u (0x%x), gtf_count=%d, addr=0x%lx\n", 435 gtf_length, gtf_length, gtf_count, gtf_address); 436 437 if (gtf_length % REGS_PER_GTF) { 438 printk(KERN_ERR "%s: unexpected GTF length (%d)\n", 439 __FUNCTION__, gtf_length); 440 goto out; 441 } 442 443 rc = 0; 444 for (ix = 0; ix < gtf_count; ix++) { 445 gtf = (struct taskfile_array *) 446 (gtf_address + ix * REGS_PER_GTF); 447 448 /* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */ 449 err = taskfile_load_raw(drive, gtf); 450 if (err) 451 rc = err; 452 } 453 454out: 455 return rc; 456} 457 458/** 459 * ide_acpi_exec_tfs - get then write drive taskfile settings 460 * @drive: the drive for which the taskfile settings should be 461 * written. 462 * 463 * According to the ACPI spec this should be called after _STM 464 * has been evaluated for the interface. Some ACPI vendors interpret 465 * that as a hard requirement and modify the taskfile according 466 * to the Identify Drive information passed down with _STM. 467 * So one should really make sure to call this only after _STM has 468 * been executed. 469 */ 470int ide_acpi_exec_tfs(ide_drive_t *drive) 471{ 472 int ret; 473 unsigned int gtf_length; 474 unsigned long gtf_address; 475 unsigned long obj_loc; 476 477 if (ide_noacpi) 478 return 0; 479 480 DEBPRINT("call get_GTF, drive=%s port=%d\n", drive->name, drive->dn); 481 482 ret = do_drive_get_GTF(drive, >f_length, >f_address, &obj_loc); 483 if (ret < 0) { 484 DEBPRINT("get_GTF error (%d)\n", ret); 485 return ret; 486 } 487 488 DEBPRINT("call set_taskfiles, drive=%s\n", drive->name); 489 490 ret = do_drive_set_taskfiles(drive, gtf_length, gtf_address); 491 kfree((void *)obj_loc); 492 if (ret < 0) { 493 DEBPRINT("set_taskfiles error (%d)\n", ret); 494 } 495 496 DEBPRINT("ret=%d\n", ret); 497 498 return ret; 499} 500EXPORT_SYMBOL_GPL(ide_acpi_exec_tfs); 501 502/** 503 * ide_acpi_get_timing - get the channel (controller) timings 504 * @hwif: target IDE interface (channel) 505 * 506 * This function executes the _GTM ACPI method for the target channel. 507 * 508 */ 509void ide_acpi_get_timing(ide_hwif_t *hwif) 510{ 511 acpi_status status; 512 struct acpi_buffer output; 513 union acpi_object *out_obj; 514 515 if (ide_noacpi) 516 return; 517 518 DEBPRINT("ENTER:\n"); 519 520 if (!hwif->acpidata) { 521 DEBPRINT("no ACPI data for %s\n", hwif->name); 522 return; 523 } 524 525 /* Setting up output buffer for _GTM */ 526 output.length = ACPI_ALLOCATE_BUFFER; 527 output.pointer = NULL; /* ACPI-CA sets this; save/free it later */ 528 529 /* _GTM has no input parameters */ 530 status = acpi_evaluate_object(hwif->acpidata->obj_handle, "_GTM", 531 NULL, &output); 532 533 DEBPRINT("_GTM status: %d, outptr: 0x%p, outlen: 0x%llx\n", 534 status, output.pointer, 535 (unsigned long long)output.length); 536 537 if (ACPI_FAILURE(status)) { 538 DEBPRINT("Run _GTM error: status = 0x%x\n", status); 539 return; 540 } 541 542 if (!output.length || !output.pointer) { 543 DEBPRINT("Run _GTM: length or ptr is NULL (0x%llx, 0x%p)\n", 544 (unsigned long long)output.length, 545 output.pointer); 546 kfree(output.pointer); 547 return; 548 } 549 550 out_obj = output.pointer; 551 if (out_obj->type != ACPI_TYPE_BUFFER) { 552 kfree(output.pointer); 553 DEBPRINT("Run _GTM: error: " 554 "expected object type of ACPI_TYPE_BUFFER, " 555 "got 0x%x\n", out_obj->type); 556 return; 557 } 558 559 if (!out_obj->buffer.length || !out_obj->buffer.pointer || 560 out_obj->buffer.length != sizeof(struct GTM_buffer)) { 561 kfree(output.pointer); 562 printk(KERN_ERR 563 "%s: unexpected _GTM length (0x%x)[should be 0x%zx] or " 564 "addr (0x%p)\n", 565 __FUNCTION__, out_obj->buffer.length, 566 sizeof(struct GTM_buffer), out_obj->buffer.pointer); 567 return; 568 } 569 570 memcpy(&hwif->acpidata->gtm, out_obj->buffer.pointer, 571 sizeof(struct GTM_buffer)); 572 573 DEBPRINT("_GTM info: ptr: 0x%p, len: 0x%x, exp.len: 0x%Zx\n", 574 out_obj->buffer.pointer, out_obj->buffer.length, 575 sizeof(struct GTM_buffer)); 576 577 DEBPRINT("_GTM fields: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", 578 hwif->acpidata->gtm.PIO_speed0, 579 hwif->acpidata->gtm.DMA_speed0, 580 hwif->acpidata->gtm.PIO_speed1, 581 hwif->acpidata->gtm.DMA_speed1, 582 hwif->acpidata->gtm.GTM_flags); 583 584 kfree(output.pointer); 585} 586EXPORT_SYMBOL_GPL(ide_acpi_get_timing); 587 588/** 589 * ide_acpi_push_timing - set the channel (controller) timings 590 * @hwif: target IDE interface (channel) 591 * 592 * This function executes the _STM ACPI method for the target channel. 593 * 594 * _STM requires Identify Drive data, which has to passed as an argument. 595 * Unfortunately hd_driveid is a mangled version which we can't readily 596 * use; hence we'll get the information afresh. 597 */ 598void ide_acpi_push_timing(ide_hwif_t *hwif) 599{ 600 acpi_status status; 601 struct acpi_object_list input; 602 union acpi_object in_params[3]; 603 struct ide_acpi_drive_link *master = &hwif->acpidata->master; 604 struct ide_acpi_drive_link *slave = &hwif->acpidata->slave; 605 606 if (ide_noacpi) 607 return; 608 609 DEBPRINT("ENTER:\n"); 610 611 if (!hwif->acpidata) { 612 DEBPRINT("no ACPI data for %s\n", hwif->name); 613 return; 614 } 615 616 /* Give the GTM buffer + drive Identify data to the channel via the 617 * _STM method: */ 618 /* setup input parameters buffer for _STM */ 619 input.count = 3; 620 input.pointer = in_params; 621 in_params[0].type = ACPI_TYPE_BUFFER; 622 in_params[0].buffer.length = sizeof(struct GTM_buffer); 623 in_params[0].buffer.pointer = (u8 *)&hwif->acpidata->gtm; 624 in_params[1].type = ACPI_TYPE_BUFFER; 625 in_params[1].buffer.length = sizeof(struct hd_driveid); 626 in_params[1].buffer.pointer = (u8 *)&master->idbuff; 627 in_params[2].type = ACPI_TYPE_BUFFER; 628 in_params[2].buffer.length = sizeof(struct hd_driveid); 629 in_params[2].buffer.pointer = (u8 *)&slave->idbuff; 630 /* Output buffer: _STM has no output */ 631 632 status = acpi_evaluate_object(hwif->acpidata->obj_handle, "_STM", 633 &input, NULL); 634 635 if (ACPI_FAILURE(status)) { 636 DEBPRINT("Run _STM error: status = 0x%x\n", status); 637 } 638 DEBPRINT("_STM status: %d\n", status); 639} 640EXPORT_SYMBOL_GPL(ide_acpi_push_timing); 641 642/** 643 * ide_acpi_set_state - set the channel power state 644 * @hwif: target IDE interface 645 * @on: state, on/off 646 * 647 * This function executes the _PS0/_PS3 ACPI method to set the power state. 648 * ACPI spec requires _PS0 when IDE power on and _PS3 when power off 649 */ 650void ide_acpi_set_state(ide_hwif_t *hwif, int on) 651{ 652 int unit; 653 654 if (ide_noacpi || ide_noacpi_psx) 655 return; 656 657 DEBPRINT("ENTER:\n"); 658 659 if (!hwif->acpidata) { 660 DEBPRINT("no ACPI data for %s\n", hwif->name); 661 return; 662 } 663 /* channel first and then drives for power on and verse versa for power off */ 664 if (on) 665 acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D0); 666 for (unit = 0; unit < MAX_DRIVES; ++unit) { 667 ide_drive_t *drive = &hwif->drives[unit]; 668 669 if (!drive->acpidata->obj_handle) 670 drive->acpidata->obj_handle = ide_acpi_drive_get_handle(drive); 671 672 if (drive->acpidata->obj_handle && drive->present) { 673 acpi_bus_set_power(drive->acpidata->obj_handle, 674 on? ACPI_STATE_D0: ACPI_STATE_D3); 675 } 676 } 677 if (!on) 678 acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D3); 679} 680 681/** 682 * ide_acpi_init - initialize the ACPI link for an IDE interface 683 * @hwif: target IDE interface (channel) 684 * 685 * The ACPI spec is not quite clear when the drive identify buffer 686 * should be obtained. Calling IDENTIFY DEVICE during shutdown 687 * is not the best of ideas as the drive might already being put to 688 * sleep. And obviously we can't call it during resume. 689 * So we get the information during startup; but this means that 690 * any changes during run-time will be lost after resume. 691 */ 692void ide_acpi_init(ide_hwif_t *hwif) 693{ 694 int unit; 695 int err; 696 struct ide_acpi_drive_link *master; 697 struct ide_acpi_drive_link *slave; 698 699 ide_acpi_blacklist(); 700 701 hwif->acpidata = kzalloc(sizeof(struct ide_acpi_hwif_link), GFP_KERNEL); 702 if (!hwif->acpidata) 703 return; 704 705 hwif->acpidata->obj_handle = ide_acpi_hwif_get_handle(hwif); 706 if (!hwif->acpidata->obj_handle) { 707 DEBPRINT("no ACPI object for %s found\n", hwif->name); 708 kfree(hwif->acpidata); 709 hwif->acpidata = NULL; 710 return; 711 } 712 713 /* 714 * The ACPI spec mandates that we send information 715 * for both drives, regardless whether they are connected 716 * or not. 717 */ 718 hwif->acpidata->master.drive = &hwif->drives[0]; 719 hwif->drives[0].acpidata = &hwif->acpidata->master; 720 master = &hwif->acpidata->master; 721 722 hwif->acpidata->slave.drive = &hwif->drives[1]; 723 hwif->drives[1].acpidata = &hwif->acpidata->slave; 724 slave = &hwif->acpidata->slave; 725 726 727 /* 728 * Send IDENTIFY for each drive 729 */ 730 if (master->drive->present) { 731 err = taskfile_lib_get_identify(master->drive, master->idbuff); 732 if (err) { 733 DEBPRINT("identify device %s failed (%d)\n", 734 master->drive->name, err); 735 } 736 } 737 738 if (slave->drive->present) { 739 err = taskfile_lib_get_identify(slave->drive, slave->idbuff); 740 if (err) { 741 DEBPRINT("identify device %s failed (%d)\n", 742 slave->drive->name, err); 743 } 744 } 745 746 if (ide_noacpionboot) { 747 DEBPRINT("ACPI methods disabled on boot\n"); 748 return; 749 } 750 751 /* ACPI _PS0 before _STM */ 752 ide_acpi_set_state(hwif, 1); 753 /* 754 * ACPI requires us to call _STM on startup 755 */ 756 ide_acpi_get_timing(hwif); 757 ide_acpi_push_timing(hwif); 758 759 for (unit = 0; unit < MAX_DRIVES; ++unit) { 760 ide_drive_t *drive = &hwif->drives[unit]; 761 762 if (drive->present) { 763 /* Execute ACPI startup code */ 764 ide_acpi_exec_tfs(drive); 765 } 766 } 767} 768EXPORT_SYMBOL_GPL(ide_acpi_init); 769