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