ide.c revision 5d682e4407d8364c286650baafcccae54d4b7c89
1/* 2 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below) 3 * Copyrifht (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz 4 */ 5 6/* 7 * Mostly written by Mark Lord <mlord@pobox.com> 8 * and Gadi Oxman <gadio@netvision.net.il> 9 * and Andre Hedrick <andre@linux-ide.org> 10 * 11 * See linux/MAINTAINERS for address of current maintainer. 12 * 13 * This is the multiple IDE interface driver, as evolved from hd.c. 14 * It supports up to MAX_HWIFS IDE interfaces, on one or more IRQs 15 * (usually 14 & 15). 16 * There can be up to two drives per interface, as per the ATA-2 spec. 17 * 18 * ... 19 * 20 * From hd.c: 21 * | 22 * | It traverses the request-list, using interrupts to jump between functions. 23 * | As nearly all functions can be called within interrupts, we may not sleep. 24 * | Special care is recommended. Have Fun! 25 * | 26 * | modified by Drew Eckhardt to check nr of hd's from the CMOS. 27 * | 28 * | Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug 29 * | in the early extended-partition checks and added DM partitions. 30 * | 31 * | Early work on error handling by Mika Liljeberg (liljeber@cs.Helsinki.FI). 32 * | 33 * | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads", 34 * | and general streamlining by Mark Lord (mlord@pobox.com). 35 * 36 * October, 1994 -- Complete line-by-line overhaul for linux 1.1.x, by: 37 * 38 * Mark Lord (mlord@pobox.com) (IDE Perf.Pkg) 39 * Delman Lee (delman@ieee.org) ("Mr. atdisk2") 40 * Scott Snyder (snyder@fnald0.fnal.gov) (ATAPI IDE cd-rom) 41 * 42 * This was a rewrite of just about everything from hd.c, though some original 43 * code is still sprinkled about. Think of it as a major evolution, with 44 * inspiration from lots of linux users, esp. hamish@zot.apana.org.au 45 */ 46 47#define _IDE_C /* Tell ide.h it's really us */ 48 49#include <linux/module.h> 50#include <linux/types.h> 51#include <linux/string.h> 52#include <linux/kernel.h> 53#include <linux/timer.h> 54#include <linux/mm.h> 55#include <linux/interrupt.h> 56#include <linux/major.h> 57#include <linux/errno.h> 58#include <linux/genhd.h> 59#include <linux/blkpg.h> 60#include <linux/slab.h> 61#include <linux/init.h> 62#include <linux/pci.h> 63#include <linux/delay.h> 64#include <linux/ide.h> 65#include <linux/completion.h> 66#include <linux/reboot.h> 67#include <linux/cdrom.h> 68#include <linux/seq_file.h> 69#include <linux/device.h> 70#include <linux/bitops.h> 71 72#include <asm/byteorder.h> 73#include <asm/irq.h> 74#include <asm/uaccess.h> 75#include <asm/io.h> 76 77 78/* default maximum number of failures */ 79#define IDE_DEFAULT_MAX_FAILURES 1 80 81struct class *ide_port_class; 82 83static const u8 ide_hwif_to_major[] = { IDE0_MAJOR, IDE1_MAJOR, 84 IDE2_MAJOR, IDE3_MAJOR, 85 IDE4_MAJOR, IDE5_MAJOR, 86 IDE6_MAJOR, IDE7_MAJOR, 87 IDE8_MAJOR, IDE9_MAJOR }; 88 89static int idebus_parameter; /* holds the "idebus=" parameter */ 90static int system_bus_speed; /* holds what we think is VESA/PCI bus speed */ 91 92DEFINE_MUTEX(ide_cfg_mtx); 93 __cacheline_aligned_in_smp DEFINE_SPINLOCK(ide_lock); 94 95int noautodma = 0; 96 97#ifdef CONFIG_BLK_DEV_IDEACPI 98int ide_noacpi = 0; 99int ide_noacpitfs = 1; 100int ide_noacpionboot = 1; 101#endif 102 103/* 104 * This is declared extern in ide.h, for access by other IDE modules: 105 */ 106ide_hwif_t ide_hwifs[MAX_HWIFS]; /* master data repository */ 107 108EXPORT_SYMBOL(ide_hwifs); 109 110static void ide_port_init_devices_data(ide_hwif_t *); 111 112/* 113 * Do not even *think* about calling this! 114 */ 115void ide_init_port_data(ide_hwif_t *hwif, unsigned int index) 116{ 117 /* bulk initialize hwif & drive info with zeros */ 118 memset(hwif, 0, sizeof(ide_hwif_t)); 119 120 /* fill in any non-zero initial values */ 121 hwif->index = index; 122 hwif->major = ide_hwif_to_major[index]; 123 124 hwif->name[0] = 'i'; 125 hwif->name[1] = 'd'; 126 hwif->name[2] = 'e'; 127 hwif->name[3] = '0' + index; 128 129 hwif->bus_state = BUSSTATE_ON; 130 131 init_completion(&hwif->gendev_rel_comp); 132 133 default_hwif_iops(hwif); 134 default_hwif_transport(hwif); 135 136 ide_port_init_devices_data(hwif); 137} 138EXPORT_SYMBOL_GPL(ide_init_port_data); 139 140static void ide_port_init_devices_data(ide_hwif_t *hwif) 141{ 142 int unit; 143 144 for (unit = 0; unit < MAX_DRIVES; ++unit) { 145 ide_drive_t *drive = &hwif->drives[unit]; 146 u8 j = (hwif->index * MAX_DRIVES) + unit; 147 148 memset(drive, 0, sizeof(*drive)); 149 150 drive->media = ide_disk; 151 drive->select.all = (unit<<4)|0xa0; 152 drive->hwif = hwif; 153 drive->ctl = 0x08; 154 drive->ready_stat = READY_STAT; 155 drive->bad_wstat = BAD_W_STAT; 156 drive->special.b.recalibrate = 1; 157 drive->special.b.set_geometry = 1; 158 drive->name[0] = 'h'; 159 drive->name[1] = 'd'; 160 drive->name[2] = 'a' + j; 161 drive->max_failures = IDE_DEFAULT_MAX_FAILURES; 162 163 INIT_LIST_HEAD(&drive->list); 164 init_completion(&drive->gendev_rel_comp); 165 } 166} 167 168 169/* 170 * init_ide_data() sets reasonable default values into all fields 171 * of all instances of the hwifs and drives, but only on the first call. 172 * Subsequent calls have no effect (they don't wipe out anything). 173 * 174 * This routine is normally called at driver initialization time, 175 * but may also be called MUCH earlier during kernel "command-line" 176 * parameter processing. As such, we cannot depend on any other parts 177 * of the kernel (such as memory allocation) to be functioning yet. 178 * 179 * This is too bad, as otherwise we could dynamically allocate the 180 * ide_drive_t structs as needed, rather than always consuming memory 181 * for the max possible number (MAX_HWIFS * MAX_DRIVES) of them. 182 * 183 * FIXME: We should stuff the setup data into __init and copy the 184 * relevant hwifs/allocate them properly during boot. 185 */ 186#define MAGIC_COOKIE 0x12345678 187static void __init init_ide_data (void) 188{ 189 unsigned int index; 190 static unsigned long magic_cookie = MAGIC_COOKIE; 191 hw_regs_t hw; 192 193 if (magic_cookie != MAGIC_COOKIE) 194 return; /* already initialized */ 195 magic_cookie = 0; 196 197 /* Initialise all interface structures */ 198 for (index = 0; index < MAX_HWIFS; ++index) { 199 ide_hwif_t *hwif = &ide_hwifs[index]; 200 unsigned long io_addr = ide_default_io_base(index); 201 unsigned long ctl_addr = ide_default_io_ctl(io_addr); 202 203 ide_init_port_data(hwif, index); 204 205#ifdef CONFIG_IDE_ARCH_OBSOLETE_INIT 206 memset(&hw, 0, sizeof(hw)); 207 ide_std_init_ports(&hw, io_addr, ctl_addr); 208# ifdef CONFIG_PPC32 209 if (ppc_ide_md.ide_init_hwif) 210 ppc_ide_md.ide_init_hwif(&hw, io_addr, 0, &hwif->irq); 211# endif 212 memcpy(hwif->io_ports, hw.io_ports, sizeof(hw.io_ports)); 213#endif 214 hwif->noprobe = !hwif->io_ports[IDE_DATA_OFFSET]; 215#if !defined(CONFIG_PPC32) || defined(CONFIG_PPLUS) || !defined(CONFIG_PCI) 216 hwif->irq = 217 ide_init_default_irq(hwif->io_ports[IDE_DATA_OFFSET]); 218#endif 219 } 220} 221 222/** 223 * ide_system_bus_speed - guess bus speed 224 * 225 * ide_system_bus_speed() returns what we think is the system VESA/PCI 226 * bus speed (in MHz). This is used for calculating interface PIO timings. 227 * The default is 40 for known PCI systems, 50 otherwise. 228 * The "idebus=xx" parameter can be used to override this value. 229 * The actual value to be used is computed/displayed the first time 230 * through. Drivers should only use this as a last resort. 231 * 232 * Returns a guessed speed in MHz. 233 */ 234 235static int ide_system_bus_speed(void) 236{ 237#ifdef CONFIG_PCI 238 static struct pci_device_id pci_default[] = { 239 { PCI_DEVICE(PCI_ANY_ID, PCI_ANY_ID) }, 240 { } 241 }; 242#else 243#define pci_default 0 244#endif /* CONFIG_PCI */ 245 246 /* user supplied value */ 247 if (idebus_parameter) 248 return idebus_parameter; 249 250 /* safe default value for PCI or VESA and PCI*/ 251 return pci_dev_present(pci_default) ? 33 : 50; 252} 253 254ide_hwif_t * ide_find_port(unsigned long base) 255{ 256 ide_hwif_t *hwif; 257 int i; 258 259 for (i = 0; i < MAX_HWIFS; i++) { 260 hwif = &ide_hwifs[i]; 261 if (hwif->io_ports[IDE_DATA_OFFSET] == base) 262 goto found; 263 } 264 265 for (i = 0; i < MAX_HWIFS; i++) { 266 hwif = &ide_hwifs[i]; 267 if (hwif->chipset == ide_unknown) 268 goto found; 269 } 270 271 hwif = NULL; 272found: 273 return hwif; 274} 275 276EXPORT_SYMBOL_GPL(ide_find_port); 277 278static struct resource* hwif_request_region(ide_hwif_t *hwif, 279 unsigned long addr, int num) 280{ 281 struct resource *res = request_region(addr, num, hwif->name); 282 283 if (!res) 284 printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n", 285 hwif->name, addr, addr+num-1); 286 return res; 287} 288 289/** 290 * ide_hwif_request_regions - request resources for IDE 291 * @hwif: interface to use 292 * 293 * Requests all the needed resources for an interface. 294 * Right now core IDE code does this work which is deeply wrong. 295 * MMIO leaves it to the controller driver, 296 * PIO will migrate this way over time. 297 */ 298 299int ide_hwif_request_regions(ide_hwif_t *hwif) 300{ 301 unsigned long addr; 302 unsigned int i; 303 304 if (hwif->mmio) 305 return 0; 306 addr = hwif->io_ports[IDE_CONTROL_OFFSET]; 307 if (addr && !hwif_request_region(hwif, addr, 1)) 308 goto control_region_busy; 309 hwif->straight8 = 0; 310 addr = hwif->io_ports[IDE_DATA_OFFSET]; 311 if ((addr | 7) == hwif->io_ports[IDE_STATUS_OFFSET]) { 312 if (!hwif_request_region(hwif, addr, 8)) 313 goto data_region_busy; 314 hwif->straight8 = 1; 315 return 0; 316 } 317 for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) { 318 addr = hwif->io_ports[i]; 319 if (!hwif_request_region(hwif, addr, 1)) { 320 while (--i) 321 release_region(addr, 1); 322 goto data_region_busy; 323 } 324 } 325 return 0; 326 327data_region_busy: 328 addr = hwif->io_ports[IDE_CONTROL_OFFSET]; 329 if (addr) 330 release_region(addr, 1); 331control_region_busy: 332 /* If any errors are return, we drop the hwif interface. */ 333 return -EBUSY; 334} 335 336/** 337 * ide_hwif_release_regions - free IDE resources 338 * 339 * Note that we only release the standard ports, 340 * and do not even try to handle any extra ports 341 * allocated for weird IDE interface chipsets. 342 * 343 * Note also that we don't yet handle mmio resources here. More 344 * importantly our caller should be doing this so we need to 345 * restructure this as a helper function for drivers. 346 */ 347 348void ide_hwif_release_regions(ide_hwif_t *hwif) 349{ 350 u32 i = 0; 351 352 if (hwif->mmio) 353 return; 354 if (hwif->io_ports[IDE_CONTROL_OFFSET]) 355 release_region(hwif->io_ports[IDE_CONTROL_OFFSET], 1); 356 if (hwif->straight8) { 357 release_region(hwif->io_ports[IDE_DATA_OFFSET], 8); 358 return; 359 } 360 for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) 361 if (hwif->io_ports[i]) 362 release_region(hwif->io_ports[i], 1); 363} 364 365void ide_remove_port_from_hwgroup(ide_hwif_t *hwif) 366{ 367 ide_hwgroup_t *hwgroup = hwif->hwgroup; 368 369 spin_lock_irq(&ide_lock); 370 /* 371 * Remove us from the hwgroup, and free 372 * the hwgroup if we were the only member 373 */ 374 if (hwif->next == hwif) { 375 BUG_ON(hwgroup->hwif != hwif); 376 kfree(hwgroup); 377 } else { 378 /* There is another interface in hwgroup. 379 * Unlink us, and set hwgroup->drive and ->hwif to 380 * something sane. 381 */ 382 ide_hwif_t *g = hwgroup->hwif; 383 384 while (g->next != hwif) 385 g = g->next; 386 g->next = hwif->next; 387 if (hwgroup->hwif == hwif) { 388 /* Chose a random hwif for hwgroup->hwif. 389 * It's guaranteed that there are no drives 390 * left in the hwgroup. 391 */ 392 BUG_ON(hwgroup->drive != NULL); 393 hwgroup->hwif = g; 394 } 395 BUG_ON(hwgroup->hwif == hwif); 396 } 397 spin_unlock_irq(&ide_lock); 398} 399 400/* Called with ide_lock held. */ 401static void __ide_port_unregister_devices(ide_hwif_t *hwif) 402{ 403 int i; 404 405 for (i = 0; i < MAX_DRIVES; i++) { 406 ide_drive_t *drive = &hwif->drives[i]; 407 408 if (drive->present) { 409 spin_unlock_irq(&ide_lock); 410 device_unregister(&drive->gendev); 411 wait_for_completion(&drive->gendev_rel_comp); 412 spin_lock_irq(&ide_lock); 413 } 414 } 415} 416 417void ide_port_unregister_devices(ide_hwif_t *hwif) 418{ 419 mutex_lock(&ide_cfg_mtx); 420 spin_lock_irq(&ide_lock); 421 __ide_port_unregister_devices(hwif); 422 hwif->present = 0; 423 ide_port_init_devices_data(hwif); 424 spin_unlock_irq(&ide_lock); 425 mutex_unlock(&ide_cfg_mtx); 426} 427EXPORT_SYMBOL_GPL(ide_port_unregister_devices); 428 429/** 430 * ide_unregister - free an IDE interface 431 * @index: index of interface (will change soon to a pointer) 432 * 433 * Perform the final unregister of an IDE interface. At the moment 434 * we don't refcount interfaces so this will also get split up. 435 * 436 * Locking: 437 * The caller must not hold the IDE locks 438 * The drive present/vanishing is not yet properly locked 439 * Take care with the callbacks. These have been split to avoid 440 * deadlocking the IDE layer. The shutdown callback is called 441 * before we take the lock and free resources. It is up to the 442 * caller to be sure there is no pending I/O here, and that 443 * the interface will not be reopened (present/vanishing locking 444 * isn't yet done BTW). After we commit to the final kill we 445 * call the cleanup callback with the ide locks held. 446 * 447 * Unregister restores the hwif structures to the default state. 448 * This is raving bonkers. 449 */ 450 451void ide_unregister(unsigned int index) 452{ 453 ide_hwif_t *hwif, *g; 454 ide_hwgroup_t *hwgroup; 455 int irq_count = 0; 456 457 BUG_ON(index >= MAX_HWIFS); 458 459 BUG_ON(in_interrupt()); 460 BUG_ON(irqs_disabled()); 461 mutex_lock(&ide_cfg_mtx); 462 spin_lock_irq(&ide_lock); 463 hwif = &ide_hwifs[index]; 464 if (!hwif->present) 465 goto abort; 466 __ide_port_unregister_devices(hwif); 467 hwif->present = 0; 468 469 spin_unlock_irq(&ide_lock); 470 471 ide_proc_unregister_port(hwif); 472 473 hwgroup = hwif->hwgroup; 474 /* 475 * free the irq if we were the only hwif using it 476 */ 477 g = hwgroup->hwif; 478 do { 479 if (g->irq == hwif->irq) 480 ++irq_count; 481 g = g->next; 482 } while (g != hwgroup->hwif); 483 if (irq_count == 1) 484 free_irq(hwif->irq, hwgroup); 485 486 ide_remove_port_from_hwgroup(hwif); 487 488 device_unregister(hwif->portdev); 489 device_unregister(&hwif->gendev); 490 wait_for_completion(&hwif->gendev_rel_comp); 491 492 /* 493 * Remove us from the kernel's knowledge 494 */ 495 blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS); 496 kfree(hwif->sg_table); 497 unregister_blkdev(hwif->major, hwif->name); 498 spin_lock_irq(&ide_lock); 499 500 if (hwif->dma_base) 501 (void)ide_release_dma(hwif); 502 503 ide_hwif_release_regions(hwif); 504 505 /* restore hwif data to pristine status */ 506 ide_init_port_data(hwif, index); 507 508abort: 509 spin_unlock_irq(&ide_lock); 510 mutex_unlock(&ide_cfg_mtx); 511} 512 513EXPORT_SYMBOL(ide_unregister); 514 515void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw) 516{ 517 memcpy(hwif->io_ports, hw->io_ports, sizeof(hwif->io_ports)); 518 hwif->irq = hw->irq; 519 hwif->noprobe = 0; 520 hwif->chipset = hw->chipset; 521 hwif->gendev.parent = hw->dev; 522 hwif->ack_intr = hw->ack_intr; 523} 524EXPORT_SYMBOL_GPL(ide_init_port_hw); 525 526/* 527 * Locks for IDE setting functionality 528 */ 529 530DEFINE_MUTEX(ide_setting_mtx); 531 532EXPORT_SYMBOL_GPL(ide_setting_mtx); 533 534/** 535 * ide_spin_wait_hwgroup - wait for group 536 * @drive: drive in the group 537 * 538 * Wait for an IDE device group to go non busy and then return 539 * holding the ide_lock which guards the hwgroup->busy status 540 * and right to use it. 541 */ 542 543int ide_spin_wait_hwgroup (ide_drive_t *drive) 544{ 545 ide_hwgroup_t *hwgroup = HWGROUP(drive); 546 unsigned long timeout = jiffies + (3 * HZ); 547 548 spin_lock_irq(&ide_lock); 549 550 while (hwgroup->busy) { 551 unsigned long lflags; 552 spin_unlock_irq(&ide_lock); 553 local_irq_set(lflags); 554 if (time_after(jiffies, timeout)) { 555 local_irq_restore(lflags); 556 printk(KERN_ERR "%s: channel busy\n", drive->name); 557 return -EBUSY; 558 } 559 local_irq_restore(lflags); 560 spin_lock_irq(&ide_lock); 561 } 562 return 0; 563} 564 565EXPORT_SYMBOL(ide_spin_wait_hwgroup); 566 567int set_io_32bit(ide_drive_t *drive, int arg) 568{ 569 if (drive->no_io_32bit) 570 return -EPERM; 571 572 if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1)) 573 return -EINVAL; 574 575 if (ide_spin_wait_hwgroup(drive)) 576 return -EBUSY; 577 578 drive->io_32bit = arg; 579 580 spin_unlock_irq(&ide_lock); 581 582 return 0; 583} 584 585static int set_ksettings(ide_drive_t *drive, int arg) 586{ 587 if (arg < 0 || arg > 1) 588 return -EINVAL; 589 590 if (ide_spin_wait_hwgroup(drive)) 591 return -EBUSY; 592 drive->keep_settings = arg; 593 spin_unlock_irq(&ide_lock); 594 595 return 0; 596} 597 598int set_using_dma(ide_drive_t *drive, int arg) 599{ 600#ifdef CONFIG_BLK_DEV_IDEDMA 601 ide_hwif_t *hwif = drive->hwif; 602 int err = -EPERM; 603 604 if (arg < 0 || arg > 1) 605 return -EINVAL; 606 607 if (!drive->id || !(drive->id->capability & 1)) 608 goto out; 609 610 if (hwif->dma_host_set == NULL) 611 goto out; 612 613 err = -EBUSY; 614 if (ide_spin_wait_hwgroup(drive)) 615 goto out; 616 /* 617 * set ->busy flag, unlock and let it ride 618 */ 619 hwif->hwgroup->busy = 1; 620 spin_unlock_irq(&ide_lock); 621 622 err = 0; 623 624 if (arg) { 625 if (ide_set_dma(drive)) 626 err = -EIO; 627 } else 628 ide_dma_off(drive); 629 630 /* 631 * lock, clear ->busy flag and unlock before leaving 632 */ 633 spin_lock_irq(&ide_lock); 634 hwif->hwgroup->busy = 0; 635 spin_unlock_irq(&ide_lock); 636out: 637 return err; 638#else 639 if (arg < 0 || arg > 1) 640 return -EINVAL; 641 642 return -EPERM; 643#endif 644} 645 646int set_pio_mode(ide_drive_t *drive, int arg) 647{ 648 struct request rq; 649 650 if (arg < 0 || arg > 255) 651 return -EINVAL; 652 653 if (drive->hwif->set_pio_mode == NULL) 654 return -ENOSYS; 655 656 if (drive->special.b.set_tune) 657 return -EBUSY; 658 659 ide_init_drive_cmd(&rq); 660 rq.cmd_type = REQ_TYPE_ATA_TASKFILE; 661 662 drive->tune_req = (u8) arg; 663 drive->special.b.set_tune = 1; 664 (void) ide_do_drive_cmd(drive, &rq, ide_wait); 665 return 0; 666} 667 668static int set_unmaskirq(ide_drive_t *drive, int arg) 669{ 670 if (drive->no_unmask) 671 return -EPERM; 672 673 if (arg < 0 || arg > 1) 674 return -EINVAL; 675 676 if (ide_spin_wait_hwgroup(drive)) 677 return -EBUSY; 678 drive->unmask = arg; 679 spin_unlock_irq(&ide_lock); 680 681 return 0; 682} 683 684/** 685 * system_bus_clock - clock guess 686 * 687 * External version of the bus clock guess used by very old IDE drivers 688 * for things like VLB timings. Should not be used. 689 */ 690 691int system_bus_clock (void) 692{ 693 return system_bus_speed; 694} 695 696EXPORT_SYMBOL(system_bus_clock); 697 698static int generic_ide_suspend(struct device *dev, pm_message_t mesg) 699{ 700 ide_drive_t *drive = dev->driver_data; 701 ide_hwif_t *hwif = HWIF(drive); 702 struct request rq; 703 struct request_pm_state rqpm; 704 ide_task_t args; 705 int ret; 706 707 /* Call ACPI _GTM only once */ 708 if (!(drive->dn % 2)) 709 ide_acpi_get_timing(hwif); 710 711 memset(&rq, 0, sizeof(rq)); 712 memset(&rqpm, 0, sizeof(rqpm)); 713 memset(&args, 0, sizeof(args)); 714 rq.cmd_type = REQ_TYPE_PM_SUSPEND; 715 rq.special = &args; 716 rq.data = &rqpm; 717 rqpm.pm_step = ide_pm_state_start_suspend; 718 if (mesg.event == PM_EVENT_PRETHAW) 719 mesg.event = PM_EVENT_FREEZE; 720 rqpm.pm_state = mesg.event; 721 722 ret = ide_do_drive_cmd(drive, &rq, ide_wait); 723 /* only call ACPI _PS3 after both drivers are suspended */ 724 if (!ret && (((drive->dn % 2) && hwif->drives[0].present 725 && hwif->drives[1].present) 726 || !hwif->drives[0].present 727 || !hwif->drives[1].present)) 728 ide_acpi_set_state(hwif, 0); 729 return ret; 730} 731 732static int generic_ide_resume(struct device *dev) 733{ 734 ide_drive_t *drive = dev->driver_data; 735 ide_hwif_t *hwif = HWIF(drive); 736 struct request rq; 737 struct request_pm_state rqpm; 738 ide_task_t args; 739 int err; 740 741 /* Call ACPI _STM only once */ 742 if (!(drive->dn % 2)) { 743 ide_acpi_set_state(hwif, 1); 744 ide_acpi_push_timing(hwif); 745 } 746 747 ide_acpi_exec_tfs(drive); 748 749 memset(&rq, 0, sizeof(rq)); 750 memset(&rqpm, 0, sizeof(rqpm)); 751 memset(&args, 0, sizeof(args)); 752 rq.cmd_type = REQ_TYPE_PM_RESUME; 753 rq.special = &args; 754 rq.data = &rqpm; 755 rqpm.pm_step = ide_pm_state_start_resume; 756 rqpm.pm_state = PM_EVENT_ON; 757 758 err = ide_do_drive_cmd(drive, &rq, ide_head_wait); 759 760 if (err == 0 && dev->driver) { 761 ide_driver_t *drv = to_ide_driver(dev->driver); 762 763 if (drv->resume) 764 drv->resume(drive); 765 } 766 767 return err; 768} 769 770int generic_ide_ioctl(ide_drive_t *drive, struct file *file, struct block_device *bdev, 771 unsigned int cmd, unsigned long arg) 772{ 773 unsigned long flags; 774 ide_driver_t *drv; 775 void __user *p = (void __user *)arg; 776 int err = 0, (*setfunc)(ide_drive_t *, int); 777 u8 *val; 778 779 switch (cmd) { 780 case HDIO_GET_32BIT: val = &drive->io_32bit; goto read_val; 781 case HDIO_GET_KEEPSETTINGS: val = &drive->keep_settings; goto read_val; 782 case HDIO_GET_UNMASKINTR: val = &drive->unmask; goto read_val; 783 case HDIO_GET_DMA: val = &drive->using_dma; goto read_val; 784 case HDIO_SET_32BIT: setfunc = set_io_32bit; goto set_val; 785 case HDIO_SET_KEEPSETTINGS: setfunc = set_ksettings; goto set_val; 786 case HDIO_SET_PIO_MODE: setfunc = set_pio_mode; goto set_val; 787 case HDIO_SET_UNMASKINTR: setfunc = set_unmaskirq; goto set_val; 788 case HDIO_SET_DMA: setfunc = set_using_dma; goto set_val; 789 } 790 791 switch (cmd) { 792 case HDIO_OBSOLETE_IDENTITY: 793 case HDIO_GET_IDENTITY: 794 if (bdev != bdev->bd_contains) 795 return -EINVAL; 796 if (drive->id_read == 0) 797 return -ENOMSG; 798 if (copy_to_user(p, drive->id, (cmd == HDIO_GET_IDENTITY) ? sizeof(*drive->id) : 142)) 799 return -EFAULT; 800 return 0; 801 802 case HDIO_GET_NICE: 803 return put_user(drive->dsc_overlap << IDE_NICE_DSC_OVERLAP | 804 drive->atapi_overlap << IDE_NICE_ATAPI_OVERLAP | 805 drive->nice1 << IDE_NICE_1, 806 (long __user *) arg); 807#ifdef CONFIG_IDE_TASK_IOCTL 808 case HDIO_DRIVE_TASKFILE: 809 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) 810 return -EACCES; 811 switch(drive->media) { 812 case ide_disk: 813 return ide_taskfile_ioctl(drive, cmd, arg); 814 default: 815 return -ENOMSG; 816 } 817#endif /* CONFIG_IDE_TASK_IOCTL */ 818 819 case HDIO_DRIVE_CMD: 820 if (!capable(CAP_SYS_RAWIO)) 821 return -EACCES; 822 return ide_cmd_ioctl(drive, cmd, arg); 823 824 case HDIO_DRIVE_TASK: 825 if (!capable(CAP_SYS_RAWIO)) 826 return -EACCES; 827 return ide_task_ioctl(drive, cmd, arg); 828 case HDIO_SET_NICE: 829 if (!capable(CAP_SYS_ADMIN)) return -EACCES; 830 if (arg != (arg & ((1 << IDE_NICE_DSC_OVERLAP) | (1 << IDE_NICE_1)))) 831 return -EPERM; 832 drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1; 833 drv = *(ide_driver_t **)bdev->bd_disk->private_data; 834 if (drive->dsc_overlap && !drv->supports_dsc_overlap) { 835 drive->dsc_overlap = 0; 836 return -EPERM; 837 } 838 drive->nice1 = (arg >> IDE_NICE_1) & 1; 839 return 0; 840 case HDIO_DRIVE_RESET: 841 if (!capable(CAP_SYS_ADMIN)) 842 return -EACCES; 843 844 /* 845 * Abort the current command on the 846 * group if there is one, taking 847 * care not to allow anything else 848 * to be queued and to die on the 849 * spot if we miss one somehow 850 */ 851 852 spin_lock_irqsave(&ide_lock, flags); 853 854 if (HWGROUP(drive)->resetting) { 855 spin_unlock_irqrestore(&ide_lock, flags); 856 return -EBUSY; 857 } 858 859 ide_abort(drive, "drive reset"); 860 861 BUG_ON(HWGROUP(drive)->handler); 862 863 /* Ensure nothing gets queued after we 864 drop the lock. Reset will clear the busy */ 865 866 HWGROUP(drive)->busy = 1; 867 spin_unlock_irqrestore(&ide_lock, flags); 868 (void) ide_do_reset(drive); 869 870 return 0; 871 case HDIO_GET_BUSSTATE: 872 if (!capable(CAP_SYS_ADMIN)) 873 return -EACCES; 874 if (put_user(HWIF(drive)->bus_state, (long __user *)arg)) 875 return -EFAULT; 876 return 0; 877 878 case HDIO_SET_BUSSTATE: 879 if (!capable(CAP_SYS_ADMIN)) 880 return -EACCES; 881 return -EOPNOTSUPP; 882 default: 883 return -EINVAL; 884 } 885 886read_val: 887 mutex_lock(&ide_setting_mtx); 888 spin_lock_irqsave(&ide_lock, flags); 889 err = *val; 890 spin_unlock_irqrestore(&ide_lock, flags); 891 mutex_unlock(&ide_setting_mtx); 892 return err >= 0 ? put_user(err, (long __user *)arg) : err; 893 894set_val: 895 if (bdev != bdev->bd_contains) 896 err = -EINVAL; 897 else { 898 if (!capable(CAP_SYS_ADMIN)) 899 err = -EACCES; 900 else { 901 mutex_lock(&ide_setting_mtx); 902 err = setfunc(drive, arg); 903 mutex_unlock(&ide_setting_mtx); 904 } 905 } 906 return err; 907} 908 909EXPORT_SYMBOL(generic_ide_ioctl); 910 911/* 912 * stridx() returns the offset of c within s, 913 * or -1 if c is '\0' or not found within s. 914 */ 915static int __init stridx (const char *s, char c) 916{ 917 char *i = strchr(s, c); 918 return (i && c) ? i - s : -1; 919} 920 921/* 922 * match_parm() does parsing for ide_setup(): 923 * 924 * 1. the first char of s must be '='. 925 * 2. if the remainder matches one of the supplied keywords, 926 * the index (1 based) of the keyword is negated and returned. 927 * 3. if the remainder is a series of no more than max_vals numbers 928 * separated by commas, the numbers are saved in vals[] and a 929 * count of how many were saved is returned. Base10 is assumed, 930 * and base16 is allowed when prefixed with "0x". 931 * 4. otherwise, zero is returned. 932 */ 933static int __init match_parm (char *s, const char *keywords[], int vals[], int max_vals) 934{ 935 static const char *decimal = "0123456789"; 936 static const char *hex = "0123456789abcdef"; 937 int i, n; 938 939 if (*s++ == '=') { 940 /* 941 * Try matching against the supplied keywords, 942 * and return -(index+1) if we match one 943 */ 944 if (keywords != NULL) { 945 for (i = 0; *keywords != NULL; ++i) { 946 if (!strcmp(s, *keywords++)) 947 return -(i+1); 948 } 949 } 950 /* 951 * Look for a series of no more than "max_vals" 952 * numeric values separated by commas, in base10, 953 * or base16 when prefixed with "0x". 954 * Return a count of how many were found. 955 */ 956 for (n = 0; (i = stridx(decimal, *s)) >= 0;) { 957 vals[n] = i; 958 while ((i = stridx(decimal, *++s)) >= 0) 959 vals[n] = (vals[n] * 10) + i; 960 if (*s == 'x' && !vals[n]) { 961 while ((i = stridx(hex, *++s)) >= 0) 962 vals[n] = (vals[n] * 0x10) + i; 963 } 964 if (++n == max_vals) 965 break; 966 if (*s == ',' || *s == ';') 967 ++s; 968 } 969 if (!*s) 970 return n; 971 } 972 return 0; /* zero = nothing matched */ 973} 974 975extern int probe_ali14xx; 976extern int probe_umc8672; 977extern int probe_dtc2278; 978extern int probe_ht6560b; 979extern int probe_qd65xx; 980extern int cmd640_vlb; 981 982static int __initdata is_chipset_set; 983 984/* 985 * ide_setup() gets called VERY EARLY during initialization, 986 * to handle kernel "command line" strings beginning with "hdx=" or "ide". 987 * 988 * Remember to update Documentation/ide/ide.txt if you change something here. 989 */ 990static int __init ide_setup(char *s) 991{ 992 int i, vals[3]; 993 ide_hwif_t *hwif; 994 ide_drive_t *drive; 995 unsigned int hw, unit; 996 const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1); 997 const char max_hwif = '0' + (MAX_HWIFS - 1); 998 999 1000 if (strncmp(s,"hd",2) == 0 && s[2] == '=') /* hd= is for hd.c */ 1001 return 0; /* driver and not us */ 1002 1003 if (strncmp(s,"ide",3) && strncmp(s,"idebus",6) && strncmp(s,"hd",2)) 1004 return 0; 1005 1006 printk(KERN_INFO "ide_setup: %s", s); 1007 init_ide_data (); 1008 1009#ifdef CONFIG_BLK_DEV_IDEDOUBLER 1010 if (!strcmp(s, "ide=doubler")) { 1011 extern int ide_doubler; 1012 1013 printk(" : Enabled support for IDE doublers\n"); 1014 ide_doubler = 1; 1015 return 1; 1016 } 1017#endif /* CONFIG_BLK_DEV_IDEDOUBLER */ 1018 1019 if (!strcmp(s, "ide=nodma")) { 1020 printk(" : Prevented DMA\n"); 1021 noautodma = 1; 1022 goto obsolete_option; 1023 } 1024 1025#ifdef CONFIG_BLK_DEV_IDEACPI 1026 if (!strcmp(s, "ide=noacpi")) { 1027 //printk(" : Disable IDE ACPI support.\n"); 1028 ide_noacpi = 1; 1029 return 1; 1030 } 1031 if (!strcmp(s, "ide=acpigtf")) { 1032 //printk(" : Enable IDE ACPI _GTF support.\n"); 1033 ide_noacpitfs = 0; 1034 return 1; 1035 } 1036 if (!strcmp(s, "ide=acpionboot")) { 1037 //printk(" : Call IDE ACPI methods on boot.\n"); 1038 ide_noacpionboot = 0; 1039 return 1; 1040 } 1041#endif /* CONFIG_BLK_DEV_IDEACPI */ 1042 1043 /* 1044 * Look for drive options: "hdx=" 1045 */ 1046 if (s[0] == 'h' && s[1] == 'd' && s[2] >= 'a' && s[2] <= max_drive) { 1047 const char *hd_words[] = { 1048 "none", "noprobe", "nowerr", "cdrom", "nodma", 1049 "autotune", "noautotune", "-8", "-9", "-10", 1050 "noflush", "remap", "remap63", "scsi", NULL }; 1051 unit = s[2] - 'a'; 1052 hw = unit / MAX_DRIVES; 1053 unit = unit % MAX_DRIVES; 1054 hwif = &ide_hwifs[hw]; 1055 drive = &hwif->drives[unit]; 1056 if (strncmp(s + 4, "ide-", 4) == 0) { 1057 strlcpy(drive->driver_req, s + 4, sizeof(drive->driver_req)); 1058 goto obsolete_option; 1059 } 1060 switch (match_parm(&s[3], hd_words, vals, 3)) { 1061 case -1: /* "none" */ 1062 case -2: /* "noprobe" */ 1063 drive->noprobe = 1; 1064 goto done; 1065 case -3: /* "nowerr" */ 1066 drive->bad_wstat = BAD_R_STAT; 1067 hwif->noprobe = 0; 1068 goto done; 1069 case -4: /* "cdrom" */ 1070 drive->present = 1; 1071 drive->media = ide_cdrom; 1072 /* an ATAPI device ignores DRDY */ 1073 drive->ready_stat = 0; 1074 hwif->noprobe = 0; 1075 goto done; 1076 case -5: /* nodma */ 1077 drive->nodma = 1; 1078 goto done; 1079 case -6: /* "autotune" */ 1080 drive->autotune = IDE_TUNE_AUTO; 1081 goto obsolete_option; 1082 case -7: /* "noautotune" */ 1083 drive->autotune = IDE_TUNE_NOAUTO; 1084 goto obsolete_option; 1085 case -11: /* noflush */ 1086 drive->noflush = 1; 1087 goto done; 1088 case -12: /* "remap" */ 1089 drive->remap_0_to_1 = 1; 1090 goto obsolete_option; 1091 case -13: /* "remap63" */ 1092 drive->sect0 = 63; 1093 goto obsolete_option; 1094 case -14: /* "scsi" */ 1095 drive->scsi = 1; 1096 goto obsolete_option; 1097 case 3: /* cyl,head,sect */ 1098 drive->media = ide_disk; 1099 drive->ready_stat = READY_STAT; 1100 drive->cyl = drive->bios_cyl = vals[0]; 1101 drive->head = drive->bios_head = vals[1]; 1102 drive->sect = drive->bios_sect = vals[2]; 1103 drive->present = 1; 1104 drive->forced_geom = 1; 1105 hwif->noprobe = 0; 1106 goto done; 1107 default: 1108 goto bad_option; 1109 } 1110 } 1111 1112 if (s[0] != 'i' || s[1] != 'd' || s[2] != 'e') 1113 goto bad_option; 1114 /* 1115 * Look for bus speed option: "idebus=" 1116 */ 1117 if (s[3] == 'b' && s[4] == 'u' && s[5] == 's') { 1118 if (match_parm(&s[6], NULL, vals, 1) != 1) 1119 goto bad_option; 1120 if (vals[0] >= 20 && vals[0] <= 66) { 1121 idebus_parameter = vals[0]; 1122 } else 1123 printk(" -- BAD BUS SPEED! Expected value from 20 to 66"); 1124 goto done; 1125 } 1126 /* 1127 * Look for interface options: "idex=" 1128 */ 1129 if (s[3] >= '0' && s[3] <= max_hwif) { 1130 /* 1131 * Be VERY CAREFUL changing this: note hardcoded indexes below 1132 * (-8, -9, -10) are reserved to ease the hardcoding. 1133 */ 1134 static const char *ide_words[] = { 1135 "noprobe", "serialize", "minus3", "minus4", 1136 "reset", "minus6", "ata66", "minus8", "minus9", 1137 "minus10", "four", "qd65xx", "ht6560b", "cmd640_vlb", 1138 "dtc2278", "umc8672", "ali14xx", NULL }; 1139 1140 hw = s[3] - '0'; 1141 hwif = &ide_hwifs[hw]; 1142 i = match_parm(&s[4], ide_words, vals, 3); 1143 1144 /* 1145 * Cryptic check to ensure chipset not already set for hwif. 1146 * Note: we can't depend on hwif->chipset here. 1147 */ 1148 if (i >= -18 && i <= -11) { 1149 /* chipset already specified */ 1150 if (is_chipset_set) 1151 goto bad_option; 1152 /* these drivers are for "ide0=" only */ 1153 if (hw != 0) 1154 goto bad_hwif; 1155 is_chipset_set = 1; 1156 printk("\n"); 1157 } 1158 1159 switch (i) { 1160#ifdef CONFIG_BLK_DEV_ALI14XX 1161 case -17: /* "ali14xx" */ 1162 probe_ali14xx = 1; 1163 goto obsolete_option; 1164#endif 1165#ifdef CONFIG_BLK_DEV_UMC8672 1166 case -16: /* "umc8672" */ 1167 probe_umc8672 = 1; 1168 goto obsolete_option; 1169#endif 1170#ifdef CONFIG_BLK_DEV_DTC2278 1171 case -15: /* "dtc2278" */ 1172 probe_dtc2278 = 1; 1173 goto obsolete_option; 1174#endif 1175#ifdef CONFIG_BLK_DEV_CMD640 1176 case -14: /* "cmd640_vlb" */ 1177 cmd640_vlb = 1; 1178 goto obsolete_option; 1179#endif 1180#ifdef CONFIG_BLK_DEV_HT6560B 1181 case -13: /* "ht6560b" */ 1182 probe_ht6560b = 1; 1183 goto obsolete_option; 1184#endif 1185#ifdef CONFIG_BLK_DEV_QD65XX 1186 case -12: /* "qd65xx" */ 1187 probe_qd65xx = 1; 1188 goto obsolete_option; 1189#endif 1190#ifdef CONFIG_BLK_DEV_4DRIVES 1191 case -11: /* "four" drives on one set of ports */ 1192 { 1193 ide_hwif_t *mate = &ide_hwifs[hw^1]; 1194 mate->drives[0].select.all ^= 0x20; 1195 mate->drives[1].select.all ^= 0x20; 1196 hwif->chipset = mate->chipset = ide_4drives; 1197 mate->irq = hwif->irq; 1198 memcpy(mate->io_ports, hwif->io_ports, sizeof(hwif->io_ports)); 1199 hwif->mate = mate; 1200 mate->mate = hwif; 1201 hwif->serialized = mate->serialized = 1; 1202 goto obsolete_option; 1203 } 1204#endif /* CONFIG_BLK_DEV_4DRIVES */ 1205 case -10: /* minus10 */ 1206 case -9: /* minus9 */ 1207 case -8: /* minus8 */ 1208 case -6: 1209 case -4: 1210 case -3: 1211 goto bad_option; 1212 case -7: /* ata66 */ 1213#ifdef CONFIG_BLK_DEV_IDEPCI 1214 /* 1215 * Use ATA_CBL_PATA40_SHORT so drive side 1216 * cable detection is also overriden. 1217 */ 1218 hwif->cbl = ATA_CBL_PATA40_SHORT; 1219 goto obsolete_option; 1220#else 1221 goto bad_hwif; 1222#endif 1223 case -5: /* "reset" */ 1224 hwif->reset = 1; 1225 goto obsolete_option; 1226 case -2: /* "serialize" */ 1227 hwif->mate = &ide_hwifs[hw^1]; 1228 hwif->mate->mate = hwif; 1229 hwif->serialized = hwif->mate->serialized = 1; 1230 goto obsolete_option; 1231 1232 case -1: /* "noprobe" */ 1233 hwif->noprobe = 1; 1234 goto obsolete_option; 1235 case 0: 1236 case 1: 1237 case 2: 1238 case 3: 1239 goto bad_option; 1240 default: 1241 printk(" -- SUPPORT NOT CONFIGURED IN THIS KERNEL\n"); 1242 return 1; 1243 } 1244 } 1245bad_option: 1246 printk(" -- BAD OPTION\n"); 1247 return 1; 1248obsolete_option: 1249 printk(" -- OBSOLETE OPTION, WILL BE REMOVED SOON!\n"); 1250 return 1; 1251bad_hwif: 1252 printk("-- NOT SUPPORTED ON ide%d", hw); 1253done: 1254 printk("\n"); 1255 return 1; 1256} 1257 1258EXPORT_SYMBOL(ide_lock); 1259 1260static int ide_bus_match(struct device *dev, struct device_driver *drv) 1261{ 1262 return 1; 1263} 1264 1265static char *media_string(ide_drive_t *drive) 1266{ 1267 switch (drive->media) { 1268 case ide_disk: 1269 return "disk"; 1270 case ide_cdrom: 1271 return "cdrom"; 1272 case ide_tape: 1273 return "tape"; 1274 case ide_floppy: 1275 return "floppy"; 1276 case ide_optical: 1277 return "optical"; 1278 default: 1279 return "UNKNOWN"; 1280 } 1281} 1282 1283static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf) 1284{ 1285 ide_drive_t *drive = to_ide_device(dev); 1286 return sprintf(buf, "%s\n", media_string(drive)); 1287} 1288 1289static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf) 1290{ 1291 ide_drive_t *drive = to_ide_device(dev); 1292 return sprintf(buf, "%s\n", drive->name); 1293} 1294 1295static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 1296{ 1297 ide_drive_t *drive = to_ide_device(dev); 1298 return sprintf(buf, "ide:m-%s\n", media_string(drive)); 1299} 1300 1301static ssize_t model_show(struct device *dev, struct device_attribute *attr, 1302 char *buf) 1303{ 1304 ide_drive_t *drive = to_ide_device(dev); 1305 return sprintf(buf, "%s\n", drive->id->model); 1306} 1307 1308static ssize_t firmware_show(struct device *dev, struct device_attribute *attr, 1309 char *buf) 1310{ 1311 ide_drive_t *drive = to_ide_device(dev); 1312 return sprintf(buf, "%s\n", drive->id->fw_rev); 1313} 1314 1315static ssize_t serial_show(struct device *dev, struct device_attribute *attr, 1316 char *buf) 1317{ 1318 ide_drive_t *drive = to_ide_device(dev); 1319 return sprintf(buf, "%s\n", drive->id->serial_no); 1320} 1321 1322static struct device_attribute ide_dev_attrs[] = { 1323 __ATTR_RO(media), 1324 __ATTR_RO(drivename), 1325 __ATTR_RO(modalias), 1326 __ATTR_RO(model), 1327 __ATTR_RO(firmware), 1328 __ATTR(serial, 0400, serial_show, NULL), 1329 __ATTR_NULL 1330}; 1331 1332static int ide_uevent(struct device *dev, struct kobj_uevent_env *env) 1333{ 1334 ide_drive_t *drive = to_ide_device(dev); 1335 1336 add_uevent_var(env, "MEDIA=%s", media_string(drive)); 1337 add_uevent_var(env, "DRIVENAME=%s", drive->name); 1338 add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive)); 1339 return 0; 1340} 1341 1342static int generic_ide_probe(struct device *dev) 1343{ 1344 ide_drive_t *drive = to_ide_device(dev); 1345 ide_driver_t *drv = to_ide_driver(dev->driver); 1346 1347 return drv->probe ? drv->probe(drive) : -ENODEV; 1348} 1349 1350static int generic_ide_remove(struct device *dev) 1351{ 1352 ide_drive_t *drive = to_ide_device(dev); 1353 ide_driver_t *drv = to_ide_driver(dev->driver); 1354 1355 if (drv->remove) 1356 drv->remove(drive); 1357 1358 return 0; 1359} 1360 1361static void generic_ide_shutdown(struct device *dev) 1362{ 1363 ide_drive_t *drive = to_ide_device(dev); 1364 ide_driver_t *drv = to_ide_driver(dev->driver); 1365 1366 if (dev->driver && drv->shutdown) 1367 drv->shutdown(drive); 1368} 1369 1370struct bus_type ide_bus_type = { 1371 .name = "ide", 1372 .match = ide_bus_match, 1373 .uevent = ide_uevent, 1374 .probe = generic_ide_probe, 1375 .remove = generic_ide_remove, 1376 .shutdown = generic_ide_shutdown, 1377 .dev_attrs = ide_dev_attrs, 1378 .suspend = generic_ide_suspend, 1379 .resume = generic_ide_resume, 1380}; 1381 1382EXPORT_SYMBOL_GPL(ide_bus_type); 1383 1384static void ide_port_class_release(struct device *portdev) 1385{ 1386 ide_hwif_t *hwif = dev_get_drvdata(portdev); 1387 1388 put_device(&hwif->gendev); 1389} 1390 1391/* 1392 * This is gets invoked once during initialization, to set *everything* up 1393 */ 1394static int __init ide_init(void) 1395{ 1396 int ret; 1397 1398 printk(KERN_INFO "Uniform Multi-Platform E-IDE driver\n"); 1399 system_bus_speed = ide_system_bus_speed(); 1400 1401 printk(KERN_INFO "ide: Assuming %dMHz system bus speed " 1402 "for PIO modes%s\n", system_bus_speed, 1403 idebus_parameter ? "" : "; override with idebus=xx"); 1404 1405 ret = bus_register(&ide_bus_type); 1406 if (ret < 0) { 1407 printk(KERN_WARNING "IDE: bus_register error: %d\n", ret); 1408 return ret; 1409 } 1410 1411 ide_port_class = class_create(THIS_MODULE, "ide_port"); 1412 if (IS_ERR(ide_port_class)) { 1413 ret = PTR_ERR(ide_port_class); 1414 goto out_port_class; 1415 } 1416 ide_port_class->dev_release = ide_port_class_release; 1417 1418 init_ide_data(); 1419 1420 proc_ide_create(); 1421 1422 return 0; 1423 1424out_port_class: 1425 bus_unregister(&ide_bus_type); 1426 1427 return ret; 1428} 1429 1430#ifdef MODULE 1431static char *options = NULL; 1432module_param(options, charp, 0); 1433MODULE_LICENSE("GPL"); 1434 1435static void __init parse_options (char *line) 1436{ 1437 char *next = line; 1438 1439 if (line == NULL || !*line) 1440 return; 1441 while ((line = next) != NULL) { 1442 if ((next = strchr(line,' ')) != NULL) 1443 *next++ = 0; 1444 if (!ide_setup(line)) 1445 printk (KERN_INFO "Unknown option '%s'\n", line); 1446 } 1447} 1448 1449int __init init_module (void) 1450{ 1451 parse_options(options); 1452 return ide_init(); 1453} 1454 1455void __exit cleanup_module (void) 1456{ 1457 int index; 1458 1459 for (index = 0; index < MAX_HWIFS; ++index) 1460 ide_unregister(index); 1461 1462 proc_ide_destroy(); 1463 1464 class_destroy(ide_port_class); 1465 1466 bus_unregister(&ide_bus_type); 1467} 1468 1469#else /* !MODULE */ 1470 1471__setup("", ide_setup); 1472 1473module_init(ide_init); 1474 1475#endif /* MODULE */ 1476