ide.c revision 232595eaff951e96cabe5e85fed35f66b72ff51e
1/* 2 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below) 3 * Copyrifht (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz 4 */ 5 6/* 7 * Mostly written by Mark Lord <mlord@pobox.com> 8 * and Gadi Oxman <gadio@netvision.net.il> 9 * and Andre Hedrick <andre@linux-ide.org> 10 * 11 * See linux/MAINTAINERS for address of current maintainer. 12 * 13 * This is the multiple IDE interface driver, as evolved from hd.c. 14 * It supports up to MAX_HWIFS IDE interfaces, on one or more IRQs 15 * (usually 14 & 15). 16 * There can be up to two drives per interface, as per the ATA-2 spec. 17 * 18 * ... 19 * 20 * From hd.c: 21 * | 22 * | It traverses the request-list, using interrupts to jump between functions. 23 * | As nearly all functions can be called within interrupts, we may not sleep. 24 * | Special care is recommended. Have Fun! 25 * | 26 * | modified by Drew Eckhardt to check nr of hd's from the CMOS. 27 * | 28 * | Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug 29 * | in the early extended-partition checks and added DM partitions. 30 * | 31 * | Early work on error handling by Mika Liljeberg (liljeber@cs.Helsinki.FI). 32 * | 33 * | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads", 34 * | and general streamlining by Mark Lord (mlord@pobox.com). 35 * 36 * October, 1994 -- Complete line-by-line overhaul for linux 1.1.x, by: 37 * 38 * Mark Lord (mlord@pobox.com) (IDE Perf.Pkg) 39 * Delman Lee (delman@ieee.org) ("Mr. atdisk2") 40 * Scott Snyder (snyder@fnald0.fnal.gov) (ATAPI IDE cd-rom) 41 * 42 * This was a rewrite of just about everything from hd.c, though some original 43 * code is still sprinkled about. Think of it as a major evolution, with 44 * inspiration from lots of linux users, esp. hamish@zot.apana.org.au 45 */ 46 47#define _IDE_C /* Tell ide.h it's really us */ 48 49#include <linux/module.h> 50#include <linux/types.h> 51#include <linux/string.h> 52#include <linux/kernel.h> 53#include <linux/timer.h> 54#include <linux/mm.h> 55#include <linux/interrupt.h> 56#include <linux/major.h> 57#include <linux/errno.h> 58#include <linux/genhd.h> 59#include <linux/blkpg.h> 60#include <linux/slab.h> 61#include <linux/init.h> 62#include <linux/pci.h> 63#include <linux/delay.h> 64#include <linux/ide.h> 65#include <linux/completion.h> 66#include <linux/reboot.h> 67#include <linux/cdrom.h> 68#include <linux/seq_file.h> 69#include <linux/device.h> 70#include <linux/bitops.h> 71 72#include <asm/byteorder.h> 73#include <asm/irq.h> 74#include <asm/uaccess.h> 75#include <asm/io.h> 76 77 78/* default maximum number of failures */ 79#define IDE_DEFAULT_MAX_FAILURES 1 80 81struct class *ide_port_class; 82 83static const u8 ide_hwif_to_major[] = { IDE0_MAJOR, IDE1_MAJOR, 84 IDE2_MAJOR, IDE3_MAJOR, 85 IDE4_MAJOR, IDE5_MAJOR, 86 IDE6_MAJOR, IDE7_MAJOR, 87 IDE8_MAJOR, IDE9_MAJOR }; 88 89DEFINE_MUTEX(ide_cfg_mtx); 90 __cacheline_aligned_in_smp DEFINE_SPINLOCK(ide_lock); 91 92int noautodma = 0; 93 94ide_hwif_t ide_hwifs[MAX_HWIFS]; /* master data repository */ 95 96static void ide_port_init_devices_data(ide_hwif_t *); 97 98/* 99 * Do not even *think* about calling this! 100 */ 101void ide_init_port_data(ide_hwif_t *hwif, unsigned int index) 102{ 103 /* bulk initialize hwif & drive info with zeros */ 104 memset(hwif, 0, sizeof(ide_hwif_t)); 105 106 /* fill in any non-zero initial values */ 107 hwif->index = index; 108 hwif->major = ide_hwif_to_major[index]; 109 110 hwif->name[0] = 'i'; 111 hwif->name[1] = 'd'; 112 hwif->name[2] = 'e'; 113 hwif->name[3] = '0' + index; 114 115 hwif->bus_state = BUSSTATE_ON; 116 117 init_completion(&hwif->gendev_rel_comp); 118 119 default_hwif_iops(hwif); 120 default_hwif_transport(hwif); 121 122 ide_port_init_devices_data(hwif); 123} 124EXPORT_SYMBOL_GPL(ide_init_port_data); 125 126static void ide_port_init_devices_data(ide_hwif_t *hwif) 127{ 128 int unit; 129 130 for (unit = 0; unit < MAX_DRIVES; ++unit) { 131 ide_drive_t *drive = &hwif->drives[unit]; 132 u8 j = (hwif->index * MAX_DRIVES) + unit; 133 134 memset(drive, 0, sizeof(*drive)); 135 136 drive->media = ide_disk; 137 drive->select.all = (unit<<4)|0xa0; 138 drive->hwif = hwif; 139 drive->ctl = 0x08; 140 drive->ready_stat = READY_STAT; 141 drive->bad_wstat = BAD_W_STAT; 142 drive->special.b.recalibrate = 1; 143 drive->special.b.set_geometry = 1; 144 drive->name[0] = 'h'; 145 drive->name[1] = 'd'; 146 drive->name[2] = 'a' + j; 147 drive->max_failures = IDE_DEFAULT_MAX_FAILURES; 148 149 INIT_LIST_HEAD(&drive->list); 150 init_completion(&drive->gendev_rel_comp); 151 } 152} 153 154/* 155 * init_ide_data() sets reasonable default values into all fields 156 * of all instances of the hwifs and drives, but only on the first call. 157 * Subsequent calls have no effect (they don't wipe out anything). 158 * 159 * This routine is normally called at driver initialization time, 160 * but may also be called MUCH earlier during kernel "command-line" 161 * parameter processing. As such, we cannot depend on any other parts 162 * of the kernel (such as memory allocation) to be functioning yet. 163 * 164 * This is too bad, as otherwise we could dynamically allocate the 165 * ide_drive_t structs as needed, rather than always consuming memory 166 * for the max possible number (MAX_HWIFS * MAX_DRIVES) of them. 167 * 168 * FIXME: We should stuff the setup data into __init and copy the 169 * relevant hwifs/allocate them properly during boot. 170 */ 171#define MAGIC_COOKIE 0x12345678 172static void __init init_ide_data (void) 173{ 174 unsigned int index; 175 static unsigned long magic_cookie = MAGIC_COOKIE; 176 177 if (magic_cookie != MAGIC_COOKIE) 178 return; /* already initialized */ 179 magic_cookie = 0; 180 181 /* Initialise all interface structures */ 182 for (index = 0; index < MAX_HWIFS; ++index) { 183 ide_hwif_t *hwif = &ide_hwifs[index]; 184 185 ide_init_port_data(hwif, index); 186 } 187} 188 189void ide_remove_port_from_hwgroup(ide_hwif_t *hwif) 190{ 191 ide_hwgroup_t *hwgroup = hwif->hwgroup; 192 193 spin_lock_irq(&ide_lock); 194 /* 195 * Remove us from the hwgroup, and free 196 * the hwgroup if we were the only member 197 */ 198 if (hwif->next == hwif) { 199 BUG_ON(hwgroup->hwif != hwif); 200 kfree(hwgroup); 201 } else { 202 /* There is another interface in hwgroup. 203 * Unlink us, and set hwgroup->drive and ->hwif to 204 * something sane. 205 */ 206 ide_hwif_t *g = hwgroup->hwif; 207 208 while (g->next != hwif) 209 g = g->next; 210 g->next = hwif->next; 211 if (hwgroup->hwif == hwif) { 212 /* Chose a random hwif for hwgroup->hwif. 213 * It's guaranteed that there are no drives 214 * left in the hwgroup. 215 */ 216 BUG_ON(hwgroup->drive != NULL); 217 hwgroup->hwif = g; 218 } 219 BUG_ON(hwgroup->hwif == hwif); 220 } 221 spin_unlock_irq(&ide_lock); 222} 223 224/* Called with ide_lock held. */ 225static void __ide_port_unregister_devices(ide_hwif_t *hwif) 226{ 227 int i; 228 229 for (i = 0; i < MAX_DRIVES; i++) { 230 ide_drive_t *drive = &hwif->drives[i]; 231 232 if (drive->present) { 233 spin_unlock_irq(&ide_lock); 234 device_unregister(&drive->gendev); 235 wait_for_completion(&drive->gendev_rel_comp); 236 spin_lock_irq(&ide_lock); 237 } 238 } 239} 240 241void ide_port_unregister_devices(ide_hwif_t *hwif) 242{ 243 mutex_lock(&ide_cfg_mtx); 244 spin_lock_irq(&ide_lock); 245 __ide_port_unregister_devices(hwif); 246 hwif->present = 0; 247 ide_port_init_devices_data(hwif); 248 spin_unlock_irq(&ide_lock); 249 mutex_unlock(&ide_cfg_mtx); 250} 251EXPORT_SYMBOL_GPL(ide_port_unregister_devices); 252 253/** 254 * ide_unregister - free an IDE interface 255 * @hwif: IDE interface 256 * 257 * Perform the final unregister of an IDE interface. At the moment 258 * we don't refcount interfaces so this will also get split up. 259 * 260 * Locking: 261 * The caller must not hold the IDE locks 262 * The drive present/vanishing is not yet properly locked 263 * Take care with the callbacks. These have been split to avoid 264 * deadlocking the IDE layer. The shutdown callback is called 265 * before we take the lock and free resources. It is up to the 266 * caller to be sure there is no pending I/O here, and that 267 * the interface will not be reopened (present/vanishing locking 268 * isn't yet done BTW). After we commit to the final kill we 269 * call the cleanup callback with the ide locks held. 270 * 271 * Unregister restores the hwif structures to the default state. 272 * This is raving bonkers. 273 */ 274 275void ide_unregister(ide_hwif_t *hwif) 276{ 277 ide_hwif_t *g; 278 ide_hwgroup_t *hwgroup; 279 int irq_count = 0; 280 281 BUG_ON(in_interrupt()); 282 BUG_ON(irqs_disabled()); 283 284 mutex_lock(&ide_cfg_mtx); 285 286 spin_lock_irq(&ide_lock); 287 if (hwif->present) { 288 __ide_port_unregister_devices(hwif); 289 hwif->present = 0; 290 } 291 spin_unlock_irq(&ide_lock); 292 293 ide_proc_unregister_port(hwif); 294 295 hwgroup = hwif->hwgroup; 296 /* 297 * free the irq if we were the only hwif using it 298 */ 299 g = hwgroup->hwif; 300 do { 301 if (g->irq == hwif->irq) 302 ++irq_count; 303 g = g->next; 304 } while (g != hwgroup->hwif); 305 if (irq_count == 1) 306 free_irq(hwif->irq, hwgroup); 307 308 ide_remove_port_from_hwgroup(hwif); 309 310 device_unregister(hwif->portdev); 311 device_unregister(&hwif->gendev); 312 wait_for_completion(&hwif->gendev_rel_comp); 313 314 /* 315 * Remove us from the kernel's knowledge 316 */ 317 blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS); 318 kfree(hwif->sg_table); 319 unregister_blkdev(hwif->major, hwif->name); 320 321 if (hwif->dma_base) 322 ide_release_dma_engine(hwif); 323 324 spin_lock_irq(&ide_lock); 325 /* restore hwif data to pristine status */ 326 ide_init_port_data(hwif, hwif->index); 327 spin_unlock_irq(&ide_lock); 328 329 mutex_unlock(&ide_cfg_mtx); 330} 331 332EXPORT_SYMBOL(ide_unregister); 333 334void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw) 335{ 336 memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports)); 337 hwif->irq = hw->irq; 338 hwif->chipset = hw->chipset; 339 hwif->gendev.parent = hw->dev; 340 hwif->ack_intr = hw->ack_intr; 341} 342EXPORT_SYMBOL_GPL(ide_init_port_hw); 343 344/* 345 * Locks for IDE setting functionality 346 */ 347 348DEFINE_MUTEX(ide_setting_mtx); 349 350EXPORT_SYMBOL_GPL(ide_setting_mtx); 351 352/** 353 * ide_spin_wait_hwgroup - wait for group 354 * @drive: drive in the group 355 * 356 * Wait for an IDE device group to go non busy and then return 357 * holding the ide_lock which guards the hwgroup->busy status 358 * and right to use it. 359 */ 360 361int ide_spin_wait_hwgroup (ide_drive_t *drive) 362{ 363 ide_hwgroup_t *hwgroup = HWGROUP(drive); 364 unsigned long timeout = jiffies + (3 * HZ); 365 366 spin_lock_irq(&ide_lock); 367 368 while (hwgroup->busy) { 369 unsigned long lflags; 370 spin_unlock_irq(&ide_lock); 371 local_irq_set(lflags); 372 if (time_after(jiffies, timeout)) { 373 local_irq_restore(lflags); 374 printk(KERN_ERR "%s: channel busy\n", drive->name); 375 return -EBUSY; 376 } 377 local_irq_restore(lflags); 378 spin_lock_irq(&ide_lock); 379 } 380 return 0; 381} 382 383EXPORT_SYMBOL(ide_spin_wait_hwgroup); 384 385int set_io_32bit(ide_drive_t *drive, int arg) 386{ 387 if (drive->no_io_32bit) 388 return -EPERM; 389 390 if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1)) 391 return -EINVAL; 392 393 if (ide_spin_wait_hwgroup(drive)) 394 return -EBUSY; 395 396 drive->io_32bit = arg; 397 398 spin_unlock_irq(&ide_lock); 399 400 return 0; 401} 402 403static int set_ksettings(ide_drive_t *drive, int arg) 404{ 405 if (arg < 0 || arg > 1) 406 return -EINVAL; 407 408 if (ide_spin_wait_hwgroup(drive)) 409 return -EBUSY; 410 drive->keep_settings = arg; 411 spin_unlock_irq(&ide_lock); 412 413 return 0; 414} 415 416int set_using_dma(ide_drive_t *drive, int arg) 417{ 418#ifdef CONFIG_BLK_DEV_IDEDMA 419 ide_hwif_t *hwif = drive->hwif; 420 int err = -EPERM; 421 422 if (arg < 0 || arg > 1) 423 return -EINVAL; 424 425 if (!drive->id || !(drive->id->capability & 1)) 426 goto out; 427 428 if (hwif->dma_ops == NULL) 429 goto out; 430 431 err = -EBUSY; 432 if (ide_spin_wait_hwgroup(drive)) 433 goto out; 434 /* 435 * set ->busy flag, unlock and let it ride 436 */ 437 hwif->hwgroup->busy = 1; 438 spin_unlock_irq(&ide_lock); 439 440 err = 0; 441 442 if (arg) { 443 if (ide_set_dma(drive)) 444 err = -EIO; 445 } else 446 ide_dma_off(drive); 447 448 /* 449 * lock, clear ->busy flag and unlock before leaving 450 */ 451 spin_lock_irq(&ide_lock); 452 hwif->hwgroup->busy = 0; 453 spin_unlock_irq(&ide_lock); 454out: 455 return err; 456#else 457 if (arg < 0 || arg > 1) 458 return -EINVAL; 459 460 return -EPERM; 461#endif 462} 463 464int set_pio_mode(ide_drive_t *drive, int arg) 465{ 466 struct request *rq; 467 ide_hwif_t *hwif = drive->hwif; 468 const struct ide_port_ops *port_ops = hwif->port_ops; 469 470 if (arg < 0 || arg > 255) 471 return -EINVAL; 472 473 if (port_ops == NULL || port_ops->set_pio_mode == NULL || 474 (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)) 475 return -ENOSYS; 476 477 if (drive->special.b.set_tune) 478 return -EBUSY; 479 480 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 481 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 482 483 drive->tune_req = (u8) arg; 484 drive->special.b.set_tune = 1; 485 486 blk_execute_rq(drive->queue, NULL, rq, 0); 487 blk_put_request(rq); 488 489 return 0; 490} 491 492static int set_unmaskirq(ide_drive_t *drive, int arg) 493{ 494 if (drive->no_unmask) 495 return -EPERM; 496 497 if (arg < 0 || arg > 1) 498 return -EINVAL; 499 500 if (ide_spin_wait_hwgroup(drive)) 501 return -EBUSY; 502 drive->unmask = arg; 503 spin_unlock_irq(&ide_lock); 504 505 return 0; 506} 507 508static int generic_ide_suspend(struct device *dev, pm_message_t mesg) 509{ 510 ide_drive_t *drive = dev->driver_data; 511 ide_hwif_t *hwif = HWIF(drive); 512 struct request *rq; 513 struct request_pm_state rqpm; 514 ide_task_t args; 515 int ret; 516 517 /* Call ACPI _GTM only once */ 518 if (!(drive->dn % 2)) 519 ide_acpi_get_timing(hwif); 520 521 memset(&rqpm, 0, sizeof(rqpm)); 522 memset(&args, 0, sizeof(args)); 523 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 524 rq->cmd_type = REQ_TYPE_PM_SUSPEND; 525 rq->special = &args; 526 rq->data = &rqpm; 527 rqpm.pm_step = ide_pm_state_start_suspend; 528 if (mesg.event == PM_EVENT_PRETHAW) 529 mesg.event = PM_EVENT_FREEZE; 530 rqpm.pm_state = mesg.event; 531 532 ret = blk_execute_rq(drive->queue, NULL, rq, 0); 533 blk_put_request(rq); 534 /* only call ACPI _PS3 after both drivers are suspended */ 535 if (!ret && (((drive->dn % 2) && hwif->drives[0].present 536 && hwif->drives[1].present) 537 || !hwif->drives[0].present 538 || !hwif->drives[1].present)) 539 ide_acpi_set_state(hwif, 0); 540 return ret; 541} 542 543static int generic_ide_resume(struct device *dev) 544{ 545 ide_drive_t *drive = dev->driver_data; 546 ide_hwif_t *hwif = HWIF(drive); 547 struct request *rq; 548 struct request_pm_state rqpm; 549 ide_task_t args; 550 int err; 551 552 /* Call ACPI _STM only once */ 553 if (!(drive->dn % 2)) { 554 ide_acpi_set_state(hwif, 1); 555 ide_acpi_push_timing(hwif); 556 } 557 558 ide_acpi_exec_tfs(drive); 559 560 memset(&rqpm, 0, sizeof(rqpm)); 561 memset(&args, 0, sizeof(args)); 562 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 563 rq->cmd_type = REQ_TYPE_PM_RESUME; 564 rq->cmd_flags |= REQ_PREEMPT; 565 rq->special = &args; 566 rq->data = &rqpm; 567 rqpm.pm_step = ide_pm_state_start_resume; 568 rqpm.pm_state = PM_EVENT_ON; 569 570 err = blk_execute_rq(drive->queue, NULL, rq, 1); 571 blk_put_request(rq); 572 573 if (err == 0 && dev->driver) { 574 ide_driver_t *drv = to_ide_driver(dev->driver); 575 576 if (drv->resume) 577 drv->resume(drive); 578 } 579 580 return err; 581} 582 583int generic_ide_ioctl(ide_drive_t *drive, struct file *file, struct block_device *bdev, 584 unsigned int cmd, unsigned long arg) 585{ 586 unsigned long flags; 587 ide_driver_t *drv; 588 void __user *p = (void __user *)arg; 589 int err = 0, (*setfunc)(ide_drive_t *, int); 590 u8 *val; 591 592 switch (cmd) { 593 case HDIO_GET_32BIT: val = &drive->io_32bit; goto read_val; 594 case HDIO_GET_KEEPSETTINGS: val = &drive->keep_settings; goto read_val; 595 case HDIO_GET_UNMASKINTR: val = &drive->unmask; goto read_val; 596 case HDIO_GET_DMA: val = &drive->using_dma; goto read_val; 597 case HDIO_SET_32BIT: setfunc = set_io_32bit; goto set_val; 598 case HDIO_SET_KEEPSETTINGS: setfunc = set_ksettings; goto set_val; 599 case HDIO_SET_PIO_MODE: setfunc = set_pio_mode; goto set_val; 600 case HDIO_SET_UNMASKINTR: setfunc = set_unmaskirq; goto set_val; 601 case HDIO_SET_DMA: setfunc = set_using_dma; goto set_val; 602 } 603 604 switch (cmd) { 605 case HDIO_OBSOLETE_IDENTITY: 606 case HDIO_GET_IDENTITY: 607 if (bdev != bdev->bd_contains) 608 return -EINVAL; 609 if (drive->id_read == 0) 610 return -ENOMSG; 611 if (copy_to_user(p, drive->id, (cmd == HDIO_GET_IDENTITY) ? sizeof(*drive->id) : 142)) 612 return -EFAULT; 613 return 0; 614 615 case HDIO_GET_NICE: 616 return put_user(drive->dsc_overlap << IDE_NICE_DSC_OVERLAP | 617 drive->atapi_overlap << IDE_NICE_ATAPI_OVERLAP | 618 drive->nice1 << IDE_NICE_1, 619 (long __user *) arg); 620#ifdef CONFIG_IDE_TASK_IOCTL 621 case HDIO_DRIVE_TASKFILE: 622 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) 623 return -EACCES; 624 switch(drive->media) { 625 case ide_disk: 626 return ide_taskfile_ioctl(drive, cmd, arg); 627 default: 628 return -ENOMSG; 629 } 630#endif /* CONFIG_IDE_TASK_IOCTL */ 631 632 case HDIO_DRIVE_CMD: 633 if (!capable(CAP_SYS_RAWIO)) 634 return -EACCES; 635 return ide_cmd_ioctl(drive, cmd, arg); 636 637 case HDIO_DRIVE_TASK: 638 if (!capable(CAP_SYS_RAWIO)) 639 return -EACCES; 640 return ide_task_ioctl(drive, cmd, arg); 641 case HDIO_SET_NICE: 642 if (!capable(CAP_SYS_ADMIN)) return -EACCES; 643 if (arg != (arg & ((1 << IDE_NICE_DSC_OVERLAP) | (1 << IDE_NICE_1)))) 644 return -EPERM; 645 drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1; 646 drv = *(ide_driver_t **)bdev->bd_disk->private_data; 647 if (drive->dsc_overlap && !drv->supports_dsc_overlap) { 648 drive->dsc_overlap = 0; 649 return -EPERM; 650 } 651 drive->nice1 = (arg >> IDE_NICE_1) & 1; 652 return 0; 653 case HDIO_DRIVE_RESET: 654 if (!capable(CAP_SYS_ADMIN)) 655 return -EACCES; 656 657 /* 658 * Abort the current command on the 659 * group if there is one, taking 660 * care not to allow anything else 661 * to be queued and to die on the 662 * spot if we miss one somehow 663 */ 664 665 spin_lock_irqsave(&ide_lock, flags); 666 667 if (HWGROUP(drive)->resetting) { 668 spin_unlock_irqrestore(&ide_lock, flags); 669 return -EBUSY; 670 } 671 672 ide_abort(drive, "drive reset"); 673 674 BUG_ON(HWGROUP(drive)->handler); 675 676 /* Ensure nothing gets queued after we 677 drop the lock. Reset will clear the busy */ 678 679 HWGROUP(drive)->busy = 1; 680 spin_unlock_irqrestore(&ide_lock, flags); 681 (void) ide_do_reset(drive); 682 683 return 0; 684 case HDIO_GET_BUSSTATE: 685 if (!capable(CAP_SYS_ADMIN)) 686 return -EACCES; 687 if (put_user(HWIF(drive)->bus_state, (long __user *)arg)) 688 return -EFAULT; 689 return 0; 690 691 case HDIO_SET_BUSSTATE: 692 if (!capable(CAP_SYS_ADMIN)) 693 return -EACCES; 694 return -EOPNOTSUPP; 695 default: 696 return -EINVAL; 697 } 698 699read_val: 700 mutex_lock(&ide_setting_mtx); 701 spin_lock_irqsave(&ide_lock, flags); 702 err = *val; 703 spin_unlock_irqrestore(&ide_lock, flags); 704 mutex_unlock(&ide_setting_mtx); 705 return err >= 0 ? put_user(err, (long __user *)arg) : err; 706 707set_val: 708 if (bdev != bdev->bd_contains) 709 err = -EINVAL; 710 else { 711 if (!capable(CAP_SYS_ADMIN)) 712 err = -EACCES; 713 else { 714 mutex_lock(&ide_setting_mtx); 715 err = setfunc(drive, arg); 716 mutex_unlock(&ide_setting_mtx); 717 } 718 } 719 return err; 720} 721 722EXPORT_SYMBOL(generic_ide_ioctl); 723 724/* 725 * ide_setup() gets called VERY EARLY during initialization, 726 * to handle kernel "command line" strings beginning with "ide". 727 * 728 * Remember to update Documentation/ide/ide.txt if you change something here. 729 */ 730static int __init ide_setup(char *s) 731{ 732 printk(KERN_INFO "ide_setup: %s", s); 733 init_ide_data (); 734 735#ifdef CONFIG_BLK_DEV_IDEDOUBLER 736 if (!strcmp(s, "ide=doubler")) { 737 extern int ide_doubler; 738 739 printk(" : Enabled support for IDE doublers\n"); 740 ide_doubler = 1; 741 goto obsolete_option; 742 } 743#endif /* CONFIG_BLK_DEV_IDEDOUBLER */ 744 745 if (!strcmp(s, "ide=nodma")) { 746 printk(" : Prevented DMA\n"); 747 noautodma = 1; 748 goto obsolete_option; 749 } 750 751#ifdef CONFIG_BLK_DEV_IDEACPI 752 if (!strcmp(s, "ide=noacpi")) { 753 //printk(" : Disable IDE ACPI support.\n"); 754 ide_noacpi = 1; 755 goto obsolete_option; 756 } 757 if (!strcmp(s, "ide=acpigtf")) { 758 //printk(" : Enable IDE ACPI _GTF support.\n"); 759 ide_acpigtf = 1; 760 goto obsolete_option; 761 } 762 if (!strcmp(s, "ide=acpionboot")) { 763 //printk(" : Call IDE ACPI methods on boot.\n"); 764 ide_acpionboot = 1; 765 goto obsolete_option; 766 } 767#endif /* CONFIG_BLK_DEV_IDEACPI */ 768 769 printk(" -- BAD OPTION\n"); 770 return 1; 771obsolete_option: 772 printk(" -- OBSOLETE OPTION, WILL BE REMOVED SOON!\n"); 773 return 1; 774} 775 776EXPORT_SYMBOL(ide_lock); 777 778static int ide_bus_match(struct device *dev, struct device_driver *drv) 779{ 780 return 1; 781} 782 783static char *media_string(ide_drive_t *drive) 784{ 785 switch (drive->media) { 786 case ide_disk: 787 return "disk"; 788 case ide_cdrom: 789 return "cdrom"; 790 case ide_tape: 791 return "tape"; 792 case ide_floppy: 793 return "floppy"; 794 case ide_optical: 795 return "optical"; 796 default: 797 return "UNKNOWN"; 798 } 799} 800 801static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf) 802{ 803 ide_drive_t *drive = to_ide_device(dev); 804 return sprintf(buf, "%s\n", media_string(drive)); 805} 806 807static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf) 808{ 809 ide_drive_t *drive = to_ide_device(dev); 810 return sprintf(buf, "%s\n", drive->name); 811} 812 813static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 814{ 815 ide_drive_t *drive = to_ide_device(dev); 816 return sprintf(buf, "ide:m-%s\n", media_string(drive)); 817} 818 819static ssize_t model_show(struct device *dev, struct device_attribute *attr, 820 char *buf) 821{ 822 ide_drive_t *drive = to_ide_device(dev); 823 return sprintf(buf, "%s\n", drive->id->model); 824} 825 826static ssize_t firmware_show(struct device *dev, struct device_attribute *attr, 827 char *buf) 828{ 829 ide_drive_t *drive = to_ide_device(dev); 830 return sprintf(buf, "%s\n", drive->id->fw_rev); 831} 832 833static ssize_t serial_show(struct device *dev, struct device_attribute *attr, 834 char *buf) 835{ 836 ide_drive_t *drive = to_ide_device(dev); 837 return sprintf(buf, "%s\n", drive->id->serial_no); 838} 839 840static struct device_attribute ide_dev_attrs[] = { 841 __ATTR_RO(media), 842 __ATTR_RO(drivename), 843 __ATTR_RO(modalias), 844 __ATTR_RO(model), 845 __ATTR_RO(firmware), 846 __ATTR(serial, 0400, serial_show, NULL), 847 __ATTR_NULL 848}; 849 850static int ide_uevent(struct device *dev, struct kobj_uevent_env *env) 851{ 852 ide_drive_t *drive = to_ide_device(dev); 853 854 add_uevent_var(env, "MEDIA=%s", media_string(drive)); 855 add_uevent_var(env, "DRIVENAME=%s", drive->name); 856 add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive)); 857 return 0; 858} 859 860static int generic_ide_probe(struct device *dev) 861{ 862 ide_drive_t *drive = to_ide_device(dev); 863 ide_driver_t *drv = to_ide_driver(dev->driver); 864 865 return drv->probe ? drv->probe(drive) : -ENODEV; 866} 867 868static int generic_ide_remove(struct device *dev) 869{ 870 ide_drive_t *drive = to_ide_device(dev); 871 ide_driver_t *drv = to_ide_driver(dev->driver); 872 873 if (drv->remove) 874 drv->remove(drive); 875 876 return 0; 877} 878 879static void generic_ide_shutdown(struct device *dev) 880{ 881 ide_drive_t *drive = to_ide_device(dev); 882 ide_driver_t *drv = to_ide_driver(dev->driver); 883 884 if (dev->driver && drv->shutdown) 885 drv->shutdown(drive); 886} 887 888struct bus_type ide_bus_type = { 889 .name = "ide", 890 .match = ide_bus_match, 891 .uevent = ide_uevent, 892 .probe = generic_ide_probe, 893 .remove = generic_ide_remove, 894 .shutdown = generic_ide_shutdown, 895 .dev_attrs = ide_dev_attrs, 896 .suspend = generic_ide_suspend, 897 .resume = generic_ide_resume, 898}; 899 900EXPORT_SYMBOL_GPL(ide_bus_type); 901 902int ide_vlb_clk; 903EXPORT_SYMBOL_GPL(ide_vlb_clk); 904 905module_param_named(vlb_clock, ide_vlb_clk, int, 0); 906MODULE_PARM_DESC(vlb_clock, "VLB clock frequency (in MHz)"); 907 908int ide_pci_clk; 909EXPORT_SYMBOL_GPL(ide_pci_clk); 910 911module_param_named(pci_clock, ide_pci_clk, int, 0); 912MODULE_PARM_DESC(pci_clock, "PCI bus clock frequency (in MHz)"); 913 914static int ide_set_dev_param_mask(const char *s, struct kernel_param *kp) 915{ 916 int a, b, i, j = 1; 917 unsigned int *dev_param_mask = (unsigned int *)kp->arg; 918 919 if (sscanf(s, "%d.%d:%d", &a, &b, &j) != 3 && 920 sscanf(s, "%d.%d", &a, &b) != 2) 921 return -EINVAL; 922 923 i = a * MAX_DRIVES + b; 924 925 if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1) 926 return -EINVAL; 927 928 if (j) 929 *dev_param_mask |= (1 << i); 930 else 931 *dev_param_mask &= (1 << i); 932 933 return 0; 934} 935 936static unsigned int ide_nodma; 937 938module_param_call(nodma, ide_set_dev_param_mask, NULL, &ide_nodma, 0); 939MODULE_PARM_DESC(nodma, "disallow DMA for a device"); 940 941static unsigned int ide_noflush; 942 943module_param_call(noflush, ide_set_dev_param_mask, NULL, &ide_noflush, 0); 944MODULE_PARM_DESC(noflush, "disable flush requests for a device"); 945 946static unsigned int ide_noprobe; 947 948module_param_call(noprobe, ide_set_dev_param_mask, NULL, &ide_noprobe, 0); 949MODULE_PARM_DESC(noprobe, "skip probing for a device"); 950 951static unsigned int ide_nowerr; 952 953module_param_call(nowerr, ide_set_dev_param_mask, NULL, &ide_nowerr, 0); 954MODULE_PARM_DESC(nowerr, "ignore the WRERR_STAT bit for a device"); 955 956static unsigned int ide_cdroms; 957 958module_param_call(cdrom, ide_set_dev_param_mask, NULL, &ide_cdroms, 0); 959MODULE_PARM_DESC(cdrom, "force device as a CD-ROM"); 960 961struct chs_geom { 962 unsigned int cyl; 963 u8 head; 964 u8 sect; 965}; 966 967static unsigned int ide_disks; 968static struct chs_geom ide_disks_chs[MAX_HWIFS * MAX_DRIVES]; 969 970static int ide_set_disk_chs(const char *str, struct kernel_param *kp) 971{ 972 int a, b, c = 0, h = 0, s = 0, i, j = 1; 973 974 if (sscanf(str, "%d.%d:%d,%d,%d", &a, &b, &c, &h, &s) != 5 && 975 sscanf(str, "%d.%d:%d", &a, &b, &j) != 3) 976 return -EINVAL; 977 978 i = a * MAX_DRIVES + b; 979 980 if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1) 981 return -EINVAL; 982 983 if (c > INT_MAX || h > 255 || s > 255) 984 return -EINVAL; 985 986 if (j) 987 ide_disks |= (1 << i); 988 else 989 ide_disks &= (1 << i); 990 991 ide_disks_chs[i].cyl = c; 992 ide_disks_chs[i].head = h; 993 ide_disks_chs[i].sect = s; 994 995 return 0; 996} 997 998module_param_call(chs, ide_set_disk_chs, NULL, NULL, 0); 999MODULE_PARM_DESC(chs, "force device as a disk (using CHS)"); 1000 1001static void ide_dev_apply_params(ide_drive_t *drive) 1002{ 1003 int i = drive->hwif->index * MAX_DRIVES + drive->select.b.unit; 1004 1005 if (ide_nodma & (1 << i)) { 1006 printk(KERN_INFO "ide: disallowing DMA for %s\n", drive->name); 1007 drive->nodma = 1; 1008 } 1009 if (ide_noflush & (1 << i)) { 1010 printk(KERN_INFO "ide: disabling flush requests for %s\n", 1011 drive->name); 1012 drive->noflush = 1; 1013 } 1014 if (ide_noprobe & (1 << i)) { 1015 printk(KERN_INFO "ide: skipping probe for %s\n", drive->name); 1016 drive->noprobe = 1; 1017 } 1018 if (ide_nowerr & (1 << i)) { 1019 printk(KERN_INFO "ide: ignoring the WRERR_STAT bit for %s\n", 1020 drive->name); 1021 drive->bad_wstat = BAD_R_STAT; 1022 } 1023 if (ide_cdroms & (1 << i)) { 1024 printk(KERN_INFO "ide: forcing %s as a CD-ROM\n", drive->name); 1025 drive->present = 1; 1026 drive->media = ide_cdrom; 1027 /* an ATAPI device ignores DRDY */ 1028 drive->ready_stat = 0; 1029 } 1030 if (ide_disks & (1 << i)) { 1031 drive->cyl = drive->bios_cyl = ide_disks_chs[i].cyl; 1032 drive->head = drive->bios_head = ide_disks_chs[i].head; 1033 drive->sect = drive->bios_sect = ide_disks_chs[i].sect; 1034 drive->forced_geom = 1; 1035 printk(KERN_INFO "ide: forcing %s as a disk (%d/%d/%d)\n", 1036 drive->name, 1037 drive->cyl, drive->head, drive->sect); 1038 drive->present = 1; 1039 drive->media = ide_disk; 1040 drive->ready_stat = READY_STAT; 1041 } 1042} 1043 1044static unsigned int ide_ignore_cable; 1045 1046static int ide_set_ignore_cable(const char *s, struct kernel_param *kp) 1047{ 1048 int i, j = 1; 1049 1050 if (sscanf(s, "%d:%d", &i, &j) != 2 && sscanf(s, "%d", &i) != 1) 1051 return -EINVAL; 1052 1053 if (i >= MAX_HWIFS || j < 0 || j > 1) 1054 return -EINVAL; 1055 1056 if (j) 1057 ide_ignore_cable |= (1 << i); 1058 else 1059 ide_ignore_cable &= (1 << i); 1060 1061 return 0; 1062} 1063 1064module_param_call(ignore_cable, ide_set_ignore_cable, NULL, NULL, 0); 1065MODULE_PARM_DESC(ignore_cable, "ignore cable detection"); 1066 1067void ide_port_apply_params(ide_hwif_t *hwif) 1068{ 1069 int i; 1070 1071 if (ide_ignore_cable & (1 << hwif->index)) { 1072 printk(KERN_INFO "ide: ignoring cable detection for %s\n", 1073 hwif->name); 1074 hwif->cbl = ATA_CBL_PATA40_SHORT; 1075 } 1076 1077 for (i = 0; i < MAX_DRIVES; i++) 1078 ide_dev_apply_params(&hwif->drives[i]); 1079} 1080 1081/* 1082 * This is gets invoked once during initialization, to set *everything* up 1083 */ 1084static int __init ide_init(void) 1085{ 1086 int ret; 1087 1088 printk(KERN_INFO "Uniform Multi-Platform E-IDE driver\n"); 1089 1090 ret = bus_register(&ide_bus_type); 1091 if (ret < 0) { 1092 printk(KERN_WARNING "IDE: bus_register error: %d\n", ret); 1093 return ret; 1094 } 1095 1096 ide_port_class = class_create(THIS_MODULE, "ide_port"); 1097 if (IS_ERR(ide_port_class)) { 1098 ret = PTR_ERR(ide_port_class); 1099 goto out_port_class; 1100 } 1101 1102 init_ide_data(); 1103 1104 proc_ide_create(); 1105 1106 return 0; 1107 1108out_port_class: 1109 bus_unregister(&ide_bus_type); 1110 1111 return ret; 1112} 1113 1114#ifdef MODULE 1115static char *options = NULL; 1116module_param(options, charp, 0); 1117MODULE_LICENSE("GPL"); 1118 1119static void __init parse_options (char *line) 1120{ 1121 char *next = line; 1122 1123 if (line == NULL || !*line) 1124 return; 1125 while ((line = next) != NULL) { 1126 if ((next = strchr(line,' ')) != NULL) 1127 *next++ = 0; 1128 if (!ide_setup(line)) 1129 printk (KERN_INFO "Unknown option '%s'\n", line); 1130 } 1131} 1132 1133int __init init_module (void) 1134{ 1135 parse_options(options); 1136 return ide_init(); 1137} 1138 1139void __exit cleanup_module (void) 1140{ 1141 proc_ide_destroy(); 1142 1143 class_destroy(ide_port_class); 1144 1145 bus_unregister(&ide_bus_type); 1146} 1147 1148#else /* !MODULE */ 1149 1150__setup("", ide_setup); 1151 1152module_init(ide_init); 1153 1154#endif /* MODULE */ 1155