ide.c revision 123995b97136cb41fa282f0ed2385f2c8066df96
1/* 2 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below) 3 * Copyright (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz 4 */ 5 6/* 7 * Mostly written by Mark Lord <mlord@pobox.com> 8 * and Gadi Oxman <gadio@netvision.net.il> 9 * and Andre Hedrick <andre@linux-ide.org> 10 * 11 * See linux/MAINTAINERS for address of current maintainer. 12 * 13 * This is the multiple IDE interface driver, as evolved from hd.c. 14 * It supports up to MAX_HWIFS IDE interfaces, on one or more IRQs 15 * (usually 14 & 15). 16 * There can be up to two drives per interface, as per the ATA-2 spec. 17 * 18 * ... 19 * 20 * From hd.c: 21 * | 22 * | It traverses the request-list, using interrupts to jump between functions. 23 * | As nearly all functions can be called within interrupts, we may not sleep. 24 * | Special care is recommended. Have Fun! 25 * | 26 * | modified by Drew Eckhardt to check nr of hd's from the CMOS. 27 * | 28 * | Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug 29 * | in the early extended-partition checks and added DM partitions. 30 * | 31 * | Early work on error handling by Mika Liljeberg (liljeber@cs.Helsinki.FI). 32 * | 33 * | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads", 34 * | and general streamlining by Mark Lord (mlord@pobox.com). 35 * 36 * October, 1994 -- Complete line-by-line overhaul for linux 1.1.x, by: 37 * 38 * Mark Lord (mlord@pobox.com) (IDE Perf.Pkg) 39 * Delman Lee (delman@ieee.org) ("Mr. atdisk2") 40 * Scott Snyder (snyder@fnald0.fnal.gov) (ATAPI IDE cd-rom) 41 * 42 * This was a rewrite of just about everything from hd.c, though some original 43 * code is still sprinkled about. Think of it as a major evolution, with 44 * inspiration from lots of linux users, esp. hamish@zot.apana.org.au 45 */ 46 47#include <linux/module.h> 48#include <linux/types.h> 49#include <linux/string.h> 50#include <linux/kernel.h> 51#include <linux/interrupt.h> 52#include <linux/major.h> 53#include <linux/errno.h> 54#include <linux/genhd.h> 55#include <linux/slab.h> 56#include <linux/init.h> 57#include <linux/pci.h> 58#include <linux/ide.h> 59#include <linux/hdreg.h> 60#include <linux/completion.h> 61#include <linux/device.h> 62 63 64/* default maximum number of failures */ 65#define IDE_DEFAULT_MAX_FAILURES 1 66 67struct class *ide_port_class; 68 69static const u8 ide_hwif_to_major[] = { IDE0_MAJOR, IDE1_MAJOR, 70 IDE2_MAJOR, IDE3_MAJOR, 71 IDE4_MAJOR, IDE5_MAJOR, 72 IDE6_MAJOR, IDE7_MAJOR, 73 IDE8_MAJOR, IDE9_MAJOR }; 74 75DEFINE_MUTEX(ide_cfg_mtx); 76 77__cacheline_aligned_in_smp DEFINE_SPINLOCK(ide_lock); 78EXPORT_SYMBOL(ide_lock); 79 80static void ide_port_init_devices_data(ide_hwif_t *); 81 82/* 83 * Do not even *think* about calling this! 84 */ 85void ide_init_port_data(ide_hwif_t *hwif, unsigned int index) 86{ 87 /* bulk initialize hwif & drive info with zeros */ 88 memset(hwif, 0, sizeof(ide_hwif_t)); 89 90 /* fill in any non-zero initial values */ 91 hwif->index = index; 92 hwif->major = ide_hwif_to_major[index]; 93 94 hwif->name[0] = 'i'; 95 hwif->name[1] = 'd'; 96 hwif->name[2] = 'e'; 97 hwif->name[3] = '0' + index; 98 99 init_completion(&hwif->gendev_rel_comp); 100 101 hwif->tp_ops = &default_tp_ops; 102 103 ide_port_init_devices_data(hwif); 104} 105 106static void ide_port_init_devices_data(ide_hwif_t *hwif) 107{ 108 int unit; 109 110 for (unit = 0; unit < MAX_DRIVES; ++unit) { 111 ide_drive_t *drive = &hwif->drives[unit]; 112 u8 j = (hwif->index * MAX_DRIVES) + unit; 113 114 memset(drive, 0, sizeof(*drive)); 115 116 drive->media = ide_disk; 117 drive->select.all = (unit<<4)|0xa0; 118 drive->hwif = hwif; 119 drive->ready_stat = ATA_DRDY; 120 drive->bad_wstat = BAD_W_STAT; 121 drive->special.b.recalibrate = 1; 122 drive->special.b.set_geometry = 1; 123 drive->name[0] = 'h'; 124 drive->name[1] = 'd'; 125 drive->name[2] = 'a' + j; 126 drive->max_failures = IDE_DEFAULT_MAX_FAILURES; 127 128 INIT_LIST_HEAD(&drive->list); 129 init_completion(&drive->gendev_rel_comp); 130 } 131} 132 133/* Called with ide_lock held. */ 134static void __ide_port_unregister_devices(ide_hwif_t *hwif) 135{ 136 int i; 137 138 for (i = 0; i < MAX_DRIVES; i++) { 139 ide_drive_t *drive = &hwif->drives[i]; 140 141 if (drive->dev_flags & IDE_DFLAG_PRESENT) { 142 spin_unlock_irq(&ide_lock); 143 device_unregister(&drive->gendev); 144 wait_for_completion(&drive->gendev_rel_comp); 145 spin_lock_irq(&ide_lock); 146 } 147 } 148} 149 150void ide_port_unregister_devices(ide_hwif_t *hwif) 151{ 152 mutex_lock(&ide_cfg_mtx); 153 spin_lock_irq(&ide_lock); 154 __ide_port_unregister_devices(hwif); 155 hwif->present = 0; 156 ide_port_init_devices_data(hwif); 157 spin_unlock_irq(&ide_lock); 158 mutex_unlock(&ide_cfg_mtx); 159} 160EXPORT_SYMBOL_GPL(ide_port_unregister_devices); 161 162/** 163 * ide_unregister - free an IDE interface 164 * @hwif: IDE interface 165 * 166 * Perform the final unregister of an IDE interface. At the moment 167 * we don't refcount interfaces so this will also get split up. 168 * 169 * Locking: 170 * The caller must not hold the IDE locks 171 * The drive present/vanishing is not yet properly locked 172 * Take care with the callbacks. These have been split to avoid 173 * deadlocking the IDE layer. The shutdown callback is called 174 * before we take the lock and free resources. It is up to the 175 * caller to be sure there is no pending I/O here, and that 176 * the interface will not be reopened (present/vanishing locking 177 * isn't yet done BTW). After we commit to the final kill we 178 * call the cleanup callback with the ide locks held. 179 * 180 * Unregister restores the hwif structures to the default state. 181 * This is raving bonkers. 182 */ 183 184void ide_unregister(ide_hwif_t *hwif) 185{ 186 ide_hwif_t *g; 187 ide_hwgroup_t *hwgroup; 188 int irq_count = 0; 189 190 BUG_ON(in_interrupt()); 191 BUG_ON(irqs_disabled()); 192 193 mutex_lock(&ide_cfg_mtx); 194 195 spin_lock_irq(&ide_lock); 196 if (hwif->present) { 197 __ide_port_unregister_devices(hwif); 198 hwif->present = 0; 199 } 200 spin_unlock_irq(&ide_lock); 201 202 ide_proc_unregister_port(hwif); 203 204 hwgroup = hwif->hwgroup; 205 /* 206 * free the irq if we were the only hwif using it 207 */ 208 g = hwgroup->hwif; 209 do { 210 if (g->irq == hwif->irq) 211 ++irq_count; 212 g = g->next; 213 } while (g != hwgroup->hwif); 214 if (irq_count == 1) 215 free_irq(hwif->irq, hwgroup); 216 217 ide_remove_port_from_hwgroup(hwif); 218 219 device_unregister(hwif->portdev); 220 device_unregister(&hwif->gendev); 221 wait_for_completion(&hwif->gendev_rel_comp); 222 223 /* 224 * Remove us from the kernel's knowledge 225 */ 226 blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS); 227 kfree(hwif->sg_table); 228 unregister_blkdev(hwif->major, hwif->name); 229 230 if (hwif->dma_base) 231 ide_release_dma_engine(hwif); 232 233 mutex_unlock(&ide_cfg_mtx); 234} 235 236void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw) 237{ 238 memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports)); 239 hwif->irq = hw->irq; 240 hwif->chipset = hw->chipset; 241 hwif->dev = hw->dev; 242 hwif->gendev.parent = hw->parent ? hw->parent : hw->dev; 243 hwif->ack_intr = hw->ack_intr; 244 hwif->config_data = hw->config; 245} 246 247/* 248 * Locks for IDE setting functionality 249 */ 250 251DEFINE_MUTEX(ide_setting_mtx); 252 253ide_devset_get(io_32bit, io_32bit); 254 255static int set_io_32bit(ide_drive_t *drive, int arg) 256{ 257 if (drive->dev_flags & IDE_DFLAG_NO_IO_32BIT) 258 return -EPERM; 259 260 if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1)) 261 return -EINVAL; 262 263 drive->io_32bit = arg; 264 265 return 0; 266} 267 268ide_devset_get_flag(ksettings, IDE_DFLAG_KEEP_SETTINGS); 269 270static int set_ksettings(ide_drive_t *drive, int arg) 271{ 272 if (arg < 0 || arg > 1) 273 return -EINVAL; 274 275 if (arg) 276 drive->dev_flags |= IDE_DFLAG_KEEP_SETTINGS; 277 else 278 drive->dev_flags &= ~IDE_DFLAG_KEEP_SETTINGS; 279 280 return 0; 281} 282 283ide_devset_get_flag(using_dma, IDE_DFLAG_USING_DMA); 284 285static int set_using_dma(ide_drive_t *drive, int arg) 286{ 287#ifdef CONFIG_BLK_DEV_IDEDMA 288 int err = -EPERM; 289 290 if (arg < 0 || arg > 1) 291 return -EINVAL; 292 293 if (ata_id_has_dma(drive->id) == 0) 294 goto out; 295 296 if (drive->hwif->dma_ops == NULL) 297 goto out; 298 299 err = 0; 300 301 if (arg) { 302 if (ide_set_dma(drive)) 303 err = -EIO; 304 } else 305 ide_dma_off(drive); 306 307out: 308 return err; 309#else 310 if (arg < 0 || arg > 1) 311 return -EINVAL; 312 313 return -EPERM; 314#endif 315} 316 317static int set_pio_mode(ide_drive_t *drive, int arg) 318{ 319 struct request *rq; 320 ide_hwif_t *hwif = drive->hwif; 321 const struct ide_port_ops *port_ops = hwif->port_ops; 322 323 if (arg < 0 || arg > 255) 324 return -EINVAL; 325 326 if (port_ops == NULL || port_ops->set_pio_mode == NULL || 327 (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)) 328 return -ENOSYS; 329 330 if (drive->special.b.set_tune) 331 return -EBUSY; 332 333 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 334 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 335 336 drive->tune_req = (u8) arg; 337 drive->special.b.set_tune = 1; 338 339 blk_execute_rq(drive->queue, NULL, rq, 0); 340 blk_put_request(rq); 341 342 return 0; 343} 344 345ide_devset_get_flag(unmaskirq, IDE_DFLAG_UNMASK); 346 347static int set_unmaskirq(ide_drive_t *drive, int arg) 348{ 349 if (drive->dev_flags & IDE_DFLAG_NO_UNMASK) 350 return -EPERM; 351 352 if (arg < 0 || arg > 1) 353 return -EINVAL; 354 355 if (arg) 356 drive->dev_flags |= IDE_DFLAG_UNMASK; 357 else 358 drive->dev_flags &= ~IDE_DFLAG_UNMASK; 359 360 return 0; 361} 362 363#define ide_gen_devset_rw(_name, _func) \ 364__IDE_DEVSET(_name, DS_SYNC, get_##_func, set_##_func) 365 366ide_gen_devset_rw(io_32bit, io_32bit); 367ide_gen_devset_rw(keepsettings, ksettings); 368ide_gen_devset_rw(unmaskirq, unmaskirq); 369ide_gen_devset_rw(using_dma, using_dma); 370__IDE_DEVSET(pio_mode, 0, NULL, set_pio_mode); 371 372static int generic_ide_suspend(struct device *dev, pm_message_t mesg) 373{ 374 ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive); 375 ide_hwif_t *hwif = HWIF(drive); 376 struct request *rq; 377 struct request_pm_state rqpm; 378 ide_task_t args; 379 int ret; 380 381 /* call ACPI _GTM only once */ 382 if ((drive->dn & 1) == 0 || pair == NULL) 383 ide_acpi_get_timing(hwif); 384 385 memset(&rqpm, 0, sizeof(rqpm)); 386 memset(&args, 0, sizeof(args)); 387 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 388 rq->cmd_type = REQ_TYPE_PM_SUSPEND; 389 rq->special = &args; 390 rq->data = &rqpm; 391 rqpm.pm_step = IDE_PM_START_SUSPEND; 392 if (mesg.event == PM_EVENT_PRETHAW) 393 mesg.event = PM_EVENT_FREEZE; 394 rqpm.pm_state = mesg.event; 395 396 ret = blk_execute_rq(drive->queue, NULL, rq, 0); 397 blk_put_request(rq); 398 399 /* call ACPI _PS3 only after both devices are suspended */ 400 if (ret == 0 && ((drive->dn & 1) || pair == NULL)) 401 ide_acpi_set_state(hwif, 0); 402 403 return ret; 404} 405 406static int generic_ide_resume(struct device *dev) 407{ 408 ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive); 409 ide_hwif_t *hwif = HWIF(drive); 410 struct request *rq; 411 struct request_pm_state rqpm; 412 ide_task_t args; 413 int err; 414 415 /* call ACPI _PS0 / _STM only once */ 416 if ((drive->dn & 1) == 0 || pair == NULL) { 417 ide_acpi_set_state(hwif, 1); 418 ide_acpi_push_timing(hwif); 419 } 420 421 ide_acpi_exec_tfs(drive); 422 423 memset(&rqpm, 0, sizeof(rqpm)); 424 memset(&args, 0, sizeof(args)); 425 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 426 rq->cmd_type = REQ_TYPE_PM_RESUME; 427 rq->cmd_flags |= REQ_PREEMPT; 428 rq->special = &args; 429 rq->data = &rqpm; 430 rqpm.pm_step = IDE_PM_START_RESUME; 431 rqpm.pm_state = PM_EVENT_ON; 432 433 err = blk_execute_rq(drive->queue, NULL, rq, 1); 434 blk_put_request(rq); 435 436 if (err == 0 && dev->driver) { 437 ide_driver_t *drv = to_ide_driver(dev->driver); 438 439 if (drv->resume) 440 drv->resume(drive); 441 } 442 443 return err; 444} 445 446/** 447 * ide_device_get - get an additional reference to a ide_drive_t 448 * @drive: device to get a reference to 449 * 450 * Gets a reference to the ide_drive_t and increments the use count of the 451 * underlying LLDD module. 452 */ 453int ide_device_get(ide_drive_t *drive) 454{ 455 struct device *host_dev; 456 struct module *module; 457 458 if (!get_device(&drive->gendev)) 459 return -ENXIO; 460 461 host_dev = drive->hwif->host->dev[0]; 462 module = host_dev ? host_dev->driver->owner : NULL; 463 464 if (module && !try_module_get(module)) { 465 put_device(&drive->gendev); 466 return -ENXIO; 467 } 468 469 return 0; 470} 471EXPORT_SYMBOL_GPL(ide_device_get); 472 473/** 474 * ide_device_put - release a reference to a ide_drive_t 475 * @drive: device to release a reference on 476 * 477 * Release a reference to the ide_drive_t and decrements the use count of 478 * the underlying LLDD module. 479 */ 480void ide_device_put(ide_drive_t *drive) 481{ 482#ifdef CONFIG_MODULE_UNLOAD 483 struct device *host_dev = drive->hwif->host->dev[0]; 484 struct module *module = host_dev ? host_dev->driver->owner : NULL; 485 486 if (module) 487 module_put(module); 488#endif 489 put_device(&drive->gendev); 490} 491EXPORT_SYMBOL_GPL(ide_device_put); 492 493static int ide_bus_match(struct device *dev, struct device_driver *drv) 494{ 495 return 1; 496} 497 498static char *media_string(ide_drive_t *drive) 499{ 500 switch (drive->media) { 501 case ide_disk: 502 return "disk"; 503 case ide_cdrom: 504 return "cdrom"; 505 case ide_tape: 506 return "tape"; 507 case ide_floppy: 508 return "floppy"; 509 case ide_optical: 510 return "optical"; 511 default: 512 return "UNKNOWN"; 513 } 514} 515 516static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf) 517{ 518 ide_drive_t *drive = to_ide_device(dev); 519 return sprintf(buf, "%s\n", media_string(drive)); 520} 521 522static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf) 523{ 524 ide_drive_t *drive = to_ide_device(dev); 525 return sprintf(buf, "%s\n", drive->name); 526} 527 528static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 529{ 530 ide_drive_t *drive = to_ide_device(dev); 531 return sprintf(buf, "ide:m-%s\n", media_string(drive)); 532} 533 534static ssize_t model_show(struct device *dev, struct device_attribute *attr, 535 char *buf) 536{ 537 ide_drive_t *drive = to_ide_device(dev); 538 return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_PROD]); 539} 540 541static ssize_t firmware_show(struct device *dev, struct device_attribute *attr, 542 char *buf) 543{ 544 ide_drive_t *drive = to_ide_device(dev); 545 return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_FW_REV]); 546} 547 548static ssize_t serial_show(struct device *dev, struct device_attribute *attr, 549 char *buf) 550{ 551 ide_drive_t *drive = to_ide_device(dev); 552 return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_SERNO]); 553} 554 555static struct device_attribute ide_dev_attrs[] = { 556 __ATTR_RO(media), 557 __ATTR_RO(drivename), 558 __ATTR_RO(modalias), 559 __ATTR_RO(model), 560 __ATTR_RO(firmware), 561 __ATTR(serial, 0400, serial_show, NULL), 562 __ATTR_NULL 563}; 564 565static int ide_uevent(struct device *dev, struct kobj_uevent_env *env) 566{ 567 ide_drive_t *drive = to_ide_device(dev); 568 569 add_uevent_var(env, "MEDIA=%s", media_string(drive)); 570 add_uevent_var(env, "DRIVENAME=%s", drive->name); 571 add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive)); 572 return 0; 573} 574 575static int generic_ide_probe(struct device *dev) 576{ 577 ide_drive_t *drive = to_ide_device(dev); 578 ide_driver_t *drv = to_ide_driver(dev->driver); 579 580 return drv->probe ? drv->probe(drive) : -ENODEV; 581} 582 583static int generic_ide_remove(struct device *dev) 584{ 585 ide_drive_t *drive = to_ide_device(dev); 586 ide_driver_t *drv = to_ide_driver(dev->driver); 587 588 if (drv->remove) 589 drv->remove(drive); 590 591 return 0; 592} 593 594static void generic_ide_shutdown(struct device *dev) 595{ 596 ide_drive_t *drive = to_ide_device(dev); 597 ide_driver_t *drv = to_ide_driver(dev->driver); 598 599 if (dev->driver && drv->shutdown) 600 drv->shutdown(drive); 601} 602 603struct bus_type ide_bus_type = { 604 .name = "ide", 605 .match = ide_bus_match, 606 .uevent = ide_uevent, 607 .probe = generic_ide_probe, 608 .remove = generic_ide_remove, 609 .shutdown = generic_ide_shutdown, 610 .dev_attrs = ide_dev_attrs, 611 .suspend = generic_ide_suspend, 612 .resume = generic_ide_resume, 613}; 614 615EXPORT_SYMBOL_GPL(ide_bus_type); 616 617int ide_vlb_clk; 618EXPORT_SYMBOL_GPL(ide_vlb_clk); 619 620module_param_named(vlb_clock, ide_vlb_clk, int, 0); 621MODULE_PARM_DESC(vlb_clock, "VLB clock frequency (in MHz)"); 622 623int ide_pci_clk; 624EXPORT_SYMBOL_GPL(ide_pci_clk); 625 626module_param_named(pci_clock, ide_pci_clk, int, 0); 627MODULE_PARM_DESC(pci_clock, "PCI bus clock frequency (in MHz)"); 628 629static int ide_set_dev_param_mask(const char *s, struct kernel_param *kp) 630{ 631 int a, b, i, j = 1; 632 unsigned int *dev_param_mask = (unsigned int *)kp->arg; 633 634 if (sscanf(s, "%d.%d:%d", &a, &b, &j) != 3 && 635 sscanf(s, "%d.%d", &a, &b) != 2) 636 return -EINVAL; 637 638 i = a * MAX_DRIVES + b; 639 640 if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1) 641 return -EINVAL; 642 643 if (j) 644 *dev_param_mask |= (1 << i); 645 else 646 *dev_param_mask &= (1 << i); 647 648 return 0; 649} 650 651static unsigned int ide_nodma; 652 653module_param_call(nodma, ide_set_dev_param_mask, NULL, &ide_nodma, 0); 654MODULE_PARM_DESC(nodma, "disallow DMA for a device"); 655 656static unsigned int ide_noflush; 657 658module_param_call(noflush, ide_set_dev_param_mask, NULL, &ide_noflush, 0); 659MODULE_PARM_DESC(noflush, "disable flush requests for a device"); 660 661static unsigned int ide_noprobe; 662 663module_param_call(noprobe, ide_set_dev_param_mask, NULL, &ide_noprobe, 0); 664MODULE_PARM_DESC(noprobe, "skip probing for a device"); 665 666static unsigned int ide_nowerr; 667 668module_param_call(nowerr, ide_set_dev_param_mask, NULL, &ide_nowerr, 0); 669MODULE_PARM_DESC(nowerr, "ignore the ATA_DF bit for a device"); 670 671static unsigned int ide_cdroms; 672 673module_param_call(cdrom, ide_set_dev_param_mask, NULL, &ide_cdroms, 0); 674MODULE_PARM_DESC(cdrom, "force device as a CD-ROM"); 675 676struct chs_geom { 677 unsigned int cyl; 678 u8 head; 679 u8 sect; 680}; 681 682static unsigned int ide_disks; 683static struct chs_geom ide_disks_chs[MAX_HWIFS * MAX_DRIVES]; 684 685static int ide_set_disk_chs(const char *str, struct kernel_param *kp) 686{ 687 int a, b, c = 0, h = 0, s = 0, i, j = 1; 688 689 if (sscanf(str, "%d.%d:%d,%d,%d", &a, &b, &c, &h, &s) != 5 && 690 sscanf(str, "%d.%d:%d", &a, &b, &j) != 3) 691 return -EINVAL; 692 693 i = a * MAX_DRIVES + b; 694 695 if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1) 696 return -EINVAL; 697 698 if (c > INT_MAX || h > 255 || s > 255) 699 return -EINVAL; 700 701 if (j) 702 ide_disks |= (1 << i); 703 else 704 ide_disks &= (1 << i); 705 706 ide_disks_chs[i].cyl = c; 707 ide_disks_chs[i].head = h; 708 ide_disks_chs[i].sect = s; 709 710 return 0; 711} 712 713module_param_call(chs, ide_set_disk_chs, NULL, NULL, 0); 714MODULE_PARM_DESC(chs, "force device as a disk (using CHS)"); 715 716static void ide_dev_apply_params(ide_drive_t *drive, u8 unit) 717{ 718 int i = drive->hwif->index * MAX_DRIVES + unit; 719 720 if (ide_nodma & (1 << i)) { 721 printk(KERN_INFO "ide: disallowing DMA for %s\n", drive->name); 722 drive->dev_flags |= IDE_DFLAG_NODMA; 723 } 724 if (ide_noflush & (1 << i)) { 725 printk(KERN_INFO "ide: disabling flush requests for %s\n", 726 drive->name); 727 drive->dev_flags |= IDE_DFLAG_NOFLUSH; 728 } 729 if (ide_noprobe & (1 << i)) { 730 printk(KERN_INFO "ide: skipping probe for %s\n", drive->name); 731 drive->dev_flags |= IDE_DFLAG_NOPROBE; 732 } 733 if (ide_nowerr & (1 << i)) { 734 printk(KERN_INFO "ide: ignoring the ATA_DF bit for %s\n", 735 drive->name); 736 drive->bad_wstat = BAD_R_STAT; 737 } 738 if (ide_cdroms & (1 << i)) { 739 printk(KERN_INFO "ide: forcing %s as a CD-ROM\n", drive->name); 740 drive->dev_flags |= IDE_DFLAG_PRESENT; 741 drive->media = ide_cdrom; 742 /* an ATAPI device ignores DRDY */ 743 drive->ready_stat = 0; 744 } 745 if (ide_disks & (1 << i)) { 746 drive->cyl = drive->bios_cyl = ide_disks_chs[i].cyl; 747 drive->head = drive->bios_head = ide_disks_chs[i].head; 748 drive->sect = drive->bios_sect = ide_disks_chs[i].sect; 749 750 printk(KERN_INFO "ide: forcing %s as a disk (%d/%d/%d)\n", 751 drive->name, 752 drive->cyl, drive->head, drive->sect); 753 754 drive->dev_flags |= IDE_DFLAG_FORCED_GEOM | IDE_DFLAG_PRESENT; 755 drive->media = ide_disk; 756 drive->ready_stat = ATA_DRDY; 757 } 758} 759 760static unsigned int ide_ignore_cable; 761 762static int ide_set_ignore_cable(const char *s, struct kernel_param *kp) 763{ 764 int i, j = 1; 765 766 if (sscanf(s, "%d:%d", &i, &j) != 2 && sscanf(s, "%d", &i) != 1) 767 return -EINVAL; 768 769 if (i >= MAX_HWIFS || j < 0 || j > 1) 770 return -EINVAL; 771 772 if (j) 773 ide_ignore_cable |= (1 << i); 774 else 775 ide_ignore_cable &= (1 << i); 776 777 return 0; 778} 779 780module_param_call(ignore_cable, ide_set_ignore_cable, NULL, NULL, 0); 781MODULE_PARM_DESC(ignore_cable, "ignore cable detection"); 782 783void ide_port_apply_params(ide_hwif_t *hwif) 784{ 785 int i; 786 787 if (ide_ignore_cable & (1 << hwif->index)) { 788 printk(KERN_INFO "ide: ignoring cable detection for %s\n", 789 hwif->name); 790 hwif->cbl = ATA_CBL_PATA40_SHORT; 791 } 792 793 for (i = 0; i < MAX_DRIVES; i++) 794 ide_dev_apply_params(&hwif->drives[i], i); 795} 796 797/* 798 * This is gets invoked once during initialization, to set *everything* up 799 */ 800static int __init ide_init(void) 801{ 802 int ret; 803 804 printk(KERN_INFO "Uniform Multi-Platform E-IDE driver\n"); 805 806 ret = bus_register(&ide_bus_type); 807 if (ret < 0) { 808 printk(KERN_WARNING "IDE: bus_register error: %d\n", ret); 809 return ret; 810 } 811 812 ide_port_class = class_create(THIS_MODULE, "ide_port"); 813 if (IS_ERR(ide_port_class)) { 814 ret = PTR_ERR(ide_port_class); 815 goto out_port_class; 816 } 817 818 proc_ide_create(); 819 820 return 0; 821 822out_port_class: 823 bus_unregister(&ide_bus_type); 824 825 return ret; 826} 827 828static void __exit ide_exit(void) 829{ 830 proc_ide_destroy(); 831 832 class_destroy(ide_port_class); 833 834 bus_unregister(&ide_bus_type); 835} 836 837module_init(ide_init); 838module_exit(ide_exit); 839 840MODULE_LICENSE("GPL"); 841