linux/drivers/ide/ide.c
<<
>>
Prefs
   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/init.h>
  56#include <linux/pci.h>
  57#include <linux/ide.h>
  58#include <linux/hdreg.h>
  59#include <linux/completion.h>
  60#include <linux/device.h>
  61
  62struct class *ide_port_class;
  63
  64/**
  65 * ide_device_get       -       get an additional reference to a ide_drive_t
  66 * @drive:      device to get a reference to
  67 *
  68 * Gets a reference to the ide_drive_t and increments the use count of the
  69 * underlying LLDD module.
  70 */
  71int ide_device_get(ide_drive_t *drive)
  72{
  73        struct device *host_dev;
  74        struct module *module;
  75
  76        if (!get_device(&drive->gendev))
  77                return -ENXIO;
  78
  79        host_dev = drive->hwif->host->dev[0];
  80        module = host_dev ? host_dev->driver->owner : NULL;
  81
  82        if (module && !try_module_get(module)) {
  83                put_device(&drive->gendev);
  84                return -ENXIO;
  85        }
  86
  87        return 0;
  88}
  89EXPORT_SYMBOL_GPL(ide_device_get);
  90
  91/**
  92 * ide_device_put       -       release a reference to a ide_drive_t
  93 * @drive:      device to release a reference on
  94 *
  95 * Release a reference to the ide_drive_t and decrements the use count of
  96 * the underlying LLDD module.
  97 */
  98void ide_device_put(ide_drive_t *drive)
  99{
 100#ifdef CONFIG_MODULE_UNLOAD
 101        struct device *host_dev = drive->hwif->host->dev[0];
 102        struct module *module = host_dev ? host_dev->driver->owner : NULL;
 103
 104        if (module)
 105                module_put(module);
 106#endif
 107        put_device(&drive->gendev);
 108}
 109EXPORT_SYMBOL_GPL(ide_device_put);
 110
 111static int ide_bus_match(struct device *dev, struct device_driver *drv)
 112{
 113        return 1;
 114}
 115
 116static int ide_uevent(struct device *dev, struct kobj_uevent_env *env)
 117{
 118        ide_drive_t *drive = to_ide_device(dev);
 119
 120        add_uevent_var(env, "MEDIA=%s", ide_media_string(drive));
 121        add_uevent_var(env, "DRIVENAME=%s", drive->name);
 122        add_uevent_var(env, "MODALIAS=ide:m-%s", ide_media_string(drive));
 123        return 0;
 124}
 125
 126static int generic_ide_probe(struct device *dev)
 127{
 128        ide_drive_t *drive = to_ide_device(dev);
 129        struct ide_driver *drv = to_ide_driver(dev->driver);
 130
 131        return drv->probe ? drv->probe(drive) : -ENODEV;
 132}
 133
 134static int generic_ide_remove(struct device *dev)
 135{
 136        ide_drive_t *drive = to_ide_device(dev);
 137        struct ide_driver *drv = to_ide_driver(dev->driver);
 138
 139        if (drv->remove)
 140                drv->remove(drive);
 141
 142        return 0;
 143}
 144
 145static void generic_ide_shutdown(struct device *dev)
 146{
 147        ide_drive_t *drive = to_ide_device(dev);
 148        struct ide_driver *drv = to_ide_driver(dev->driver);
 149
 150        if (dev->driver && drv->shutdown)
 151                drv->shutdown(drive);
 152}
 153
 154struct bus_type ide_bus_type = {
 155        .name           = "ide",
 156        .match          = ide_bus_match,
 157        .uevent         = ide_uevent,
 158        .probe          = generic_ide_probe,
 159        .remove         = generic_ide_remove,
 160        .shutdown       = generic_ide_shutdown,
 161        .dev_attrs      = ide_dev_attrs,
 162        .suspend        = generic_ide_suspend,
 163        .resume         = generic_ide_resume,
 164};
 165
 166EXPORT_SYMBOL_GPL(ide_bus_type);
 167
 168int ide_vlb_clk;
 169EXPORT_SYMBOL_GPL(ide_vlb_clk);
 170
 171module_param_named(vlb_clock, ide_vlb_clk, int, 0);
 172MODULE_PARM_DESC(vlb_clock, "VLB clock frequency (in MHz)");
 173
 174int ide_pci_clk;
 175EXPORT_SYMBOL_GPL(ide_pci_clk);
 176
 177module_param_named(pci_clock, ide_pci_clk, int, 0);
 178MODULE_PARM_DESC(pci_clock, "PCI bus clock frequency (in MHz)");
 179
 180static int ide_set_dev_param_mask(const char *s, const struct kernel_param *kp)
 181{
 182        int a, b, i, j = 1;
 183        unsigned int *dev_param_mask = (unsigned int *)kp->arg;
 184
 185        /* controller . device (0 or 1) [ : 1 (set) | 0 (clear) ] */
 186        if (sscanf(s, "%d.%d:%d", &a, &b, &j) != 3 &&
 187            sscanf(s, "%d.%d", &a, &b) != 2)
 188                return -EINVAL;
 189
 190        i = a * MAX_DRIVES + b;
 191
 192        if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1)
 193                return -EINVAL;
 194
 195        if (j)
 196                *dev_param_mask |= (1 << i);
 197        else
 198                *dev_param_mask &= ~(1 << i);
 199
 200        return 0;
 201}
 202
 203static struct kernel_param_ops param_ops_ide_dev_mask = {
 204        .set = ide_set_dev_param_mask
 205};
 206
 207#define param_check_ide_dev_mask(name, p) param_check_uint(name, p)
 208
 209static unsigned int ide_nodma;
 210
 211module_param_named(nodma, ide_nodma, ide_dev_mask, 0);
 212MODULE_PARM_DESC(nodma, "disallow DMA for a device");
 213
 214static unsigned int ide_noflush;
 215
 216module_param_named(noflush, ide_noflush, ide_dev_mask, 0);
 217MODULE_PARM_DESC(noflush, "disable flush requests for a device");
 218
 219static unsigned int ide_nohpa;
 220
 221module_param_named(nohpa, ide_nohpa, ide_dev_mask, 0);
 222MODULE_PARM_DESC(nohpa, "disable Host Protected Area for a device");
 223
 224static unsigned int ide_noprobe;
 225
 226module_param_named(noprobe, ide_noprobe, ide_dev_mask, 0);
 227MODULE_PARM_DESC(noprobe, "skip probing for a device");
 228
 229static unsigned int ide_nowerr;
 230
 231module_param_named(nowerr, ide_nowerr, ide_dev_mask, 0);
 232MODULE_PARM_DESC(nowerr, "ignore the ATA_DF bit for a device");
 233
 234static unsigned int ide_cdroms;
 235
 236module_param_named(cdrom, ide_cdroms, ide_dev_mask, 0);
 237MODULE_PARM_DESC(cdrom, "force device as a CD-ROM");
 238
 239struct chs_geom {
 240        unsigned int    cyl;
 241        u8              head;
 242        u8              sect;
 243};
 244
 245static unsigned int ide_disks;
 246static struct chs_geom ide_disks_chs[MAX_HWIFS * MAX_DRIVES];
 247
 248static int ide_set_disk_chs(const char *str, struct kernel_param *kp)
 249{
 250        int a, b, c = 0, h = 0, s = 0, i, j = 1;
 251
 252        /* controller . device (0 or 1) : Cylinders , Heads , Sectors */
 253        /* controller . device (0 or 1) : 1 (use CHS) | 0 (ignore CHS) */
 254        if (sscanf(str, "%d.%d:%d,%d,%d", &a, &b, &c, &h, &s) != 5 &&
 255            sscanf(str, "%d.%d:%d", &a, &b, &j) != 3)
 256                return -EINVAL;
 257
 258        i = a * MAX_DRIVES + b;
 259
 260        if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1)
 261                return -EINVAL;
 262
 263        if (c > INT_MAX || h > 255 || s > 255)
 264                return -EINVAL;
 265
 266        if (j)
 267                ide_disks |= (1 << i);
 268        else
 269                ide_disks &= ~(1 << i);
 270
 271        ide_disks_chs[i].cyl  = c;
 272        ide_disks_chs[i].head = h;
 273        ide_disks_chs[i].sect = s;
 274
 275        return 0;
 276}
 277
 278module_param_call(chs, ide_set_disk_chs, NULL, NULL, 0);
 279MODULE_PARM_DESC(chs, "force device as a disk (using CHS)");
 280
 281static void ide_dev_apply_params(ide_drive_t *drive, u8 unit)
 282{
 283        int i = drive->hwif->index * MAX_DRIVES + unit;
 284
 285        if (ide_nodma & (1 << i)) {
 286                printk(KERN_INFO "ide: disallowing DMA for %s\n", drive->name);
 287                drive->dev_flags |= IDE_DFLAG_NODMA;
 288        }
 289        if (ide_noflush & (1 << i)) {
 290                printk(KERN_INFO "ide: disabling flush requests for %s\n",
 291                                 drive->name);
 292                drive->dev_flags |= IDE_DFLAG_NOFLUSH;
 293        }
 294        if (ide_nohpa & (1 << i)) {
 295                printk(KERN_INFO "ide: disabling Host Protected Area for %s\n",
 296                                 drive->name);
 297                drive->dev_flags |= IDE_DFLAG_NOHPA;
 298        }
 299        if (ide_noprobe & (1 << i)) {
 300                printk(KERN_INFO "ide: skipping probe for %s\n", drive->name);
 301                drive->dev_flags |= IDE_DFLAG_NOPROBE;
 302        }
 303        if (ide_nowerr & (1 << i)) {
 304                printk(KERN_INFO "ide: ignoring the ATA_DF bit for %s\n",
 305                                 drive->name);
 306                drive->bad_wstat = BAD_R_STAT;
 307        }
 308        if (ide_cdroms & (1 << i)) {
 309                printk(KERN_INFO "ide: forcing %s as a CD-ROM\n", drive->name);
 310                drive->dev_flags |= IDE_DFLAG_PRESENT;
 311                drive->media = ide_cdrom;
 312                /* an ATAPI device ignores DRDY */
 313                drive->ready_stat = 0;
 314        }
 315        if (ide_disks & (1 << i)) {
 316                drive->cyl  = drive->bios_cyl  = ide_disks_chs[i].cyl;
 317                drive->head = drive->bios_head = ide_disks_chs[i].head;
 318                drive->sect = drive->bios_sect = ide_disks_chs[i].sect;
 319
 320                printk(KERN_INFO "ide: forcing %s as a disk (%d/%d/%d)\n",
 321                                 drive->name,
 322                                 drive->cyl, drive->head, drive->sect);
 323
 324                drive->dev_flags |= IDE_DFLAG_FORCED_GEOM | IDE_DFLAG_PRESENT;
 325                drive->media = ide_disk;
 326                drive->ready_stat = ATA_DRDY;
 327        }
 328}
 329
 330static unsigned int ide_ignore_cable;
 331
 332static int ide_set_ignore_cable(const char *s, struct kernel_param *kp)
 333{
 334        int i, j = 1;
 335
 336        /* controller (ignore) */
 337        /* controller : 1 (ignore) | 0 (use) */
 338        if (sscanf(s, "%d:%d", &i, &j) != 2 && sscanf(s, "%d", &i) != 1)
 339                return -EINVAL;
 340
 341        if (i >= MAX_HWIFS || j < 0 || j > 1)
 342                return -EINVAL;
 343
 344        if (j)
 345                ide_ignore_cable |= (1 << i);
 346        else
 347                ide_ignore_cable &= ~(1 << i);
 348
 349        return 0;
 350}
 351
 352module_param_call(ignore_cable, ide_set_ignore_cable, NULL, NULL, 0);
 353MODULE_PARM_DESC(ignore_cable, "ignore cable detection");
 354
 355void ide_port_apply_params(ide_hwif_t *hwif)
 356{
 357        ide_drive_t *drive;
 358        int i;
 359
 360        if (ide_ignore_cable & (1 << hwif->index)) {
 361                printk(KERN_INFO "ide: ignoring cable detection for %s\n",
 362                                 hwif->name);
 363                hwif->cbl = ATA_CBL_PATA40_SHORT;
 364        }
 365
 366        ide_port_for_each_dev(i, drive, hwif)
 367                ide_dev_apply_params(drive, i);
 368}
 369
 370/*
 371 * This is gets invoked once during initialization, to set *everything* up
 372 */
 373static int __init ide_init(void)
 374{
 375        int ret;
 376
 377        printk(KERN_INFO "Uniform Multi-Platform E-IDE driver\n");
 378
 379        ret = bus_register(&ide_bus_type);
 380        if (ret < 0) {
 381                printk(KERN_WARNING "IDE: bus_register error: %d\n", ret);
 382                return ret;
 383        }
 384
 385        ide_port_class = class_create(THIS_MODULE, "ide_port");
 386        if (IS_ERR(ide_port_class)) {
 387                ret = PTR_ERR(ide_port_class);
 388                goto out_port_class;
 389        }
 390
 391        ide_acpi_init();
 392
 393        proc_ide_create();
 394
 395        return 0;
 396
 397out_port_class:
 398        bus_unregister(&ide_bus_type);
 399
 400        return ret;
 401}
 402
 403static void __exit ide_exit(void)
 404{
 405        proc_ide_destroy();
 406
 407        class_destroy(ide_port_class);
 408
 409        bus_unregister(&ide_bus_type);
 410}
 411
 412module_init(ide_init);
 413module_exit(ide_exit);
 414
 415MODULE_LICENSE("GPL");
 416
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.