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