ide.c revision 9a0e77f28b50128df0c9e26ae489e44e29a7270a
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 169static void init_hwif_default(ide_hwif_t *hwif, unsigned int index) 170{ 171 hw_regs_t hw; 172 173 memset(&hw, 0, sizeof(hw_regs_t)); 174 175 ide_init_hwif_ports(&hw, ide_default_io_base(index), 0, &hwif->irq); 176 177 memcpy(hwif->io_ports, hw.io_ports, sizeof(hw.io_ports)); 178 179 hwif->noprobe = !hwif->io_ports[IDE_DATA_OFFSET]; 180} 181 182/* 183 * init_ide_data() sets reasonable default values into all fields 184 * of all instances of the hwifs and drives, but only on the first call. 185 * Subsequent calls have no effect (they don't wipe out anything). 186 * 187 * This routine is normally called at driver initialization time, 188 * but may also be called MUCH earlier during kernel "command-line" 189 * parameter processing. As such, we cannot depend on any other parts 190 * of the kernel (such as memory allocation) to be functioning yet. 191 * 192 * This is too bad, as otherwise we could dynamically allocate the 193 * ide_drive_t structs as needed, rather than always consuming memory 194 * for the max possible number (MAX_HWIFS * MAX_DRIVES) of them. 195 * 196 * FIXME: We should stuff the setup data into __init and copy the 197 * relevant hwifs/allocate them properly during boot. 198 */ 199#define MAGIC_COOKIE 0x12345678 200static void __init init_ide_data (void) 201{ 202 ide_hwif_t *hwif; 203 unsigned int index; 204 static unsigned long magic_cookie = MAGIC_COOKIE; 205 206 if (magic_cookie != MAGIC_COOKIE) 207 return; /* already initialized */ 208 magic_cookie = 0; 209 210 /* Initialise all interface structures */ 211 for (index = 0; index < MAX_HWIFS; ++index) { 212 hwif = &ide_hwifs[index]; 213 ide_init_port_data(hwif, index); 214 init_hwif_default(hwif, index); 215#if !defined(CONFIG_PPC32) || !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 365/** 366 * ide_hwif_restore - restore hwif to template 367 * @hwif: hwif to update 368 * @tmp_hwif: template 369 * 370 * Restore hwif to a previous state by copying most settings 371 * from the template. 372 */ 373 374static void ide_hwif_restore(ide_hwif_t *hwif, ide_hwif_t *tmp_hwif) 375{ 376 hwif->hwgroup = tmp_hwif->hwgroup; 377 378 hwif->gendev.parent = tmp_hwif->gendev.parent; 379 380 hwif->proc = tmp_hwif->proc; 381 382 hwif->major = tmp_hwif->major; 383 hwif->straight8 = tmp_hwif->straight8; 384 hwif->bus_state = tmp_hwif->bus_state; 385 386 hwif->host_flags = tmp_hwif->host_flags; 387 388 hwif->pio_mask = tmp_hwif->pio_mask; 389 390 hwif->ultra_mask = tmp_hwif->ultra_mask; 391 hwif->mwdma_mask = tmp_hwif->mwdma_mask; 392 hwif->swdma_mask = tmp_hwif->swdma_mask; 393 394 hwif->cbl = tmp_hwif->cbl; 395 396 hwif->chipset = tmp_hwif->chipset; 397 hwif->hold = tmp_hwif->hold; 398 399 hwif->dev = tmp_hwif->dev; 400 401#ifdef CONFIG_BLK_DEV_IDEPCI 402 hwif->cds = tmp_hwif->cds; 403#endif 404 405 hwif->set_pio_mode = tmp_hwif->set_pio_mode; 406 hwif->set_dma_mode = tmp_hwif->set_dma_mode; 407 hwif->mdma_filter = tmp_hwif->mdma_filter; 408 hwif->udma_filter = tmp_hwif->udma_filter; 409 hwif->selectproc = tmp_hwif->selectproc; 410 hwif->reset_poll = tmp_hwif->reset_poll; 411 hwif->pre_reset = tmp_hwif->pre_reset; 412 hwif->resetproc = tmp_hwif->resetproc; 413 hwif->maskproc = tmp_hwif->maskproc; 414 hwif->quirkproc = tmp_hwif->quirkproc; 415 416 hwif->ata_input_data = tmp_hwif->ata_input_data; 417 hwif->ata_output_data = tmp_hwif->ata_output_data; 418 hwif->atapi_input_bytes = tmp_hwif->atapi_input_bytes; 419 hwif->atapi_output_bytes = tmp_hwif->atapi_output_bytes; 420 421 hwif->dma_host_set = tmp_hwif->dma_host_set; 422 hwif->dma_setup = tmp_hwif->dma_setup; 423 hwif->dma_exec_cmd = tmp_hwif->dma_exec_cmd; 424 hwif->dma_start = tmp_hwif->dma_start; 425 hwif->ide_dma_end = tmp_hwif->ide_dma_end; 426 hwif->ide_dma_test_irq = tmp_hwif->ide_dma_test_irq; 427 hwif->ide_dma_clear_irq = tmp_hwif->ide_dma_clear_irq; 428 hwif->dma_lost_irq = tmp_hwif->dma_lost_irq; 429 hwif->dma_timeout = tmp_hwif->dma_timeout; 430 431 hwif->OUTB = tmp_hwif->OUTB; 432 hwif->OUTBSYNC = tmp_hwif->OUTBSYNC; 433 hwif->OUTW = tmp_hwif->OUTW; 434 hwif->OUTSW = tmp_hwif->OUTSW; 435 hwif->OUTSL = tmp_hwif->OUTSL; 436 437 hwif->INB = tmp_hwif->INB; 438 hwif->INW = tmp_hwif->INW; 439 hwif->INSW = tmp_hwif->INSW; 440 hwif->INSL = tmp_hwif->INSL; 441 442 hwif->sg_max_nents = tmp_hwif->sg_max_nents; 443 444 hwif->mmio = tmp_hwif->mmio; 445 hwif->rqsize = tmp_hwif->rqsize; 446 447#ifndef CONFIG_BLK_DEV_IDECS 448 hwif->irq = tmp_hwif->irq; 449#endif 450 451 hwif->dma_base = tmp_hwif->dma_base; 452 hwif->dma_command = tmp_hwif->dma_command; 453 hwif->dma_vendor1 = tmp_hwif->dma_vendor1; 454 hwif->dma_status = tmp_hwif->dma_status; 455 hwif->dma_vendor3 = tmp_hwif->dma_vendor3; 456 hwif->dma_prdtable = tmp_hwif->dma_prdtable; 457 458 hwif->config_data = tmp_hwif->config_data; 459 hwif->select_data = tmp_hwif->select_data; 460 hwif->extra_base = tmp_hwif->extra_base; 461 hwif->extra_ports = tmp_hwif->extra_ports; 462 463 hwif->hwif_data = tmp_hwif->hwif_data; 464} 465 466void ide_remove_port_from_hwgroup(ide_hwif_t *hwif) 467{ 468 ide_hwgroup_t *hwgroup = hwif->hwgroup; 469 470 spin_lock_irq(&ide_lock); 471 /* 472 * Remove us from the hwgroup, and free 473 * the hwgroup if we were the only member 474 */ 475 if (hwif->next == hwif) { 476 BUG_ON(hwgroup->hwif != hwif); 477 kfree(hwgroup); 478 } else { 479 /* There is another interface in hwgroup. 480 * Unlink us, and set hwgroup->drive and ->hwif to 481 * something sane. 482 */ 483 ide_hwif_t *g = hwgroup->hwif; 484 485 while (g->next != hwif) 486 g = g->next; 487 g->next = hwif->next; 488 if (hwgroup->hwif == hwif) { 489 /* Chose a random hwif for hwgroup->hwif. 490 * It's guaranteed that there are no drives 491 * left in the hwgroup. 492 */ 493 BUG_ON(hwgroup->drive != NULL); 494 hwgroup->hwif = g; 495 } 496 BUG_ON(hwgroup->hwif == hwif); 497 } 498 spin_unlock_irq(&ide_lock); 499} 500 501/* Called with ide_lock held. */ 502static void __ide_port_unregister_devices(ide_hwif_t *hwif) 503{ 504 int i; 505 506 for (i = 0; i < MAX_DRIVES; i++) { 507 ide_drive_t *drive = &hwif->drives[i]; 508 509 if (drive->present) { 510 spin_unlock_irq(&ide_lock); 511 device_unregister(&drive->gendev); 512 wait_for_completion(&drive->gendev_rel_comp); 513 spin_lock_irq(&ide_lock); 514 } 515 } 516} 517 518void ide_port_unregister_devices(ide_hwif_t *hwif) 519{ 520 mutex_lock(&ide_cfg_mtx); 521 spin_lock_irq(&ide_lock); 522 __ide_port_unregister_devices(hwif); 523 hwif->present = 0; 524 ide_port_init_devices_data(hwif); 525 spin_unlock_irq(&ide_lock); 526 mutex_unlock(&ide_cfg_mtx); 527} 528EXPORT_SYMBOL_GPL(ide_port_unregister_devices); 529 530/** 531 * ide_unregister - free an IDE interface 532 * @index: index of interface (will change soon to a pointer) 533 * @init_default: init default hwif flag 534 * @restore: restore hwif flag 535 * 536 * Perform the final unregister of an IDE interface. At the moment 537 * we don't refcount interfaces so this will also get split up. 538 * 539 * Locking: 540 * The caller must not hold the IDE locks 541 * The drive present/vanishing is not yet properly locked 542 * Take care with the callbacks. These have been split to avoid 543 * deadlocking the IDE layer. The shutdown callback is called 544 * before we take the lock and free resources. It is up to the 545 * caller to be sure there is no pending I/O here, and that 546 * the interface will not be reopened (present/vanishing locking 547 * isn't yet done BTW). After we commit to the final kill we 548 * call the cleanup callback with the ide locks held. 549 * 550 * Unregister restores the hwif structures to the default state. 551 * This is raving bonkers. 552 */ 553 554void ide_unregister(unsigned int index, int init_default, int restore) 555{ 556 ide_hwif_t *hwif, *g; 557 static ide_hwif_t tmp_hwif; /* protected by ide_cfg_mtx */ 558 ide_hwgroup_t *hwgroup; 559 int irq_count = 0; 560 561 BUG_ON(index >= MAX_HWIFS); 562 563 BUG_ON(in_interrupt()); 564 BUG_ON(irqs_disabled()); 565 mutex_lock(&ide_cfg_mtx); 566 spin_lock_irq(&ide_lock); 567 hwif = &ide_hwifs[index]; 568 if (!hwif->present) 569 goto abort; 570 __ide_port_unregister_devices(hwif); 571 hwif->present = 0; 572 573 spin_unlock_irq(&ide_lock); 574 575 ide_proc_unregister_port(hwif); 576 577 hwgroup = hwif->hwgroup; 578 /* 579 * free the irq if we were the only hwif using it 580 */ 581 g = hwgroup->hwif; 582 do { 583 if (g->irq == hwif->irq) 584 ++irq_count; 585 g = g->next; 586 } while (g != hwgroup->hwif); 587 if (irq_count == 1) 588 free_irq(hwif->irq, hwgroup); 589 590 ide_remove_port_from_hwgroup(hwif); 591 592 device_unregister(hwif->portdev); 593 device_unregister(&hwif->gendev); 594 wait_for_completion(&hwif->gendev_rel_comp); 595 596 /* 597 * Remove us from the kernel's knowledge 598 */ 599 blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS); 600 kfree(hwif->sg_table); 601 unregister_blkdev(hwif->major, hwif->name); 602 spin_lock_irq(&ide_lock); 603 604 if (hwif->dma_base) { 605 (void) ide_release_dma(hwif); 606 607 hwif->dma_base = 0; 608 hwif->dma_command = 0; 609 hwif->dma_vendor1 = 0; 610 hwif->dma_status = 0; 611 hwif->dma_vendor3 = 0; 612 hwif->dma_prdtable = 0; 613 614 hwif->extra_base = 0; 615 hwif->extra_ports = 0; 616 } 617 618 ide_hwif_release_regions(hwif); 619 620 /* copy original settings */ 621 tmp_hwif = *hwif; 622 623 /* restore hwif data to pristine status */ 624 ide_init_port_data(hwif, index); 625 626 if (init_default) 627 init_hwif_default(hwif, index); 628 629 if (restore) 630 ide_hwif_restore(hwif, &tmp_hwif); 631 632abort: 633 spin_unlock_irq(&ide_lock); 634 mutex_unlock(&ide_cfg_mtx); 635} 636 637EXPORT_SYMBOL(ide_unregister); 638 639void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw) 640{ 641 memcpy(hwif->io_ports, hw->io_ports, sizeof(hwif->io_ports)); 642 hwif->irq = hw->irq; 643 hwif->noprobe = 0; 644 hwif->chipset = hw->chipset; 645 hwif->gendev.parent = hw->dev; 646 hwif->ack_intr = hw->ack_intr; 647} 648EXPORT_SYMBOL_GPL(ide_init_port_hw); 649 650/** 651 * ide_register_hw - register IDE interface 652 * @hw: hardware registers 653 * @quirkproc: quirkproc function 654 * @hwifp: pointer to returned hwif 655 * 656 * Register an IDE interface, specifying exactly the registers etc. 657 * 658 * Returns -1 on error. 659 */ 660 661static int ide_register_hw(hw_regs_t *hw, void (*quirkproc)(ide_drive_t *), 662 ide_hwif_t **hwifp) 663{ 664 int index, retry = 1; 665 ide_hwif_t *hwif; 666 u8 idx[4] = { 0xff, 0xff, 0xff, 0xff }; 667 668 do { 669 hwif = ide_find_port(hw->io_ports[IDE_DATA_OFFSET]); 670 if (hwif) 671 goto found; 672 for (index = 0; index < MAX_HWIFS; index++) 673 ide_unregister(index, 1, 1); 674 } while (retry--); 675 return -1; 676found: 677 index = hwif->index; 678 if (hwif->present) 679 ide_unregister(index, 0, 1); 680 else if (!hwif->hold) 681 ide_init_port_data(hwif, index); 682 683 ide_init_port_hw(hwif, hw); 684 hwif->quirkproc = quirkproc; 685 686 idx[0] = index; 687 688 ide_device_add(idx, NULL); 689 690 if (hwifp) 691 *hwifp = hwif; 692 693 return hwif->present ? index : -1; 694} 695 696/* 697 * Locks for IDE setting functionality 698 */ 699 700DEFINE_MUTEX(ide_setting_mtx); 701 702EXPORT_SYMBOL_GPL(ide_setting_mtx); 703 704/** 705 * ide_spin_wait_hwgroup - wait for group 706 * @drive: drive in the group 707 * 708 * Wait for an IDE device group to go non busy and then return 709 * holding the ide_lock which guards the hwgroup->busy status 710 * and right to use it. 711 */ 712 713int ide_spin_wait_hwgroup (ide_drive_t *drive) 714{ 715 ide_hwgroup_t *hwgroup = HWGROUP(drive); 716 unsigned long timeout = jiffies + (3 * HZ); 717 718 spin_lock_irq(&ide_lock); 719 720 while (hwgroup->busy) { 721 unsigned long lflags; 722 spin_unlock_irq(&ide_lock); 723 local_irq_set(lflags); 724 if (time_after(jiffies, timeout)) { 725 local_irq_restore(lflags); 726 printk(KERN_ERR "%s: channel busy\n", drive->name); 727 return -EBUSY; 728 } 729 local_irq_restore(lflags); 730 spin_lock_irq(&ide_lock); 731 } 732 return 0; 733} 734 735EXPORT_SYMBOL(ide_spin_wait_hwgroup); 736 737int set_io_32bit(ide_drive_t *drive, int arg) 738{ 739 if (drive->no_io_32bit) 740 return -EPERM; 741 742 if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1)) 743 return -EINVAL; 744 745 if (ide_spin_wait_hwgroup(drive)) 746 return -EBUSY; 747 748 drive->io_32bit = arg; 749 750 spin_unlock_irq(&ide_lock); 751 752 return 0; 753} 754 755static int set_ksettings(ide_drive_t *drive, int arg) 756{ 757 if (arg < 0 || arg > 1) 758 return -EINVAL; 759 760 if (ide_spin_wait_hwgroup(drive)) 761 return -EBUSY; 762 drive->keep_settings = arg; 763 spin_unlock_irq(&ide_lock); 764 765 return 0; 766} 767 768int set_using_dma(ide_drive_t *drive, int arg) 769{ 770#ifdef CONFIG_BLK_DEV_IDEDMA 771 ide_hwif_t *hwif = drive->hwif; 772 int err = -EPERM; 773 774 if (arg < 0 || arg > 1) 775 return -EINVAL; 776 777 if (!drive->id || !(drive->id->capability & 1)) 778 goto out; 779 780 if (hwif->dma_host_set == NULL) 781 goto out; 782 783 err = -EBUSY; 784 if (ide_spin_wait_hwgroup(drive)) 785 goto out; 786 /* 787 * set ->busy flag, unlock and let it ride 788 */ 789 hwif->hwgroup->busy = 1; 790 spin_unlock_irq(&ide_lock); 791 792 err = 0; 793 794 if (arg) { 795 if (ide_set_dma(drive)) 796 err = -EIO; 797 } else 798 ide_dma_off(drive); 799 800 /* 801 * lock, clear ->busy flag and unlock before leaving 802 */ 803 spin_lock_irq(&ide_lock); 804 hwif->hwgroup->busy = 0; 805 spin_unlock_irq(&ide_lock); 806out: 807 return err; 808#else 809 if (arg < 0 || arg > 1) 810 return -EINVAL; 811 812 return -EPERM; 813#endif 814} 815 816int set_pio_mode(ide_drive_t *drive, int arg) 817{ 818 struct request rq; 819 820 if (arg < 0 || arg > 255) 821 return -EINVAL; 822 823 if (drive->hwif->set_pio_mode == NULL) 824 return -ENOSYS; 825 826 if (drive->special.b.set_tune) 827 return -EBUSY; 828 829 ide_init_drive_cmd(&rq); 830 rq.cmd_type = REQ_TYPE_ATA_TASKFILE; 831 832 drive->tune_req = (u8) arg; 833 drive->special.b.set_tune = 1; 834 (void) ide_do_drive_cmd(drive, &rq, ide_wait); 835 return 0; 836} 837 838static int set_unmaskirq(ide_drive_t *drive, int arg) 839{ 840 if (drive->no_unmask) 841 return -EPERM; 842 843 if (arg < 0 || arg > 1) 844 return -EINVAL; 845 846 if (ide_spin_wait_hwgroup(drive)) 847 return -EBUSY; 848 drive->unmask = arg; 849 spin_unlock_irq(&ide_lock); 850 851 return 0; 852} 853 854/** 855 * system_bus_clock - clock guess 856 * 857 * External version of the bus clock guess used by very old IDE drivers 858 * for things like VLB timings. Should not be used. 859 */ 860 861int system_bus_clock (void) 862{ 863 return system_bus_speed; 864} 865 866EXPORT_SYMBOL(system_bus_clock); 867 868static int generic_ide_suspend(struct device *dev, pm_message_t mesg) 869{ 870 ide_drive_t *drive = dev->driver_data; 871 ide_hwif_t *hwif = HWIF(drive); 872 struct request rq; 873 struct request_pm_state rqpm; 874 ide_task_t args; 875 int ret; 876 877 /* Call ACPI _GTM only once */ 878 if (!(drive->dn % 2)) 879 ide_acpi_get_timing(hwif); 880 881 memset(&rq, 0, sizeof(rq)); 882 memset(&rqpm, 0, sizeof(rqpm)); 883 memset(&args, 0, sizeof(args)); 884 rq.cmd_type = REQ_TYPE_PM_SUSPEND; 885 rq.special = &args; 886 rq.data = &rqpm; 887 rqpm.pm_step = ide_pm_state_start_suspend; 888 if (mesg.event == PM_EVENT_PRETHAW) 889 mesg.event = PM_EVENT_FREEZE; 890 rqpm.pm_state = mesg.event; 891 892 ret = ide_do_drive_cmd(drive, &rq, ide_wait); 893 /* only call ACPI _PS3 after both drivers are suspended */ 894 if (!ret && (((drive->dn % 2) && hwif->drives[0].present 895 && hwif->drives[1].present) 896 || !hwif->drives[0].present 897 || !hwif->drives[1].present)) 898 ide_acpi_set_state(hwif, 0); 899 return ret; 900} 901 902static int generic_ide_resume(struct device *dev) 903{ 904 ide_drive_t *drive = dev->driver_data; 905 ide_hwif_t *hwif = HWIF(drive); 906 struct request rq; 907 struct request_pm_state rqpm; 908 ide_task_t args; 909 int err; 910 911 /* Call ACPI _STM only once */ 912 if (!(drive->dn % 2)) { 913 ide_acpi_set_state(hwif, 1); 914 ide_acpi_push_timing(hwif); 915 } 916 917 ide_acpi_exec_tfs(drive); 918 919 memset(&rq, 0, sizeof(rq)); 920 memset(&rqpm, 0, sizeof(rqpm)); 921 memset(&args, 0, sizeof(args)); 922 rq.cmd_type = REQ_TYPE_PM_RESUME; 923 rq.special = &args; 924 rq.data = &rqpm; 925 rqpm.pm_step = ide_pm_state_start_resume; 926 rqpm.pm_state = PM_EVENT_ON; 927 928 err = ide_do_drive_cmd(drive, &rq, ide_head_wait); 929 930 if (err == 0 && dev->driver) { 931 ide_driver_t *drv = to_ide_driver(dev->driver); 932 933 if (drv->resume) 934 drv->resume(drive); 935 } 936 937 return err; 938} 939 940int generic_ide_ioctl(ide_drive_t *drive, struct file *file, struct block_device *bdev, 941 unsigned int cmd, unsigned long arg) 942{ 943 unsigned long flags; 944 ide_driver_t *drv; 945 void __user *p = (void __user *)arg; 946 int err = 0, (*setfunc)(ide_drive_t *, int); 947 u8 *val; 948 949 switch (cmd) { 950 case HDIO_GET_32BIT: val = &drive->io_32bit; goto read_val; 951 case HDIO_GET_KEEPSETTINGS: val = &drive->keep_settings; goto read_val; 952 case HDIO_GET_UNMASKINTR: val = &drive->unmask; goto read_val; 953 case HDIO_GET_DMA: val = &drive->using_dma; goto read_val; 954 case HDIO_SET_32BIT: setfunc = set_io_32bit; goto set_val; 955 case HDIO_SET_KEEPSETTINGS: setfunc = set_ksettings; goto set_val; 956 case HDIO_SET_PIO_MODE: setfunc = set_pio_mode; goto set_val; 957 case HDIO_SET_UNMASKINTR: setfunc = set_unmaskirq; goto set_val; 958 case HDIO_SET_DMA: setfunc = set_using_dma; goto set_val; 959 } 960 961 switch (cmd) { 962 case HDIO_OBSOLETE_IDENTITY: 963 case HDIO_GET_IDENTITY: 964 if (bdev != bdev->bd_contains) 965 return -EINVAL; 966 if (drive->id_read == 0) 967 return -ENOMSG; 968 if (copy_to_user(p, drive->id, (cmd == HDIO_GET_IDENTITY) ? sizeof(*drive->id) : 142)) 969 return -EFAULT; 970 return 0; 971 972 case HDIO_GET_NICE: 973 return put_user(drive->dsc_overlap << IDE_NICE_DSC_OVERLAP | 974 drive->atapi_overlap << IDE_NICE_ATAPI_OVERLAP | 975 drive->nice1 << IDE_NICE_1, 976 (long __user *) arg); 977#ifdef CONFIG_IDE_TASK_IOCTL 978 case HDIO_DRIVE_TASKFILE: 979 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) 980 return -EACCES; 981 switch(drive->media) { 982 case ide_disk: 983 return ide_taskfile_ioctl(drive, cmd, arg); 984 default: 985 return -ENOMSG; 986 } 987#endif /* CONFIG_IDE_TASK_IOCTL */ 988 989 case HDIO_DRIVE_CMD: 990 if (!capable(CAP_SYS_RAWIO)) 991 return -EACCES; 992 return ide_cmd_ioctl(drive, cmd, arg); 993 994 case HDIO_DRIVE_TASK: 995 if (!capable(CAP_SYS_RAWIO)) 996 return -EACCES; 997 return ide_task_ioctl(drive, cmd, arg); 998 999 case HDIO_SCAN_HWIF: 1000 { 1001 hw_regs_t hw; 1002 int args[3]; 1003 if (!capable(CAP_SYS_RAWIO)) return -EACCES; 1004 if (copy_from_user(args, p, 3 * sizeof(int))) 1005 return -EFAULT; 1006 memset(&hw, 0, sizeof(hw)); 1007 ide_init_hwif_ports(&hw, (unsigned long) args[0], 1008 (unsigned long) args[1], NULL); 1009 hw.irq = args[2]; 1010 if (ide_register_hw(&hw, NULL, NULL) == -1) 1011 return -EIO; 1012 return 0; 1013 } 1014 case HDIO_UNREGISTER_HWIF: 1015 if (!capable(CAP_SYS_RAWIO)) return -EACCES; 1016 /* (arg > MAX_HWIFS) checked in function */ 1017 ide_unregister(arg, 1, 1); 1018 return 0; 1019 case HDIO_SET_NICE: 1020 if (!capable(CAP_SYS_ADMIN)) return -EACCES; 1021 if (arg != (arg & ((1 << IDE_NICE_DSC_OVERLAP) | (1 << IDE_NICE_1)))) 1022 return -EPERM; 1023 drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1; 1024 drv = *(ide_driver_t **)bdev->bd_disk->private_data; 1025 if (drive->dsc_overlap && !drv->supports_dsc_overlap) { 1026 drive->dsc_overlap = 0; 1027 return -EPERM; 1028 } 1029 drive->nice1 = (arg >> IDE_NICE_1) & 1; 1030 return 0; 1031 case HDIO_DRIVE_RESET: 1032 if (!capable(CAP_SYS_ADMIN)) 1033 return -EACCES; 1034 1035 /* 1036 * Abort the current command on the 1037 * group if there is one, taking 1038 * care not to allow anything else 1039 * to be queued and to die on the 1040 * spot if we miss one somehow 1041 */ 1042 1043 spin_lock_irqsave(&ide_lock, flags); 1044 1045 if (HWGROUP(drive)->resetting) { 1046 spin_unlock_irqrestore(&ide_lock, flags); 1047 return -EBUSY; 1048 } 1049 1050 ide_abort(drive, "drive reset"); 1051 1052 BUG_ON(HWGROUP(drive)->handler); 1053 1054 /* Ensure nothing gets queued after we 1055 drop the lock. Reset will clear the busy */ 1056 1057 HWGROUP(drive)->busy = 1; 1058 spin_unlock_irqrestore(&ide_lock, flags); 1059 (void) ide_do_reset(drive); 1060 1061 return 0; 1062 case HDIO_GET_BUSSTATE: 1063 if (!capable(CAP_SYS_ADMIN)) 1064 return -EACCES; 1065 if (put_user(HWIF(drive)->bus_state, (long __user *)arg)) 1066 return -EFAULT; 1067 return 0; 1068 1069 case HDIO_SET_BUSSTATE: 1070 if (!capable(CAP_SYS_ADMIN)) 1071 return -EACCES; 1072 return -EOPNOTSUPP; 1073 default: 1074 return -EINVAL; 1075 } 1076 1077read_val: 1078 mutex_lock(&ide_setting_mtx); 1079 spin_lock_irqsave(&ide_lock, flags); 1080 err = *val; 1081 spin_unlock_irqrestore(&ide_lock, flags); 1082 mutex_unlock(&ide_setting_mtx); 1083 return err >= 0 ? put_user(err, (long __user *)arg) : err; 1084 1085set_val: 1086 if (bdev != bdev->bd_contains) 1087 err = -EINVAL; 1088 else { 1089 if (!capable(CAP_SYS_ADMIN)) 1090 err = -EACCES; 1091 else { 1092 mutex_lock(&ide_setting_mtx); 1093 err = setfunc(drive, arg); 1094 mutex_unlock(&ide_setting_mtx); 1095 } 1096 } 1097 return err; 1098} 1099 1100EXPORT_SYMBOL(generic_ide_ioctl); 1101 1102/* 1103 * stridx() returns the offset of c within s, 1104 * or -1 if c is '\0' or not found within s. 1105 */ 1106static int __init stridx (const char *s, char c) 1107{ 1108 char *i = strchr(s, c); 1109 return (i && c) ? i - s : -1; 1110} 1111 1112/* 1113 * match_parm() does parsing for ide_setup(): 1114 * 1115 * 1. the first char of s must be '='. 1116 * 2. if the remainder matches one of the supplied keywords, 1117 * the index (1 based) of the keyword is negated and returned. 1118 * 3. if the remainder is a series of no more than max_vals numbers 1119 * separated by commas, the numbers are saved in vals[] and a 1120 * count of how many were saved is returned. Base10 is assumed, 1121 * and base16 is allowed when prefixed with "0x". 1122 * 4. otherwise, zero is returned. 1123 */ 1124static int __init match_parm (char *s, const char *keywords[], int vals[], int max_vals) 1125{ 1126 static const char *decimal = "0123456789"; 1127 static const char *hex = "0123456789abcdef"; 1128 int i, n; 1129 1130 if (*s++ == '=') { 1131 /* 1132 * Try matching against the supplied keywords, 1133 * and return -(index+1) if we match one 1134 */ 1135 if (keywords != NULL) { 1136 for (i = 0; *keywords != NULL; ++i) { 1137 if (!strcmp(s, *keywords++)) 1138 return -(i+1); 1139 } 1140 } 1141 /* 1142 * Look for a series of no more than "max_vals" 1143 * numeric values separated by commas, in base10, 1144 * or base16 when prefixed with "0x". 1145 * Return a count of how many were found. 1146 */ 1147 for (n = 0; (i = stridx(decimal, *s)) >= 0;) { 1148 vals[n] = i; 1149 while ((i = stridx(decimal, *++s)) >= 0) 1150 vals[n] = (vals[n] * 10) + i; 1151 if (*s == 'x' && !vals[n]) { 1152 while ((i = stridx(hex, *++s)) >= 0) 1153 vals[n] = (vals[n] * 0x10) + i; 1154 } 1155 if (++n == max_vals) 1156 break; 1157 if (*s == ',' || *s == ';') 1158 ++s; 1159 } 1160 if (!*s) 1161 return n; 1162 } 1163 return 0; /* zero = nothing matched */ 1164} 1165 1166extern int probe_ali14xx; 1167extern int probe_umc8672; 1168extern int probe_dtc2278; 1169extern int probe_ht6560b; 1170extern int probe_qd65xx; 1171extern int cmd640_vlb; 1172 1173static int __initdata is_chipset_set; 1174 1175/* 1176 * ide_setup() gets called VERY EARLY during initialization, 1177 * to handle kernel "command line" strings beginning with "hdx=" or "ide". 1178 * 1179 * Remember to update Documentation/ide/ide.txt if you change something here. 1180 */ 1181static int __init ide_setup(char *s) 1182{ 1183 int i, vals[3]; 1184 ide_hwif_t *hwif; 1185 ide_drive_t *drive; 1186 unsigned int hw, unit; 1187 const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1); 1188 const char max_hwif = '0' + (MAX_HWIFS - 1); 1189 1190 1191 if (strncmp(s,"hd",2) == 0 && s[2] == '=') /* hd= is for hd.c */ 1192 return 0; /* driver and not us */ 1193 1194 if (strncmp(s,"ide",3) && strncmp(s,"idebus",6) && strncmp(s,"hd",2)) 1195 return 0; 1196 1197 printk(KERN_INFO "ide_setup: %s", s); 1198 init_ide_data (); 1199 1200#ifdef CONFIG_BLK_DEV_IDEDOUBLER 1201 if (!strcmp(s, "ide=doubler")) { 1202 extern int ide_doubler; 1203 1204 printk(" : Enabled support for IDE doublers\n"); 1205 ide_doubler = 1; 1206 return 1; 1207 } 1208#endif /* CONFIG_BLK_DEV_IDEDOUBLER */ 1209 1210 if (!strcmp(s, "ide=nodma")) { 1211 printk(" : Prevented DMA\n"); 1212 noautodma = 1; 1213 goto obsolete_option; 1214 } 1215 1216#ifdef CONFIG_BLK_DEV_IDEACPI 1217 if (!strcmp(s, "ide=noacpi")) { 1218 //printk(" : Disable IDE ACPI support.\n"); 1219 ide_noacpi = 1; 1220 return 1; 1221 } 1222 if (!strcmp(s, "ide=acpigtf")) { 1223 //printk(" : Enable IDE ACPI _GTF support.\n"); 1224 ide_noacpitfs = 0; 1225 return 1; 1226 } 1227 if (!strcmp(s, "ide=acpionboot")) { 1228 //printk(" : Call IDE ACPI methods on boot.\n"); 1229 ide_noacpionboot = 0; 1230 return 1; 1231 } 1232#endif /* CONFIG_BLK_DEV_IDEACPI */ 1233 1234 /* 1235 * Look for drive options: "hdx=" 1236 */ 1237 if (s[0] == 'h' && s[1] == 'd' && s[2] >= 'a' && s[2] <= max_drive) { 1238 const char *hd_words[] = { 1239 "none", "noprobe", "nowerr", "cdrom", "nodma", 1240 "autotune", "noautotune", "-8", "-9", "-10", 1241 "noflush", "remap", "remap63", "scsi", NULL }; 1242 unit = s[2] - 'a'; 1243 hw = unit / MAX_DRIVES; 1244 unit = unit % MAX_DRIVES; 1245 hwif = &ide_hwifs[hw]; 1246 drive = &hwif->drives[unit]; 1247 if (strncmp(s + 4, "ide-", 4) == 0) { 1248 strlcpy(drive->driver_req, s + 4, sizeof(drive->driver_req)); 1249 goto obsolete_option; 1250 } 1251 switch (match_parm(&s[3], hd_words, vals, 3)) { 1252 case -1: /* "none" */ 1253 case -2: /* "noprobe" */ 1254 drive->noprobe = 1; 1255 goto done; 1256 case -3: /* "nowerr" */ 1257 drive->bad_wstat = BAD_R_STAT; 1258 hwif->noprobe = 0; 1259 goto done; 1260 case -4: /* "cdrom" */ 1261 drive->present = 1; 1262 drive->media = ide_cdrom; 1263 /* an ATAPI device ignores DRDY */ 1264 drive->ready_stat = 0; 1265 hwif->noprobe = 0; 1266 goto done; 1267 case -5: /* nodma */ 1268 drive->nodma = 1; 1269 goto done; 1270 case -6: /* "autotune" */ 1271 drive->autotune = IDE_TUNE_AUTO; 1272 goto obsolete_option; 1273 case -7: /* "noautotune" */ 1274 drive->autotune = IDE_TUNE_NOAUTO; 1275 goto obsolete_option; 1276 case -11: /* noflush */ 1277 drive->noflush = 1; 1278 goto done; 1279 case -12: /* "remap" */ 1280 drive->remap_0_to_1 = 1; 1281 goto obsolete_option; 1282 case -13: /* "remap63" */ 1283 drive->sect0 = 63; 1284 goto obsolete_option; 1285 case -14: /* "scsi" */ 1286 drive->scsi = 1; 1287 goto obsolete_option; 1288 case 3: /* cyl,head,sect */ 1289 drive->media = ide_disk; 1290 drive->ready_stat = READY_STAT; 1291 drive->cyl = drive->bios_cyl = vals[0]; 1292 drive->head = drive->bios_head = vals[1]; 1293 drive->sect = drive->bios_sect = vals[2]; 1294 drive->present = 1; 1295 drive->forced_geom = 1; 1296 hwif->noprobe = 0; 1297 goto done; 1298 default: 1299 goto bad_option; 1300 } 1301 } 1302 1303 if (s[0] != 'i' || s[1] != 'd' || s[2] != 'e') 1304 goto bad_option; 1305 /* 1306 * Look for bus speed option: "idebus=" 1307 */ 1308 if (s[3] == 'b' && s[4] == 'u' && s[5] == 's') { 1309 if (match_parm(&s[6], NULL, vals, 1) != 1) 1310 goto bad_option; 1311 if (vals[0] >= 20 && vals[0] <= 66) { 1312 idebus_parameter = vals[0]; 1313 } else 1314 printk(" -- BAD BUS SPEED! Expected value from 20 to 66"); 1315 goto done; 1316 } 1317 /* 1318 * Look for interface options: "idex=" 1319 */ 1320 if (s[3] >= '0' && s[3] <= max_hwif) { 1321 /* 1322 * Be VERY CAREFUL changing this: note hardcoded indexes below 1323 * (-8, -9, -10) are reserved to ease the hardcoding. 1324 */ 1325 static const char *ide_words[] = { 1326 "noprobe", "serialize", "minus3", "minus4", 1327 "reset", "minus6", "ata66", "minus8", "minus9", 1328 "minus10", "four", "qd65xx", "ht6560b", "cmd640_vlb", 1329 "dtc2278", "umc8672", "ali14xx", NULL }; 1330 1331 hw = s[3] - '0'; 1332 hwif = &ide_hwifs[hw]; 1333 i = match_parm(&s[4], ide_words, vals, 3); 1334 1335 /* 1336 * Cryptic check to ensure chipset not already set for hwif. 1337 * Note: we can't depend on hwif->chipset here. 1338 */ 1339 if (i >= -18 && i <= -11) { 1340 /* chipset already specified */ 1341 if (is_chipset_set) 1342 goto bad_option; 1343 /* these drivers are for "ide0=" only */ 1344 if (hw != 0) 1345 goto bad_hwif; 1346 is_chipset_set = 1; 1347 printk("\n"); 1348 } 1349 1350 switch (i) { 1351#ifdef CONFIG_BLK_DEV_ALI14XX 1352 case -17: /* "ali14xx" */ 1353 probe_ali14xx = 1; 1354 goto obsolete_option; 1355#endif 1356#ifdef CONFIG_BLK_DEV_UMC8672 1357 case -16: /* "umc8672" */ 1358 probe_umc8672 = 1; 1359 goto obsolete_option; 1360#endif 1361#ifdef CONFIG_BLK_DEV_DTC2278 1362 case -15: /* "dtc2278" */ 1363 probe_dtc2278 = 1; 1364 goto obsolete_option; 1365#endif 1366#ifdef CONFIG_BLK_DEV_CMD640 1367 case -14: /* "cmd640_vlb" */ 1368 cmd640_vlb = 1; 1369 goto obsolete_option; 1370#endif 1371#ifdef CONFIG_BLK_DEV_HT6560B 1372 case -13: /* "ht6560b" */ 1373 probe_ht6560b = 1; 1374 goto obsolete_option; 1375#endif 1376#ifdef CONFIG_BLK_DEV_QD65XX 1377 case -12: /* "qd65xx" */ 1378 probe_qd65xx = 1; 1379 goto obsolete_option; 1380#endif 1381#ifdef CONFIG_BLK_DEV_4DRIVES 1382 case -11: /* "four" drives on one set of ports */ 1383 { 1384 ide_hwif_t *mate = &ide_hwifs[hw^1]; 1385 mate->drives[0].select.all ^= 0x20; 1386 mate->drives[1].select.all ^= 0x20; 1387 hwif->chipset = mate->chipset = ide_4drives; 1388 mate->irq = hwif->irq; 1389 memcpy(mate->io_ports, hwif->io_ports, sizeof(hwif->io_ports)); 1390 hwif->mate = mate; 1391 mate->mate = hwif; 1392 hwif->serialized = mate->serialized = 1; 1393 goto obsolete_option; 1394 } 1395#endif /* CONFIG_BLK_DEV_4DRIVES */ 1396 case -10: /* minus10 */ 1397 case -9: /* minus9 */ 1398 case -8: /* minus8 */ 1399 case -6: 1400 case -4: 1401 case -3: 1402 goto bad_option; 1403 case -7: /* ata66 */ 1404#ifdef CONFIG_BLK_DEV_IDEPCI 1405 /* 1406 * Use ATA_CBL_PATA40_SHORT so drive side 1407 * cable detection is also overriden. 1408 */ 1409 hwif->cbl = ATA_CBL_PATA40_SHORT; 1410 goto obsolete_option; 1411#else 1412 goto bad_hwif; 1413#endif 1414 case -5: /* "reset" */ 1415 hwif->reset = 1; 1416 goto obsolete_option; 1417 case -2: /* "serialize" */ 1418 hwif->mate = &ide_hwifs[hw^1]; 1419 hwif->mate->mate = hwif; 1420 hwif->serialized = hwif->mate->serialized = 1; 1421 goto obsolete_option; 1422 1423 case -1: /* "noprobe" */ 1424 hwif->noprobe = 1; 1425 goto obsolete_option; 1426 case 0: 1427 case 1: 1428 case 2: 1429 case 3: 1430 goto bad_option; 1431 default: 1432 printk(" -- SUPPORT NOT CONFIGURED IN THIS KERNEL\n"); 1433 return 1; 1434 } 1435 } 1436bad_option: 1437 printk(" -- BAD OPTION\n"); 1438 return 1; 1439obsolete_option: 1440 printk(" -- OBSOLETE OPTION, WILL BE REMOVED SOON!\n"); 1441 return 1; 1442bad_hwif: 1443 printk("-- NOT SUPPORTED ON ide%d", hw); 1444done: 1445 printk("\n"); 1446 return 1; 1447} 1448 1449EXPORT_SYMBOL(ide_lock); 1450 1451static int ide_bus_match(struct device *dev, struct device_driver *drv) 1452{ 1453 return 1; 1454} 1455 1456static char *media_string(ide_drive_t *drive) 1457{ 1458 switch (drive->media) { 1459 case ide_disk: 1460 return "disk"; 1461 case ide_cdrom: 1462 return "cdrom"; 1463 case ide_tape: 1464 return "tape"; 1465 case ide_floppy: 1466 return "floppy"; 1467 case ide_optical: 1468 return "optical"; 1469 default: 1470 return "UNKNOWN"; 1471 } 1472} 1473 1474static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf) 1475{ 1476 ide_drive_t *drive = to_ide_device(dev); 1477 return sprintf(buf, "%s\n", media_string(drive)); 1478} 1479 1480static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf) 1481{ 1482 ide_drive_t *drive = to_ide_device(dev); 1483 return sprintf(buf, "%s\n", drive->name); 1484} 1485 1486static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 1487{ 1488 ide_drive_t *drive = to_ide_device(dev); 1489 return sprintf(buf, "ide:m-%s\n", media_string(drive)); 1490} 1491 1492static ssize_t model_show(struct device *dev, struct device_attribute *attr, 1493 char *buf) 1494{ 1495 ide_drive_t *drive = to_ide_device(dev); 1496 return sprintf(buf, "%s\n", drive->id->model); 1497} 1498 1499static ssize_t firmware_show(struct device *dev, struct device_attribute *attr, 1500 char *buf) 1501{ 1502 ide_drive_t *drive = to_ide_device(dev); 1503 return sprintf(buf, "%s\n", drive->id->fw_rev); 1504} 1505 1506static ssize_t serial_show(struct device *dev, struct device_attribute *attr, 1507 char *buf) 1508{ 1509 ide_drive_t *drive = to_ide_device(dev); 1510 return sprintf(buf, "%s\n", drive->id->serial_no); 1511} 1512 1513static struct device_attribute ide_dev_attrs[] = { 1514 __ATTR_RO(media), 1515 __ATTR_RO(drivename), 1516 __ATTR_RO(modalias), 1517 __ATTR_RO(model), 1518 __ATTR_RO(firmware), 1519 __ATTR(serial, 0400, serial_show, NULL), 1520 __ATTR_NULL 1521}; 1522 1523static int ide_uevent(struct device *dev, struct kobj_uevent_env *env) 1524{ 1525 ide_drive_t *drive = to_ide_device(dev); 1526 1527 add_uevent_var(env, "MEDIA=%s", media_string(drive)); 1528 add_uevent_var(env, "DRIVENAME=%s", drive->name); 1529 add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive)); 1530 return 0; 1531} 1532 1533static int generic_ide_probe(struct device *dev) 1534{ 1535 ide_drive_t *drive = to_ide_device(dev); 1536 ide_driver_t *drv = to_ide_driver(dev->driver); 1537 1538 return drv->probe ? drv->probe(drive) : -ENODEV; 1539} 1540 1541static int generic_ide_remove(struct device *dev) 1542{ 1543 ide_drive_t *drive = to_ide_device(dev); 1544 ide_driver_t *drv = to_ide_driver(dev->driver); 1545 1546 if (drv->remove) 1547 drv->remove(drive); 1548 1549 return 0; 1550} 1551 1552static void generic_ide_shutdown(struct device *dev) 1553{ 1554 ide_drive_t *drive = to_ide_device(dev); 1555 ide_driver_t *drv = to_ide_driver(dev->driver); 1556 1557 if (dev->driver && drv->shutdown) 1558 drv->shutdown(drive); 1559} 1560 1561struct bus_type ide_bus_type = { 1562 .name = "ide", 1563 .match = ide_bus_match, 1564 .uevent = ide_uevent, 1565 .probe = generic_ide_probe, 1566 .remove = generic_ide_remove, 1567 .shutdown = generic_ide_shutdown, 1568 .dev_attrs = ide_dev_attrs, 1569 .suspend = generic_ide_suspend, 1570 .resume = generic_ide_resume, 1571}; 1572 1573EXPORT_SYMBOL_GPL(ide_bus_type); 1574 1575static void ide_port_class_release(struct device *portdev) 1576{ 1577 ide_hwif_t *hwif = dev_get_drvdata(portdev); 1578 1579 put_device(&hwif->gendev); 1580} 1581 1582/* 1583 * This is gets invoked once during initialization, to set *everything* up 1584 */ 1585static int __init ide_init(void) 1586{ 1587 int ret; 1588 1589 printk(KERN_INFO "Uniform Multi-Platform E-IDE driver\n"); 1590 system_bus_speed = ide_system_bus_speed(); 1591 1592 printk(KERN_INFO "ide: Assuming %dMHz system bus speed " 1593 "for PIO modes%s\n", system_bus_speed, 1594 idebus_parameter ? "" : "; override with idebus=xx"); 1595 1596 ret = bus_register(&ide_bus_type); 1597 if (ret < 0) { 1598 printk(KERN_WARNING "IDE: bus_register error: %d\n", ret); 1599 return ret; 1600 } 1601 1602 ide_port_class = class_create(THIS_MODULE, "ide_port"); 1603 if (IS_ERR(ide_port_class)) { 1604 ret = PTR_ERR(ide_port_class); 1605 goto out_port_class; 1606 } 1607 ide_port_class->dev_release = ide_port_class_release; 1608 1609 init_ide_data(); 1610 1611 proc_ide_create(); 1612 1613 return 0; 1614 1615out_port_class: 1616 bus_unregister(&ide_bus_type); 1617 1618 return ret; 1619} 1620 1621#ifdef MODULE 1622static char *options = NULL; 1623module_param(options, charp, 0); 1624MODULE_LICENSE("GPL"); 1625 1626static void __init parse_options (char *line) 1627{ 1628 char *next = line; 1629 1630 if (line == NULL || !*line) 1631 return; 1632 while ((line = next) != NULL) { 1633 if ((next = strchr(line,' ')) != NULL) 1634 *next++ = 0; 1635 if (!ide_setup(line)) 1636 printk (KERN_INFO "Unknown option '%s'\n", line); 1637 } 1638} 1639 1640int __init init_module (void) 1641{ 1642 parse_options(options); 1643 return ide_init(); 1644} 1645 1646void __exit cleanup_module (void) 1647{ 1648 int index; 1649 1650 for (index = 0; index < MAX_HWIFS; ++index) 1651 ide_unregister(index, 0, 0); 1652 1653 proc_ide_destroy(); 1654 1655 class_destroy(ide_port_class); 1656 1657 bus_unregister(&ide_bus_type); 1658} 1659 1660#else /* !MODULE */ 1661 1662__setup("", ide_setup); 1663 1664module_init(ide_init); 1665 1666#endif /* MODULE */ 1667