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