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