ide-acpi.c revision 9a3c49be5c5f7388eefb712be9a383904140532e
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 387 /* convert gtf to IDE Taskfile */ 388 memcpy(&args.tf_array[7], >f->tfa, 7); 389 390 if (ide_noacpitfs) { 391 DEBPRINT("_GTF execution disabled\n"); 392 return err; 393 } 394 395 err = ide_no_data_taskfile(drive, &args); 396 if (err) 397 printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n", 398 __FUNCTION__, err); 399 400 return err; 401} 402 403/** 404 * do_drive_set_taskfiles - write the drive taskfile settings from _GTF 405 * @drive: the drive to which the taskfile command should be sent 406 * @gtf_length: total number of bytes of _GTF taskfiles 407 * @gtf_address: location of _GTF taskfile arrays 408 * 409 * Write {gtf_address, length gtf_length} in groups of 410 * REGS_PER_GTF bytes. 411 */ 412static int do_drive_set_taskfiles(ide_drive_t *drive, 413 unsigned int gtf_length, 414 unsigned long gtf_address) 415{ 416 int rc = -ENODEV, err; 417 int gtf_count = gtf_length / REGS_PER_GTF; 418 int ix; 419 struct taskfile_array *gtf; 420 421 if (ide_noacpi) 422 return 0; 423 424 DEBPRINT("ENTER: %s, hard_port#: %d\n", drive->name, drive->dn); 425 426 if (!drive->present) 427 goto out; 428 if (!gtf_count) /* shouldn't be here */ 429 goto out; 430 431 DEBPRINT("total GTF bytes=%u (0x%x), gtf_count=%d, addr=0x%lx\n", 432 gtf_length, gtf_length, gtf_count, gtf_address); 433 434 if (gtf_length % REGS_PER_GTF) { 435 printk(KERN_ERR "%s: unexpected GTF length (%d)\n", 436 __FUNCTION__, gtf_length); 437 goto out; 438 } 439 440 rc = 0; 441 for (ix = 0; ix < gtf_count; ix++) { 442 gtf = (struct taskfile_array *) 443 (gtf_address + ix * REGS_PER_GTF); 444 445 /* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */ 446 err = taskfile_load_raw(drive, gtf); 447 if (err) 448 rc = err; 449 } 450 451out: 452 return rc; 453} 454 455/** 456 * ide_acpi_exec_tfs - get then write drive taskfile settings 457 * @drive: the drive for which the taskfile settings should be 458 * written. 459 * 460 * According to the ACPI spec this should be called after _STM 461 * has been evaluated for the interface. Some ACPI vendors interpret 462 * that as a hard requirement and modify the taskfile according 463 * to the Identify Drive information passed down with _STM. 464 * So one should really make sure to call this only after _STM has 465 * been executed. 466 */ 467int ide_acpi_exec_tfs(ide_drive_t *drive) 468{ 469 int ret; 470 unsigned int gtf_length; 471 unsigned long gtf_address; 472 unsigned long obj_loc; 473 474 if (ide_noacpi) 475 return 0; 476 477 DEBPRINT("call get_GTF, drive=%s port=%d\n", drive->name, drive->dn); 478 479 ret = do_drive_get_GTF(drive, >f_length, >f_address, &obj_loc); 480 if (ret < 0) { 481 DEBPRINT("get_GTF error (%d)\n", ret); 482 return ret; 483 } 484 485 DEBPRINT("call set_taskfiles, drive=%s\n", drive->name); 486 487 ret = do_drive_set_taskfiles(drive, gtf_length, gtf_address); 488 kfree((void *)obj_loc); 489 if (ret < 0) { 490 DEBPRINT("set_taskfiles error (%d)\n", ret); 491 } 492 493 DEBPRINT("ret=%d\n", ret); 494 495 return ret; 496} 497EXPORT_SYMBOL_GPL(ide_acpi_exec_tfs); 498 499/** 500 * ide_acpi_get_timing - get the channel (controller) timings 501 * @hwif: target IDE interface (channel) 502 * 503 * This function executes the _GTM ACPI method for the target channel. 504 * 505 */ 506void ide_acpi_get_timing(ide_hwif_t *hwif) 507{ 508 acpi_status status; 509 struct acpi_buffer output; 510 union acpi_object *out_obj; 511 512 if (ide_noacpi) 513 return; 514 515 DEBPRINT("ENTER:\n"); 516 517 if (!hwif->acpidata) { 518 DEBPRINT("no ACPI data for %s\n", hwif->name); 519 return; 520 } 521 522 /* Setting up output buffer for _GTM */ 523 output.length = ACPI_ALLOCATE_BUFFER; 524 output.pointer = NULL; /* ACPI-CA sets this; save/free it later */ 525 526 /* _GTM has no input parameters */ 527 status = acpi_evaluate_object(hwif->acpidata->obj_handle, "_GTM", 528 NULL, &output); 529 530 DEBPRINT("_GTM status: %d, outptr: 0x%p, outlen: 0x%llx\n", 531 status, output.pointer, 532 (unsigned long long)output.length); 533 534 if (ACPI_FAILURE(status)) { 535 DEBPRINT("Run _GTM error: status = 0x%x\n", status); 536 return; 537 } 538 539 if (!output.length || !output.pointer) { 540 DEBPRINT("Run _GTM: length or ptr is NULL (0x%llx, 0x%p)\n", 541 (unsigned long long)output.length, 542 output.pointer); 543 kfree(output.pointer); 544 return; 545 } 546 547 out_obj = output.pointer; 548 if (out_obj->type != ACPI_TYPE_BUFFER) { 549 kfree(output.pointer); 550 DEBPRINT("Run _GTM: error: " 551 "expected object type of ACPI_TYPE_BUFFER, " 552 "got 0x%x\n", out_obj->type); 553 return; 554 } 555 556 if (!out_obj->buffer.length || !out_obj->buffer.pointer || 557 out_obj->buffer.length != sizeof(struct GTM_buffer)) { 558 kfree(output.pointer); 559 printk(KERN_ERR 560 "%s: unexpected _GTM length (0x%x)[should be 0x%zx] or " 561 "addr (0x%p)\n", 562 __FUNCTION__, out_obj->buffer.length, 563 sizeof(struct GTM_buffer), out_obj->buffer.pointer); 564 return; 565 } 566 567 memcpy(&hwif->acpidata->gtm, out_obj->buffer.pointer, 568 sizeof(struct GTM_buffer)); 569 570 DEBPRINT("_GTM info: ptr: 0x%p, len: 0x%x, exp.len: 0x%Zx\n", 571 out_obj->buffer.pointer, out_obj->buffer.length, 572 sizeof(struct GTM_buffer)); 573 574 DEBPRINT("_GTM fields: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", 575 hwif->acpidata->gtm.PIO_speed0, 576 hwif->acpidata->gtm.DMA_speed0, 577 hwif->acpidata->gtm.PIO_speed1, 578 hwif->acpidata->gtm.DMA_speed1, 579 hwif->acpidata->gtm.GTM_flags); 580 581 kfree(output.pointer); 582} 583EXPORT_SYMBOL_GPL(ide_acpi_get_timing); 584 585/** 586 * ide_acpi_push_timing - set the channel (controller) timings 587 * @hwif: target IDE interface (channel) 588 * 589 * This function executes the _STM ACPI method for the target channel. 590 * 591 * _STM requires Identify Drive data, which has to passed as an argument. 592 * Unfortunately hd_driveid is a mangled version which we can't readily 593 * use; hence we'll get the information afresh. 594 */ 595void ide_acpi_push_timing(ide_hwif_t *hwif) 596{ 597 acpi_status status; 598 struct acpi_object_list input; 599 union acpi_object in_params[3]; 600 struct ide_acpi_drive_link *master = &hwif->acpidata->master; 601 struct ide_acpi_drive_link *slave = &hwif->acpidata->slave; 602 603 if (ide_noacpi) 604 return; 605 606 DEBPRINT("ENTER:\n"); 607 608 if (!hwif->acpidata) { 609 DEBPRINT("no ACPI data for %s\n", hwif->name); 610 return; 611 } 612 613 /* Give the GTM buffer + drive Identify data to the channel via the 614 * _STM method: */ 615 /* setup input parameters buffer for _STM */ 616 input.count = 3; 617 input.pointer = in_params; 618 in_params[0].type = ACPI_TYPE_BUFFER; 619 in_params[0].buffer.length = sizeof(struct GTM_buffer); 620 in_params[0].buffer.pointer = (u8 *)&hwif->acpidata->gtm; 621 in_params[1].type = ACPI_TYPE_BUFFER; 622 in_params[1].buffer.length = sizeof(struct hd_driveid); 623 in_params[1].buffer.pointer = (u8 *)&master->idbuff; 624 in_params[2].type = ACPI_TYPE_BUFFER; 625 in_params[2].buffer.length = sizeof(struct hd_driveid); 626 in_params[2].buffer.pointer = (u8 *)&slave->idbuff; 627 /* Output buffer: _STM has no output */ 628 629 status = acpi_evaluate_object(hwif->acpidata->obj_handle, "_STM", 630 &input, NULL); 631 632 if (ACPI_FAILURE(status)) { 633 DEBPRINT("Run _STM error: status = 0x%x\n", status); 634 } 635 DEBPRINT("_STM status: %d\n", status); 636} 637EXPORT_SYMBOL_GPL(ide_acpi_push_timing); 638 639/** 640 * ide_acpi_set_state - set the channel power state 641 * @hwif: target IDE interface 642 * @on: state, on/off 643 * 644 * This function executes the _PS0/_PS3 ACPI method to set the power state. 645 * ACPI spec requires _PS0 when IDE power on and _PS3 when power off 646 */ 647void ide_acpi_set_state(ide_hwif_t *hwif, int on) 648{ 649 int unit; 650 651 if (ide_noacpi || ide_noacpi_psx) 652 return; 653 654 DEBPRINT("ENTER:\n"); 655 656 if (!hwif->acpidata) { 657 DEBPRINT("no ACPI data for %s\n", hwif->name); 658 return; 659 } 660 /* channel first and then drives for power on and verse versa for power off */ 661 if (on) 662 acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D0); 663 for (unit = 0; unit < MAX_DRIVES; ++unit) { 664 ide_drive_t *drive = &hwif->drives[unit]; 665 666 if (!drive->acpidata->obj_handle) 667 drive->acpidata->obj_handle = ide_acpi_drive_get_handle(drive); 668 669 if (drive->acpidata->obj_handle && drive->present) { 670 acpi_bus_set_power(drive->acpidata->obj_handle, 671 on? ACPI_STATE_D0: ACPI_STATE_D3); 672 } 673 } 674 if (!on) 675 acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D3); 676} 677 678/** 679 * ide_acpi_init - initialize the ACPI link for an IDE interface 680 * @hwif: target IDE interface (channel) 681 * 682 * The ACPI spec is not quite clear when the drive identify buffer 683 * should be obtained. Calling IDENTIFY DEVICE during shutdown 684 * is not the best of ideas as the drive might already being put to 685 * sleep. And obviously we can't call it during resume. 686 * So we get the information during startup; but this means that 687 * any changes during run-time will be lost after resume. 688 */ 689void ide_acpi_init(ide_hwif_t *hwif) 690{ 691 int unit; 692 int err; 693 struct ide_acpi_drive_link *master; 694 struct ide_acpi_drive_link *slave; 695 696 ide_acpi_blacklist(); 697 698 hwif->acpidata = kzalloc(sizeof(struct ide_acpi_hwif_link), GFP_KERNEL); 699 if (!hwif->acpidata) 700 return; 701 702 hwif->acpidata->obj_handle = ide_acpi_hwif_get_handle(hwif); 703 if (!hwif->acpidata->obj_handle) { 704 DEBPRINT("no ACPI object for %s found\n", hwif->name); 705 kfree(hwif->acpidata); 706 hwif->acpidata = NULL; 707 return; 708 } 709 710 /* 711 * The ACPI spec mandates that we send information 712 * for both drives, regardless whether they are connected 713 * or not. 714 */ 715 hwif->acpidata->master.drive = &hwif->drives[0]; 716 hwif->drives[0].acpidata = &hwif->acpidata->master; 717 master = &hwif->acpidata->master; 718 719 hwif->acpidata->slave.drive = &hwif->drives[1]; 720 hwif->drives[1].acpidata = &hwif->acpidata->slave; 721 slave = &hwif->acpidata->slave; 722 723 724 /* 725 * Send IDENTIFY for each drive 726 */ 727 if (master->drive->present) { 728 err = taskfile_lib_get_identify(master->drive, master->idbuff); 729 if (err) { 730 DEBPRINT("identify device %s failed (%d)\n", 731 master->drive->name, err); 732 } 733 } 734 735 if (slave->drive->present) { 736 err = taskfile_lib_get_identify(slave->drive, slave->idbuff); 737 if (err) { 738 DEBPRINT("identify device %s failed (%d)\n", 739 slave->drive->name, err); 740 } 741 } 742 743 if (ide_noacpionboot) { 744 DEBPRINT("ACPI methods disabled on boot\n"); 745 return; 746 } 747 748 /* ACPI _PS0 before _STM */ 749 ide_acpi_set_state(hwif, 1); 750 /* 751 * ACPI requires us to call _STM on startup 752 */ 753 ide_acpi_get_timing(hwif); 754 ide_acpi_push_timing(hwif); 755 756 for (unit = 0; unit < MAX_DRIVES; ++unit) { 757 ide_drive_t *drive = &hwif->drives[unit]; 758 759 if (drive->present) { 760 /* Execute ACPI startup code */ 761 ide_acpi_exec_tfs(drive); 762 } 763 } 764} 765EXPORT_SYMBOL_GPL(ide_acpi_init); 766