SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/ide/ide-disk.c

   1 /*
   2  *  linux/drivers/ide/ide-disk.c        Version 1.18    Mar 05, 2003
   3  *
   4  *  Copyright (C) 1994-1998  Linus Torvalds & authors (see below)
   5  *  Copyright (C) 1998-2002  Linux ATA Development
   6  *                              Andre Hedrick <andre@linux-ide.org>
   7  *  Copyright (C) 2003       Red Hat <alan@redhat.com>
   8  */
   9
  10 /*
  11  *  Mostly written by Mark Lord <mlord@pobox.com>
  12  *                and Gadi Oxman <gadio@netvision.net.il>
  13  *                and Andre Hedrick <andre@linux-ide.org>
  14  *
  15  * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
  16  */
  17
  18 #define IDEDISK_VERSION "1.18"
  19
  20 //#define DEBUG
  21
  22 #include <linux/module.h>
  23 #include <linux/types.h>
  24 #include <linux/string.h>
  25 #include <linux/kernel.h>
  26 #include <linux/timer.h>
  27 #include <linux/mm.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/major.h>
  30 #include <linux/errno.h>
  31 #include <linux/genhd.h>
  32 #include <linux/slab.h>
  33 #include <linux/delay.h>
  34 #include <linux/mutex.h>
  35 #include <linux/leds.h>
  36
  37 #define _IDE_DISK
  38
  39 #include <linux/ide.h>
  40
  41 #include <asm/byteorder.h>
  42 #include <asm/irq.h>
  43 #include <asm/uaccess.h>
  44 #include <asm/io.h>
  45 #include <asm/div64.h>
  46
  47 struct ide_disk_obj {
  48         ide_drive_t     *drive;
  49         ide_driver_t    *driver;
  50         struct gendisk  *disk;
  51         struct kref     kref;
  52         unsigned int    openers;        /* protected by BKL for now */
  53 };
  54
  55 static DEFINE_MUTEX(idedisk_ref_mutex);
  56
  57 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
  58
  59 #define ide_disk_g(disk) \
  60         container_of((disk)->private_data, struct ide_disk_obj, driver)
  61
  62 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
  63 {
  64         struct ide_disk_obj *idkp = NULL;
  65
  66         mutex_lock(&idedisk_ref_mutex);
  67         idkp = ide_disk_g(disk);
  68         if (idkp)
  69                 kref_get(&idkp->kref);
  70         mutex_unlock(&idedisk_ref_mutex);
  71         return idkp;
  72 }
  73
  74 static void ide_disk_release(struct kref *);
  75
  76 static void ide_disk_put(struct ide_disk_obj *idkp)
  77 {
  78         mutex_lock(&idedisk_ref_mutex);
  79         kref_put(&idkp->kref, ide_disk_release);
  80         mutex_unlock(&idedisk_ref_mutex);
  81 }
  82
  83 /*
  84  * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
  85  * value for this drive (from its reported identification information).
  86  *
  87  * Returns:     1 if lba_capacity looks sensible
  88  *              0 otherwise
  89  *
  90  * It is called only once for each drive.
  91  */
  92 static int lba_capacity_is_ok (struct hd_driveid *id)
  93 {
  94         unsigned long lba_sects, chs_sects, head, tail;
  95
  96         /* No non-LBA info .. so valid! */
  97         if (id->cyls == 0)
  98                 return 1;
  99
 100         /*
 101          * The ATA spec tells large drives to return
 102          * C/H/S = 16383/16/63 independent of their size.
 103          * Some drives can be jumpered to use 15 heads instead of 16.
 104          * Some drives can be jumpered to use 4092 cyls instead of 16383.
 105          */
 106         if ((id->cyls == 16383
 107              || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
 108             id->sectors == 63 &&
 109             (id->heads == 15 || id->heads == 16) &&
 110             (id->lba_capacity >= 16383*63*id->heads))
 111                 return 1;
 112
 113         lba_sects   = id->lba_capacity;
 114         chs_sects   = id->cyls * id->heads * id->sectors;
 115
 116         /* perform a rough sanity check on lba_sects:  within 10% is OK */
 117         if ((lba_sects - chs_sects) < chs_sects/10)
 118                 return 1;
 119
 120         /* some drives have the word order reversed */
 121         head = ((lba_sects >> 16) & 0xffff);
 122         tail = (lba_sects & 0xffff);
 123         lba_sects = (head | (tail << 16));
 124         if ((lba_sects - chs_sects) < chs_sects/10) {
 125                 id->lba_capacity = lba_sects;
 126                 return 1;       /* lba_capacity is (now) good */
 127         }
 128
 129         return 0;       /* lba_capacity value may be bad */
 130 }
 131
 132 /*
 133  * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
 134  * using LBA if supported, or CHS otherwise, to address sectors.
 135  */
 136 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
 137 {
 138         ide_hwif_t *hwif        = HWIF(drive);
 139         unsigned int dma        = drive->using_dma;
 140         u8 lba48                = (drive->addressing == 1) ? 1 : 0;
 141         u8 command              = WIN_NOP;
 142         ata_nsector_t           nsectors;
 143         ide_task_t              task;
 144         struct ide_taskfile     *tf = &task.tf;
 145
 146         nsectors.all            = (u16) rq->nr_sectors;
 147
 148         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
 149                 if (block + rq->nr_sectors > 1ULL << 28)
 150                         dma = 0;
 151                 else
 152                         lba48 = 0;
 153         }
 154
 155         if (!dma) {
 156                 ide_init_sg_cmd(drive, rq);
 157                 ide_map_sg(drive, rq);
 158         }
 159
 160         memset(&task, 0, sizeof(task));
 161         task.tf_flags = IDE_TFLAG_NO_SELECT_MASK;  /* FIXME? */
 162         task.tf_flags |= (IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE);
 163
 164         if (drive->select.b.lba) {
 165                 if (lba48) {
 166                         pr_debug("%s: LBA=0x%012llx\n", drive->name,
 167                                         (unsigned long long)block);
 168
 169                         tf->hob_nsect = nsectors.b.high;
 170                         tf->hob_lbal  = (u8)(block >> 24);
 171                         if (sizeof(block) != 4) {
 172                                 tf->hob_lbam = (u8)((u64)block >> 32);
 173                                 tf->hob_lbah = (u8)((u64)block >> 40);
 174                         }
 175
 176                         tf->nsect  = nsectors.b.low;
 177                         tf->lbal   = (u8) block;
 178                         tf->lbam   = (u8)(block >>  8);
 179                         tf->lbah   = (u8)(block >> 16);
 180 #ifdef DEBUG
 181                         printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
 182                                 drive->name, tf->hob_nsect, tf->nsect,
 183                                 tf->hob_lbah, tf->hob_lbam, tf->hob_lbal,
 184                                 tf->lbah, tf->lbam, tf->lbal);
 185 #endif
 186                         task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
 187                 } else {
 188                         tf->nsect  = nsectors.b.low;
 189                         tf->lbal   = block;
 190                         tf->lbam   = block >>= 8;
 191                         tf->lbah   = block >>= 8;
 192                         tf->device = (block >> 8) & 0xf;
 193                 }
 194         } else {
 195                 unsigned int sect,head,cyl,track;
 196                 track = (int)block / drive->sect;
 197                 sect  = (int)block % drive->sect + 1;
 198                 head  = track % drive->head;
 199                 cyl   = track / drive->head;
 200
 201                 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
 202
 203                 tf->nsect  = nsectors.b.low;
 204                 tf->lbal   = sect;
 205                 tf->lbam   = cyl;
 206                 tf->lbah   = cyl >> 8;
 207                 tf->device = head;
 208         }
 209
 210         ide_tf_load(drive, &task);
 211
 212         if (dma) {
 213                 if (!hwif->dma_setup(drive)) {
 214                         if (rq_data_dir(rq)) {
 215                                 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
 216                                 if (drive->vdma)
 217                                         command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
 218                         } else {
 219                                 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
 220                                 if (drive->vdma)
 221                                         command = lba48 ? WIN_READ_EXT: WIN_READ;
 222                         }
 223                         hwif->dma_exec_cmd(drive, command);
 224                         hwif->dma_start(drive);
 225                         return ide_started;
 226                 }
 227                 /* fallback to PIO */
 228                 ide_init_sg_cmd(drive, rq);
 229         }
 230
 231         if (rq_data_dir(rq) == READ) {
 232
 233                 if (drive->mult_count) {
 234                         hwif->data_phase = TASKFILE_MULTI_IN;
 235                         command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
 236                 } else {
 237                         hwif->data_phase = TASKFILE_IN;
 238                         command = lba48 ? WIN_READ_EXT : WIN_READ;
 239                 }
 240
 241                 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
 242                 return ide_started;
 243         } else {
 244                 if (drive->mult_count) {
 245                         hwif->data_phase = TASKFILE_MULTI_OUT;
 246                         command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
 247                 } else {
 248                         hwif->data_phase = TASKFILE_OUT;
 249                         command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
 250                 }
 251
 252                 /* FIXME: ->OUTBSYNC ? */
 253                 hwif->OUTB(command, IDE_COMMAND_REG);
 254
 255                 return pre_task_out_intr(drive, rq);
 256         }
 257 }
 258
 259 /*
 260  * 268435455  == 137439 MB or 28bit limit
 261  * 320173056  == 163929 MB or 48bit addressing
 262  * 1073741822 == 549756 MB or 48bit addressing fake drive
 263  */
 264
 265 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
 266 {
 267         ide_hwif_t *hwif = HWIF(drive);
 268
 269         BUG_ON(drive->blocked);
 270
 271         if (!blk_fs_request(rq)) {
 272                 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
 273                 ide_end_request(drive, 0, 0);
 274                 return ide_stopped;
 275         }
 276
 277         ledtrig_ide_activity();
 278
 279         pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
 280                  drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
 281                  (unsigned long long)block, rq->nr_sectors,
 282                  (unsigned long)rq->buffer);
 283
 284         if (hwif->rw_disk)
 285                 hwif->rw_disk(drive, rq);
 286
 287         return __ide_do_rw_disk(drive, rq, block);
 288 }
 289
 290 /*
 291  * Queries for true maximum capacity of the drive.
 292  * Returns maximum LBA address (> 0) of the drive, 0 if failed.
 293  */
 294 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
 295 {
 296         ide_task_t args;
 297         struct ide_taskfile *tf = &args.tf;
 298         u64 addr = 0;
 299
 300         /* Create IDE/ATA command request structure */
 301         memset(&args, 0, sizeof(ide_task_t));
 302         if (lba48)
 303                 tf->command = WIN_READ_NATIVE_MAX_EXT;
 304         else
 305                 tf->command = WIN_READ_NATIVE_MAX;
 306         tf->device  = ATA_LBA;
 307         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 308         if (lba48)
 309                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
 310         /* submit command request */
 311         ide_no_data_taskfile(drive, &args);
 312
 313         /* if OK, compute maximum address value */
 314         if ((tf->status & 0x01) == 0) {
 315                 u32 high, low;
 316
 317                 if (lba48)
 318                         high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
 319                                 tf->hob_lbal;
 320                 else
 321                         high = tf->device & 0xf;
 322                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 323                 addr = ((__u64)high << 24) | low;
 324                 addr++; /* since the return value is (maxlba - 1), we add 1 */
 325         }
 326         return addr;
 327 }
 328
 329 /*
 330  * Sets maximum virtual LBA address of the drive.
 331  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
 332  */
 333 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
 334 {
 335         ide_task_t args;
 336         struct ide_taskfile *tf = &args.tf;
 337         u64 addr_set = 0;
 338
 339         addr_req--;
 340         /* Create IDE/ATA command request structure */
 341         memset(&args, 0, sizeof(ide_task_t));
 342         tf->lbal     = (addr_req >>  0) & 0xff;
 343         tf->lbam     = (addr_req >>= 8) & 0xff;
 344         tf->lbah     = (addr_req >>= 8) & 0xff;
 345         if (lba48) {
 346                 tf->hob_lbal = (addr_req >>= 8) & 0xff;
 347                 tf->hob_lbam = (addr_req >>= 8) & 0xff;
 348                 tf->hob_lbah = (addr_req >>= 8) & 0xff;
 349                 tf->command  = WIN_SET_MAX_EXT;
 350         } else {
 351                 tf->device   = (addr_req >>= 8) & 0x0f;
 352                 tf->command  = WIN_SET_MAX;
 353         }
 354         tf->device |= ATA_LBA;
 355         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 356         if (lba48)
 357                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
 358         /* submit command request */
 359         ide_no_data_taskfile(drive, &args);
 360         /* if OK, compute maximum address value */
 361         if ((tf->status & 0x01) == 0) {
 362                 u32 high, low;
 363
 364                 if (lba48)
 365                         high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
 366                                 tf->hob_lbal;
 367                 else
 368                         high = tf->device & 0xf;
 369                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 370                 addr_set = ((__u64)high << 24) | low;
 371                 addr_set++;
 372         }
 373         return addr_set;
 374 }
 375
 376 static unsigned long long sectors_to_MB(unsigned long long n)
 377 {
 378         n <<= 9;                /* make it bytes */
 379         do_div(n, 1000000);     /* make it MB */
 380         return n;
 381 }
 382
 383 /*
 384  * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
 385  * so on non-buggy drives we need test only one.
 386  * However, we should also check whether these fields are valid.
 387  */
 388 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
 389 {
 390         return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
 391 }
 392
 393 /*
 394  * The same here.
 395  */
 396 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
 397 {
 398         return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
 399                && id->lba_capacity_2;
 400 }
 401
 402 /*
 403  * Some disks report total number of sectors instead of
 404  * maximum sector address.  We list them here.
 405  */
 406 static const struct drive_list_entry hpa_list[] = {
 407         { "ST340823A",  NULL },
 408         { "ST320413A",  NULL },
 409         { NULL,         NULL }
 410 };
 411
 412 static void idedisk_check_hpa(ide_drive_t *drive)
 413 {
 414         unsigned long long capacity, set_max;
 415         int lba48 = idedisk_supports_lba48(drive->id);
 416
 417         capacity = drive->capacity64;
 418
 419         set_max = idedisk_read_native_max_address(drive, lba48);
 420
 421         if (ide_in_drive_list(drive->id, hpa_list)) {
 422                 /*
 423                  * Since we are inclusive wrt to firmware revisions do this
 424                  * extra check and apply the workaround only when needed.
 425                  */
 426                 if (set_max == capacity + 1)
 427                         set_max--;
 428         }
 429
 430         if (set_max <= capacity)
 431                 return;
 432
 433         printk(KERN_INFO "%s: Host Protected Area detected.\n"
 434                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
 435                          "\tnative  capacity is %llu sectors (%llu MB)\n",
 436                          drive->name,
 437                          capacity, sectors_to_MB(capacity),
 438                          set_max, sectors_to_MB(set_max));
 439
 440         set_max = idedisk_set_max_address(drive, set_max, lba48);
 441
 442         if (set_max) {
 443                 drive->capacity64 = set_max;
 444                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
 445                                  drive->name);
 446         }
 447 }
 448
 449 /*
 450  * Compute drive->capacity, the full capacity of the drive
 451  * Called with drive->id != NULL.
 452  *
 453  * To compute capacity, this uses either of
 454  *
 455  *    1. CHS value set by user       (whatever user sets will be trusted)
 456  *    2. LBA value from target drive (require new ATA feature)
 457  *    3. LBA value from system BIOS  (new one is OK, old one may break)
 458  *    4. CHS value from system BIOS  (traditional style)
 459  *
 460  * in above order (i.e., if value of higher priority is available,
 461  * reset will be ignored).
 462  */
 463 static void init_idedisk_capacity (ide_drive_t  *drive)
 464 {
 465         struct hd_driveid *id = drive->id;
 466         /*
 467          * If this drive supports the Host Protected Area feature set,
 468          * then we may need to change our opinion about the drive's capacity.
 469          */
 470         int hpa = idedisk_supports_hpa(id);
 471
 472         if (idedisk_supports_lba48(id)) {
 473                 /* drive speaks 48-bit LBA */
 474                 drive->select.b.lba = 1;
 475                 drive->capacity64 = id->lba_capacity_2;
 476                 if (hpa)
 477                         idedisk_check_hpa(drive);
 478         } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
 479                 /* drive speaks 28-bit LBA */
 480                 drive->select.b.lba = 1;
 481                 drive->capacity64 = id->lba_capacity;
 482                 if (hpa)
 483                         idedisk_check_hpa(drive);
 484         } else {
 485                 /* drive speaks boring old 28-bit CHS */
 486                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
 487         }
 488 }
 489
 490 static sector_t idedisk_capacity (ide_drive_t *drive)
 491 {
 492         return drive->capacity64 - drive->sect0;
 493 }
 494
 495 #ifdef CONFIG_IDE_PROC_FS
 496 static int smart_enable(ide_drive_t *drive)
 497 {
 498         ide_task_t args;
 499         struct ide_taskfile *tf = &args.tf;
 500
 501         memset(&args, 0, sizeof(ide_task_t));
 502         tf->feature = SMART_ENABLE;
 503         tf->lbam    = SMART_LCYL_PASS;
 504         tf->lbah    = SMART_HCYL_PASS;
 505         tf->command = WIN_SMART;
 506         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 507         return ide_no_data_taskfile(drive, &args);
 508 }
 509
 510 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 511 {
 512         ide_task_t args;
 513         struct ide_taskfile *tf = &args.tf;
 514
 515         memset(&args, 0, sizeof(ide_task_t));
 516         tf->feature = sub_cmd;
 517         tf->nsect   = 0x01;
 518         tf->lbam    = SMART_LCYL_PASS;
 519         tf->lbah    = SMART_HCYL_PASS;
 520         tf->command = WIN_SMART;
 521         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 522         args.command_type                       = IDE_DRIVE_TASK_IN;
 523         args.data_phase                         = TASKFILE_IN;
 524         args.handler                            = &task_in_intr;
 525         (void) smart_enable(drive);
 526         return ide_raw_taskfile(drive, &args, buf);
 527 }
 528
 529 static int proc_idedisk_read_cache
 530         (char *page, char **start, off_t off, int count, int *eof, void *data)
 531 {
 532         ide_drive_t     *drive = (ide_drive_t *) data;
 533         char            *out = page;
 534         int             len;
 535
 536         if (drive->id_read)
 537                 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
 538         else
 539                 len = sprintf(out,"(none)\n");
 540         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 541 }
 542
 543 static int proc_idedisk_read_capacity
 544         (char *page, char **start, off_t off, int count, int *eof, void *data)
 545 {
 546         ide_drive_t*drive = (ide_drive_t *)data;
 547         int len;
 548
 549         len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
 550         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 551 }
 552
 553 static int proc_idedisk_read_smart_thresholds
 554         (char *page, char **start, off_t off, int count, int *eof, void *data)
 555 {
 556         ide_drive_t     *drive = (ide_drive_t *)data;
 557         int             len = 0, i = 0;
 558
 559         if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
 560                 unsigned short *val = (unsigned short *) page;
 561                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 562                 page = out;
 563                 do {
 564                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 565                         val += 1;
 566                 } while (i < (SECTOR_WORDS * 2));
 567                 len = out - page;
 568         }
 569         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 570 }
 571
 572 static int proc_idedisk_read_smart_values
 573         (char *page, char **start, off_t off, int count, int *eof, void *data)
 574 {
 575         ide_drive_t     *drive = (ide_drive_t *)data;
 576         int             len = 0, i = 0;
 577
 578         if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
 579                 unsigned short *val = (unsigned short *) page;
 580                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 581                 page = out;
 582                 do {
 583                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 584                         val += 1;
 585                 } while (i < (SECTOR_WORDS * 2));
 586                 len = out - page;
 587         }
 588         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 589 }
 590
 591 static ide_proc_entry_t idedisk_proc[] = {
 592         { "cache",              S_IFREG|S_IRUGO,        proc_idedisk_read_cache,                NULL },
 593         { "capacity",           S_IFREG|S_IRUGO,        proc_idedisk_read_capacity,             NULL },
 594         { "geometry",           S_IFREG|S_IRUGO,        proc_ide_read_geometry,                 NULL },
 595         { "smart_values",       S_IFREG|S_IRUSR,        proc_idedisk_read_smart_values,         NULL },
 596         { "smart_thresholds",   S_IFREG|S_IRUSR,        proc_idedisk_read_smart_thresholds,     NULL },
 597         { NULL, 0, NULL, NULL }
 598 };
 599 #endif  /* CONFIG_IDE_PROC_FS */
 600
 601 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 602 {
 603         ide_drive_t *drive = q->queuedata;
 604         ide_task_t task;
 605
 606         memset(&task, 0, sizeof(task));
 607         if (ide_id_has_flush_cache_ext(drive->id) &&
 608             (drive->capacity64 >= (1UL << 28)))
 609                 task.tf.command = WIN_FLUSH_CACHE_EXT;
 610         else
 611                 task.tf.command = WIN_FLUSH_CACHE;
 612         task.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 613         task.command_type = IDE_DRIVE_TASK_NO_DATA;
 614         task.handler = task_no_data_intr;
 615
 616         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
 617         rq->cmd_flags |= REQ_SOFTBARRIER;
 618         rq->special = &task;
 619 }
 620
 621 /*
 622  * This is tightly woven into the driver->do_special can not touch.
 623  * DON'T do it again until a total personality rewrite is committed.
 624  */
 625 static int set_multcount(ide_drive_t *drive, int arg)
 626 {
 627         struct request rq;
 628
 629         if (arg < 0 || arg > drive->id->max_multsect)
 630                 return -EINVAL;
 631
 632         if (drive->special.b.set_multmode)
 633                 return -EBUSY;
 634         ide_init_drive_cmd (&rq);
 635         rq.cmd_type = REQ_TYPE_ATA_CMD;
 636         drive->mult_req = arg;
 637         drive->special.b.set_multmode = 1;
 638         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
 639         return (drive->mult_count == arg) ? 0 : -EIO;
 640 }
 641
 642 static int set_nowerr(ide_drive_t *drive, int arg)
 643 {
 644         if (arg < 0 || arg > 1)
 645                 return -EINVAL;
 646
 647         if (ide_spin_wait_hwgroup(drive))
 648                 return -EBUSY;
 649         drive->nowerr = arg;
 650         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
 651         spin_unlock_irq(&ide_lock);
 652         return 0;
 653 }
 654
 655 static void update_ordered(ide_drive_t *drive)
 656 {
 657         struct hd_driveid *id = drive->id;
 658         unsigned ordered = QUEUE_ORDERED_NONE;
 659         prepare_flush_fn *prep_fn = NULL;
 660
 661         if (drive->wcache) {
 662                 unsigned long long capacity;
 663                 int barrier;
 664                 /*
 665                  * We must avoid issuing commands a drive does not
 666                  * understand or we may crash it. We check flush cache
 667                  * is supported. We also check we have the LBA48 flush
 668                  * cache if the drive capacity is too large. By this
 669                  * time we have trimmed the drive capacity if LBA48 is
 670                  * not available so we don't need to recheck that.
 671                  */
 672                 capacity = idedisk_capacity(drive);
 673                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
 674                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
 675                          ide_id_has_flush_cache_ext(id));
 676
 677                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
 678                        drive->name, barrier ? "" : "not ");
 679
 680                 if (barrier) {
 681                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
 682                         prep_fn = idedisk_prepare_flush;
 683                 }
 684         } else
 685                 ordered = QUEUE_ORDERED_DRAIN;
 686
 687         blk_queue_ordered(drive->queue, ordered, prep_fn);
 688 }
 689
 690 static int write_cache(ide_drive_t *drive, int arg)
 691 {
 692         ide_task_t args;
 693         int err = 1;
 694
 695         if (arg < 0 || arg > 1)
 696                 return -EINVAL;
 697
 698         if (ide_id_has_flush_cache(drive->id)) {
 699                 memset(&args, 0, sizeof(ide_task_t));
 700                 args.tf.feature = arg ?
 701                         SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
 702                 args.tf.command = WIN_SETFEATURES;
 703                 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 704                 err = ide_no_data_taskfile(drive, &args);
 705                 if (err == 0)
 706                         drive->wcache = arg;
 707         }
 708
 709         update_ordered(drive);
 710
 711         return err;
 712 }
 713
 714 static int do_idedisk_flushcache (ide_drive_t *drive)
 715 {
 716         ide_task_t args;
 717
 718         memset(&args, 0, sizeof(ide_task_t));
 719         if (ide_id_has_flush_cache_ext(drive->id))
 720                 args.tf.command = WIN_FLUSH_CACHE_EXT;
 721         else
 722                 args.tf.command = WIN_FLUSH_CACHE;
 723         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 724         return ide_no_data_taskfile(drive, &args);
 725 }
 726
 727 static int set_acoustic (ide_drive_t *drive, int arg)
 728 {
 729         ide_task_t args;
 730
 731         if (arg < 0 || arg > 254)
 732                 return -EINVAL;
 733
 734         memset(&args, 0, sizeof(ide_task_t));
 735         args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
 736         args.tf.nsect   = arg;
 737         args.tf.command = WIN_SETFEATURES;
 738         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 739         ide_no_data_taskfile(drive, &args);
 740         drive->acoustic = arg;
 741         return 0;
 742 }
 743
 744 /*
 745  * drive->addressing:
 746  *      0: 28-bit
 747  *      1: 48-bit
 748  *      2: 48-bit capable doing 28-bit
 749  */
 750 static int set_lba_addressing(ide_drive_t *drive, int arg)
 751 {
 752         if (arg < 0 || arg > 2)
 753                 return -EINVAL;
 754
 755         drive->addressing =  0;
 756
 757         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
 758                 return 0;
 759
 760         if (!idedisk_supports_lba48(drive->id))
 761                 return -EIO;
 762         drive->addressing = arg;
 763         return 0;
 764 }
 765
 766 #ifdef CONFIG_IDE_PROC_FS
 767 static void idedisk_add_settings(ide_drive_t *drive)
 768 {
 769         struct hd_driveid *id = drive->id;
 770
 771         ide_add_setting(drive,  "bios_cyl",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->bios_cyl,       NULL);
 772         ide_add_setting(drive,  "bios_head",    SETTING_RW,     TYPE_BYTE,      0,      255,                    1,      1,      &drive->bios_head,      NULL);
 773         ide_add_setting(drive,  "bios_sect",    SETTING_RW,     TYPE_BYTE,      0,      63,                     1,      1,      &drive->bios_sect,      NULL);
 774         ide_add_setting(drive,  "address",      SETTING_RW,     TYPE_BYTE,      0,      2,                      1,      1,      &drive->addressing,     set_lba_addressing);
 775         ide_add_setting(drive,  "bswap",        SETTING_READ,   TYPE_BYTE,      0,      1,                      1,      1,      &drive->bswap,          NULL);
 776         ide_add_setting(drive,  "multcount",    SETTING_RW,     TYPE_BYTE,      0,      id->max_multsect,       1,      1,      &drive->mult_count,     set_multcount);
 777         ide_add_setting(drive,  "nowerr",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->nowerr,         set_nowerr);
 778         ide_add_setting(drive,  "lun",          SETTING_RW,     TYPE_INT,       0,      7,                      1,      1,      &drive->lun,            NULL);
 779         ide_add_setting(drive,  "wcache",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->wcache,         write_cache);
 780         ide_add_setting(drive,  "acoustic",     SETTING_RW,     TYPE_BYTE,      0,      254,                    1,      1,      &drive->acoustic,       set_acoustic);
 781         ide_add_setting(drive,  "failures",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->failures,       NULL);
 782         ide_add_setting(drive,  "max_failures", SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->max_failures,   NULL);
 783 }
 784 #else
 785 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
 786 #endif
 787
 788 static void idedisk_setup (ide_drive_t *drive)
 789 {
 790         ide_hwif_t *hwif = drive->hwif;
 791         struct hd_driveid *id = drive->id;
 792         unsigned long long capacity;
 793
 794         idedisk_add_settings(drive);
 795
 796         if (drive->id_read == 0)
 797                 return;
 798
 799         if (drive->removable) {
 800                 /*
 801                  * Removable disks (eg. SYQUEST); ignore 'WD' drives
 802                  */
 803                 if (id->model[0] != 'W' || id->model[1] != 'D') {
 804                         drive->doorlocking = 1;
 805                 }
 806         }
 807
 808         (void)set_lba_addressing(drive, 1);
 809
 810         if (drive->addressing == 1) {
 811                 int max_s = 2048;
 812
 813                 if (max_s > hwif->rqsize)
 814                         max_s = hwif->rqsize;
 815
 816                 blk_queue_max_sectors(drive->queue, max_s);
 817         }
 818
 819         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
 820
 821         /* calculate drive capacity, and select LBA if possible */
 822         init_idedisk_capacity (drive);
 823
 824         /* limit drive capacity to 137GB if LBA48 cannot be used */
 825         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
 826                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
 827                        "%llu sectors (%llu MB)\n",
 828                        drive->name, (unsigned long long)drive->capacity64,
 829                        sectors_to_MB(drive->capacity64));
 830                 drive->capacity64 = 1ULL << 28;
 831         }
 832
 833         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
 834                 if (drive->capacity64 > 1ULL << 28) {
 835                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
 836                                          " be used for accessing sectors > %u\n",
 837                                          drive->name, 1 << 28);
 838                 } else
 839                         drive->addressing = 0;
 840         }
 841
 842         /*
 843          * if possible, give fdisk access to more of the drive,
 844          * by correcting bios_cyls:
 845          */
 846         capacity = idedisk_capacity (drive);
 847         if (!drive->forced_geom) {
 848
 849                 if (idedisk_supports_lba48(drive->id)) {
 850                         /* compatibility */
 851                         drive->bios_sect = 63;
 852                         drive->bios_head = 255;
 853                 }
 854
 855                 if (drive->bios_sect && drive->bios_head) {
 856                         unsigned int cap0 = capacity; /* truncate to 32 bits */
 857                         unsigned int cylsz, cyl;
 858
 859                         if (cap0 != capacity)
 860                                 drive->bios_cyl = 65535;
 861                         else {
 862                                 cylsz = drive->bios_sect * drive->bios_head;
 863                                 cyl = cap0 / cylsz;
 864                                 if (cyl > 65535)
 865                                         cyl = 65535;
 866                                 if (cyl > drive->bios_cyl)
 867                                         drive->bios_cyl = cyl;
 868                         }
 869                 }
 870         }
 871         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
 872                          drive->name, capacity, sectors_to_MB(capacity));
 873
 874         /* Only print cache size when it was specified */
 875         if (id->buf_size)
 876                 printk (" w/%dKiB Cache", id->buf_size/2);
 877
 878         printk(KERN_CONT ", CHS=%d/%d/%d\n",
 879                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
 880
 881         /* write cache enabled? */
 882         if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
 883                 drive->wcache = 1;
 884
 885         write_cache(drive, 1);
 886 }
 887
 888 static void ide_cacheflush_p(ide_drive_t *drive)
 889 {
 890         if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
 891                 return;
 892
 893         if (do_idedisk_flushcache(drive))
 894                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 895 }
 896
 897 static void ide_disk_remove(ide_drive_t *drive)
 898 {
 899         struct ide_disk_obj *idkp = drive->driver_data;
 900         struct gendisk *g = idkp->disk;
 901
 902         ide_proc_unregister_driver(drive, idkp->driver);
 903
 904         del_gendisk(g);
 905
 906         ide_cacheflush_p(drive);
 907
 908         ide_disk_put(idkp);
 909 }
 910
 911 static void ide_disk_release(struct kref *kref)
 912 {
 913         struct ide_disk_obj *idkp = to_ide_disk(kref);
 914         ide_drive_t *drive = idkp->drive;
 915         struct gendisk *g = idkp->disk;
 916
 917         drive->driver_data = NULL;
 918         g->private_data = NULL;
 919         put_disk(g);
 920         kfree(idkp);
 921 }
 922
 923 static int ide_disk_probe(ide_drive_t *drive);
 924
 925 /*
 926  * On HPA drives the capacity needs to be
 927  * reinitilized on resume otherwise the disk
 928  * can not be used and a hard reset is required
 929  */
 930 static void ide_disk_resume(ide_drive_t *drive)
 931 {
 932         if (idedisk_supports_hpa(drive->id))
 933                 init_idedisk_capacity(drive);
 934 }
 935
 936 static void ide_device_shutdown(ide_drive_t *drive)
 937 {
 938 #ifdef  CONFIG_ALPHA
 939         /* On Alpha, halt(8) doesn't actually turn the machine off,
 940            it puts you into the sort of firmware monitor. Typically,
 941            it's used to boot another kernel image, so it's not much
 942            different from reboot(8). Therefore, we don't need to
 943            spin down the disk in this case, especially since Alpha
 944            firmware doesn't handle disks in standby mode properly.
 945            On the other hand, it's reasonably safe to turn the power
 946            off when the shutdown process reaches the firmware prompt,
 947            as the firmware initialization takes rather long time -
 948            at least 10 seconds, which should be sufficient for
 949            the disk to expire its write cache. */
 950         if (system_state != SYSTEM_POWER_OFF) {
 951 #else
 952         if (system_state == SYSTEM_RESTART) {
 953 #endif
 954                 ide_cacheflush_p(drive);
 955                 return;
 956         }
 957
 958         printk("Shutdown: %s\n", drive->name);
 959         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
 960 }
 961
 962 static ide_driver_t idedisk_driver = {
 963         .gen_driver = {
 964                 .owner          = THIS_MODULE,
 965                 .name           = "ide-disk",
 966                 .bus            = &ide_bus_type,
 967         },
 968         .probe                  = ide_disk_probe,
 969         .remove                 = ide_disk_remove,
 970         .resume                 = ide_disk_resume,
 971         .shutdown               = ide_device_shutdown,
 972         .version                = IDEDISK_VERSION,
 973         .media                  = ide_disk,
 974         .supports_dsc_overlap   = 0,
 975         .do_request             = ide_do_rw_disk,
 976         .end_request            = ide_end_request,
 977         .error                  = __ide_error,
 978         .abort                  = __ide_abort,
 979 #ifdef CONFIG_IDE_PROC_FS
 980         .proc                   = idedisk_proc,
 981 #endif
 982 };
 983
 984 static int idedisk_open(struct inode *inode, struct file *filp)
 985 {
 986         struct gendisk *disk = inode->i_bdev->bd_disk;
 987         struct ide_disk_obj *idkp;
 988         ide_drive_t *drive;
 989
 990         if (!(idkp = ide_disk_get(disk)))
 991                 return -ENXIO;
 992
 993         drive = idkp->drive;
 994
 995         idkp->openers++;
 996
 997         if (drive->removable && idkp->openers == 1) {
 998                 ide_task_t args;
 999                 memset(&args, 0, sizeof(ide_task_t));
1000                 args.tf.command = WIN_DOORLOCK;
1001                 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
1002                 check_disk_change(inode->i_bdev);
1003                 /*
1004                  * Ignore the return code from door_lock,
1005                  * since the open() has already succeeded,
1006                  * and the door_lock is irrelevant at this point.
1007                  */
1008                 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
1009                         drive->doorlocking = 0;
1010         }
1011         return 0;
1012 }
1013
1014 static int idedisk_release(struct inode *inode, struct file *filp)
1015 {
1016         struct gendisk *disk = inode->i_bdev->bd_disk;
1017         struct ide_disk_obj *idkp = ide_disk_g(disk);
1018         ide_drive_t *drive = idkp->drive;
1019
1020         if (idkp->openers == 1)
1021                 ide_cacheflush_p(drive);
1022
1023         if (drive->removable && idkp->openers == 1) {
1024                 ide_task_t args;
1025                 memset(&args, 0, sizeof(ide_task_t));
1026                 args.tf.command = WIN_DOORUNLOCK;
1027                 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
1028                 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
1029                         drive->doorlocking = 0;
1030         }
1031
1032         idkp->openers--;
1033
1034         ide_disk_put(idkp);
1035
1036         return 0;
1037 }
1038
1039 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1040 {
1041         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1042         ide_drive_t *drive = idkp->drive;
1043
1044         geo->heads = drive->bios_head;
1045         geo->sectors = drive->bios_sect;
1046         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1047         return 0;
1048 }
1049
1050 static int idedisk_ioctl(struct inode *inode, struct file *file,
1051                         unsigned int cmd, unsigned long arg)
1052 {
1053         unsigned long flags;
1054         struct block_device *bdev = inode->i_bdev;
1055         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1056         ide_drive_t *drive = idkp->drive;
1057         int err, (*setfunc)(ide_drive_t *, int);
1058         u8 *val;
1059
1060         switch (cmd) {
1061         case HDIO_GET_ADDRESS:   val = &drive->addressing;      goto read_val;
1062         case HDIO_GET_MULTCOUNT: val = &drive->mult_count;      goto read_val;
1063         case HDIO_GET_NOWERR:    val = &drive->nowerr;          goto read_val;
1064         case HDIO_GET_WCACHE:    val = &drive->wcache;          goto read_val;
1065         case HDIO_GET_ACOUSTIC:  val = &drive->acoustic;        goto read_val;
1066         case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
1067         case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
1068         case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
1069         case HDIO_SET_WCACHE:    setfunc = write_cache;         goto set_val;
1070         case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
1071         }
1072
1073         return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1074
1075 read_val:
1076         mutex_lock(&ide_setting_mtx);
1077         spin_lock_irqsave(&ide_lock, flags);
1078         err = *val;
1079         spin_unlock_irqrestore(&ide_lock, flags);
1080         mutex_unlock(&ide_setting_mtx);
1081         return err >= 0 ? put_user(err, (long __user *)arg) : err;
1082
1083 set_val:
1084         if (bdev != bdev->bd_contains)
1085                 err = -EINVAL;
1086         else {
1087                 if (!capable(CAP_SYS_ADMIN))
1088                         err = -EACCES;
1089                 else {
1090                         mutex_lock(&ide_setting_mtx);
1091                         err = setfunc(drive, arg);
1092                         mutex_unlock(&ide_setting_mtx);
1093                 }
1094         }
1095         return err;
1096 }
1097
1098 static int idedisk_media_changed(struct gendisk *disk)
1099 {
1100         struct ide_disk_obj *idkp = ide_disk_g(disk);
1101         ide_drive_t *drive = idkp->drive;
1102
1103         /* do not scan partitions twice if this is a removable device */
1104         if (drive->attach) {
1105                 drive->attach = 0;
1106                 return 0;
1107         }
1108         /* if removable, always assume it was changed */
1109         return drive->removable;
1110 }
1111
1112 static int idedisk_revalidate_disk(struct gendisk *disk)
1113 {
1114         struct ide_disk_obj *idkp = ide_disk_g(disk);
1115         set_capacity(disk, idedisk_capacity(idkp->drive));
1116         return 0;
1117 }
1118
1119 static struct block_device_operations idedisk_ops = {
1120         .owner          = THIS_MODULE,
1121         .open           = idedisk_open,
1122         .release        = idedisk_release,
1123         .ioctl          = idedisk_ioctl,
1124         .getgeo         = idedisk_getgeo,
1125         .media_changed  = idedisk_media_changed,
1126         .revalidate_disk= idedisk_revalidate_disk
1127 };
1128
1129 MODULE_DESCRIPTION("ATA DISK Driver");
1130
1131 static int ide_disk_probe(ide_drive_t *drive)
1132 {
1133         struct ide_disk_obj *idkp;
1134         struct gendisk *g;
1135
1136         /* strstr("foo", "") is non-NULL */
1137         if (!strstr("ide-disk", drive->driver_req))
1138                 goto failed;
1139         if (!drive->present)
1140                 goto failed;
1141         if (drive->media != ide_disk)
1142                 goto failed;
1143
1144         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1145         if (!idkp)
1146                 goto failed;
1147
1148         g = alloc_disk_node(1 << PARTN_BITS,
1149                         hwif_to_node(drive->hwif));
1150         if (!g)
1151                 goto out_free_idkp;
1152
1153         ide_init_disk(g, drive);
1154
1155         ide_proc_register_driver(drive, &idedisk_driver);
1156
1157         kref_init(&idkp->kref);
1158
1159         idkp->drive = drive;
1160         idkp->driver = &idedisk_driver;
1161         idkp->disk = g;
1162
1163         g->private_data = &idkp->driver;
1164
1165         drive->driver_data = idkp;
1166
1167         idedisk_setup(drive);
1168         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1169                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1170                         drive->name, drive->head);
1171                 drive->attach = 0;
1172         } else
1173                 drive->attach = 1;
1174
1175         g->minors = 1 << PARTN_BITS;
1176         g->driverfs_dev = &drive->gendev;
1177         g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1178         set_capacity(g, idedisk_capacity(drive));
1179         g->fops = &idedisk_ops;
1180         add_disk(g);
1181         return 0;
1182
1183 out_free_idkp:
1184         kfree(idkp);
1185 failed:
1186         return -ENODEV;
1187 }
1188
1189 static void __exit idedisk_exit (void)
1190 {
1191         driver_unregister(&idedisk_driver.gen_driver);
1192 }
1193
1194 static int __init idedisk_init(void)
1195 {
1196         return driver_register(&idedisk_driver.gen_driver);
1197 }
1198
1199 MODULE_ALIAS("ide:*m-disk*");
1200 module_init(idedisk_init);
1201 module_exit(idedisk_exit);
1202 MODULE_LICENSE("GPL");