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                 hwif->OUTBSYNC(drive, command, IDE_COMMAND_REG);
 251                 ndelay(400);    /* FIXME */
 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         (void) smart_enable(drive);
 522         return ide_raw_taskfile(drive, &args, buf, 1);
 523 }
 524
 525 static int proc_idedisk_read_cache
 526         (char *page, char **start, off_t off, int count, int *eof, void *data)
 527 {
 528         ide_drive_t     *drive = (ide_drive_t *) data;
 529         char            *out = page;
 530         int             len;
 531
 532         if (drive->id_read)
 533                 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
 534         else
 535                 len = sprintf(out,"(none)\n");
 536         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 537 }
 538
 539 static int proc_idedisk_read_capacity
 540         (char *page, char **start, off_t off, int count, int *eof, void *data)
 541 {
 542         ide_drive_t*drive = (ide_drive_t *)data;
 543         int len;
 544
 545         len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
 546         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 547 }
 548
 549 static int proc_idedisk_read_smart_thresholds
 550         (char *page, char **start, off_t off, int count, int *eof, void *data)
 551 {
 552         ide_drive_t     *drive = (ide_drive_t *)data;
 553         int             len = 0, i = 0;
 554
 555         if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
 556                 unsigned short *val = (unsigned short *) page;
 557                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 558                 page = out;
 559                 do {
 560                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 561                         val += 1;
 562                 } while (i < (SECTOR_WORDS * 2));
 563                 len = out - page;
 564         }
 565         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 566 }
 567
 568 static int proc_idedisk_read_smart_values
 569         (char *page, char **start, off_t off, int count, int *eof, void *data)
 570 {
 571         ide_drive_t     *drive = (ide_drive_t *)data;
 572         int             len = 0, i = 0;
 573
 574         if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
 575                 unsigned short *val = (unsigned short *) page;
 576                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 577                 page = out;
 578                 do {
 579                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 580                         val += 1;
 581                 } while (i < (SECTOR_WORDS * 2));
 582                 len = out - page;
 583         }
 584         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 585 }
 586
 587 static ide_proc_entry_t idedisk_proc[] = {
 588         { "cache",              S_IFREG|S_IRUGO,        proc_idedisk_read_cache,                NULL },
 589         { "capacity",           S_IFREG|S_IRUGO,        proc_idedisk_read_capacity,             NULL },
 590         { "geometry",           S_IFREG|S_IRUGO,        proc_ide_read_geometry,                 NULL },
 591         { "smart_values",       S_IFREG|S_IRUSR,        proc_idedisk_read_smart_values,         NULL },
 592         { "smart_thresholds",   S_IFREG|S_IRUSR,        proc_idedisk_read_smart_thresholds,     NULL },
 593         { NULL, 0, NULL, NULL }
 594 };
 595 #endif  /* CONFIG_IDE_PROC_FS */
 596
 597 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 598 {
 599         ide_drive_t *drive = q->queuedata;
 600         ide_task_t task;
 601
 602         memset(&task, 0, sizeof(task));
 603         if (ide_id_has_flush_cache_ext(drive->id) &&
 604             (drive->capacity64 >= (1UL << 28)))
 605                 task.tf.command = WIN_FLUSH_CACHE_EXT;
 606         else
 607                 task.tf.command = WIN_FLUSH_CACHE;
 608         task.tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 609         task.data_phase = TASKFILE_NO_DATA;
 610
 611         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
 612         rq->cmd_flags |= REQ_SOFTBARRIER;
 613         rq->special = &task;
 614 }
 615
 616 /*
 617  * This is tightly woven into the driver->do_special can not touch.
 618  * DON'T do it again until a total personality rewrite is committed.
 619  */
 620 static int set_multcount(ide_drive_t *drive, int arg)
 621 {
 622         struct request rq;
 623
 624         if (arg < 0 || arg > drive->id->max_multsect)
 625                 return -EINVAL;
 626
 627         if (drive->special.b.set_multmode)
 628                 return -EBUSY;
 629         ide_init_drive_cmd (&rq);
 630         rq.cmd_type = REQ_TYPE_ATA_CMD;
 631         drive->mult_req = arg;
 632         drive->special.b.set_multmode = 1;
 633         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
 634         return (drive->mult_count == arg) ? 0 : -EIO;
 635 }
 636
 637 static int set_nowerr(ide_drive_t *drive, int arg)
 638 {
 639         if (arg < 0 || arg > 1)
 640                 return -EINVAL;
 641
 642         if (ide_spin_wait_hwgroup(drive))
 643                 return -EBUSY;
 644         drive->nowerr = arg;
 645         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
 646         spin_unlock_irq(&ide_lock);
 647         return 0;
 648 }
 649
 650 static void update_ordered(ide_drive_t *drive)
 651 {
 652         struct hd_driveid *id = drive->id;
 653         unsigned ordered = QUEUE_ORDERED_NONE;
 654         prepare_flush_fn *prep_fn = NULL;
 655
 656         if (drive->wcache) {
 657                 unsigned long long capacity;
 658                 int barrier;
 659                 /*
 660                  * We must avoid issuing commands a drive does not
 661                  * understand or we may crash it. We check flush cache
 662                  * is supported. We also check we have the LBA48 flush
 663                  * cache if the drive capacity is too large. By this
 664                  * time we have trimmed the drive capacity if LBA48 is
 665                  * not available so we don't need to recheck that.
 666                  */
 667                 capacity = idedisk_capacity(drive);
 668                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
 669                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
 670                          ide_id_has_flush_cache_ext(id));
 671
 672                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
 673                        drive->name, barrier ? "" : "not ");
 674
 675                 if (barrier) {
 676                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
 677                         prep_fn = idedisk_prepare_flush;
 678                 }
 679         } else
 680                 ordered = QUEUE_ORDERED_DRAIN;
 681
 682         blk_queue_ordered(drive->queue, ordered, prep_fn);
 683 }
 684
 685 static int write_cache(ide_drive_t *drive, int arg)
 686 {
 687         ide_task_t args;
 688         int err = 1;
 689
 690         if (arg < 0 || arg > 1)
 691                 return -EINVAL;
 692
 693         if (ide_id_has_flush_cache(drive->id)) {
 694                 memset(&args, 0, sizeof(ide_task_t));
 695                 args.tf.feature = arg ?
 696                         SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
 697                 args.tf.command = WIN_SETFEATURES;
 698                 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 699                 err = ide_no_data_taskfile(drive, &args);
 700                 if (err == 0)
 701                         drive->wcache = arg;
 702         }
 703
 704         update_ordered(drive);
 705
 706         return err;
 707 }
 708
 709 static int do_idedisk_flushcache (ide_drive_t *drive)
 710 {
 711         ide_task_t args;
 712
 713         memset(&args, 0, sizeof(ide_task_t));
 714         if (ide_id_has_flush_cache_ext(drive->id))
 715                 args.tf.command = WIN_FLUSH_CACHE_EXT;
 716         else
 717                 args.tf.command = WIN_FLUSH_CACHE;
 718         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 719         return ide_no_data_taskfile(drive, &args);
 720 }
 721
 722 static int set_acoustic (ide_drive_t *drive, int arg)
 723 {
 724         ide_task_t args;
 725
 726         if (arg < 0 || arg > 254)
 727                 return -EINVAL;
 728
 729         memset(&args, 0, sizeof(ide_task_t));
 730         args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
 731         args.tf.nsect   = arg;
 732         args.tf.command = WIN_SETFEATURES;
 733         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 734         ide_no_data_taskfile(drive, &args);
 735         drive->acoustic = arg;
 736         return 0;
 737 }
 738
 739 /*
 740  * drive->addressing:
 741  *      0: 28-bit
 742  *      1: 48-bit
 743  *      2: 48-bit capable doing 28-bit
 744  */
 745 static int set_lba_addressing(ide_drive_t *drive, int arg)
 746 {
 747         if (arg < 0 || arg > 2)
 748                 return -EINVAL;
 749
 750         drive->addressing =  0;
 751
 752         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
 753                 return 0;
 754
 755         if (!idedisk_supports_lba48(drive->id))
 756                 return -EIO;
 757         drive->addressing = arg;
 758         return 0;
 759 }
 760
 761 #ifdef CONFIG_IDE_PROC_FS
 762 static void idedisk_add_settings(ide_drive_t *drive)
 763 {
 764         struct hd_driveid *id = drive->id;
 765
 766         ide_add_setting(drive,  "bios_cyl",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->bios_cyl,       NULL);
 767         ide_add_setting(drive,  "bios_head",    SETTING_RW,     TYPE_BYTE,      0,      255,                    1,      1,      &drive->bios_head,      NULL);
 768         ide_add_setting(drive,  "bios_sect",    SETTING_RW,     TYPE_BYTE,      0,      63,                     1,      1,      &drive->bios_sect,      NULL);
 769         ide_add_setting(drive,  "address",      SETTING_RW,     TYPE_BYTE,      0,      2,                      1,      1,      &drive->addressing,     set_lba_addressing);
 770         ide_add_setting(drive,  "bswap",        SETTING_READ,   TYPE_BYTE,      0,      1,                      1,      1,      &drive->bswap,          NULL);
 771         ide_add_setting(drive,  "multcount",    SETTING_RW,     TYPE_BYTE,      0,      id->max_multsect,       1,      1,      &drive->mult_count,     set_multcount);
 772         ide_add_setting(drive,  "nowerr",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->nowerr,         set_nowerr);
 773         ide_add_setting(drive,  "lun",          SETTING_RW,     TYPE_INT,       0,      7,                      1,      1,      &drive->lun,            NULL);
 774         ide_add_setting(drive,  "wcache",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->wcache,         write_cache);
 775         ide_add_setting(drive,  "acoustic",     SETTING_RW,     TYPE_BYTE,      0,      254,                    1,      1,      &drive->acoustic,       set_acoustic);
 776         ide_add_setting(drive,  "failures",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->failures,       NULL);
 777         ide_add_setting(drive,  "max_failures", SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->max_failures,   NULL);
 778 }
 779 #else
 780 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
 781 #endif
 782
 783 static void idedisk_setup (ide_drive_t *drive)
 784 {
 785         ide_hwif_t *hwif = drive->hwif;
 786         struct hd_driveid *id = drive->id;
 787         unsigned long long capacity;
 788
 789         idedisk_add_settings(drive);
 790
 791         if (drive->id_read == 0)
 792                 return;
 793
 794         if (drive->removable) {
 795                 /*
 796                  * Removable disks (eg. SYQUEST); ignore 'WD' drives
 797                  */
 798                 if (id->model[0] != 'W' || id->model[1] != 'D') {
 799                         drive->doorlocking = 1;
 800                 }
 801         }
 802
 803         (void)set_lba_addressing(drive, 1);
 804
 805         if (drive->addressing == 1) {
 806                 int max_s = 2048;
 807
 808                 if (max_s > hwif->rqsize)
 809                         max_s = hwif->rqsize;
 810
 811                 blk_queue_max_sectors(drive->queue, max_s);
 812         }
 813
 814         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
 815
 816         /* calculate drive capacity, and select LBA if possible */
 817         init_idedisk_capacity (drive);
 818
 819         /* limit drive capacity to 137GB if LBA48 cannot be used */
 820         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
 821                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
 822                        "%llu sectors (%llu MB)\n",
 823                        drive->name, (unsigned long long)drive->capacity64,
 824                        sectors_to_MB(drive->capacity64));
 825                 drive->capacity64 = 1ULL << 28;
 826         }
 827
 828         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
 829                 if (drive->capacity64 > 1ULL << 28) {
 830                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
 831                                          " be used for accessing sectors > %u\n",
 832                                          drive->name, 1 << 28);
 833                 } else
 834                         drive->addressing = 0;
 835         }
 836
 837         /*
 838          * if possible, give fdisk access to more of the drive,
 839          * by correcting bios_cyls:
 840          */
 841         capacity = idedisk_capacity (drive);
 842         if (!drive->forced_geom) {
 843
 844                 if (idedisk_supports_lba48(drive->id)) {
 845                         /* compatibility */
 846                         drive->bios_sect = 63;
 847                         drive->bios_head = 255;
 848                 }
 849
 850                 if (drive->bios_sect && drive->bios_head) {
 851                         unsigned int cap0 = capacity; /* truncate to 32 bits */
 852                         unsigned int cylsz, cyl;
 853
 854                         if (cap0 != capacity)
 855                                 drive->bios_cyl = 65535;
 856                         else {
 857                                 cylsz = drive->bios_sect * drive->bios_head;
 858                                 cyl = cap0 / cylsz;
 859                                 if (cyl > 65535)
 860                                         cyl = 65535;
 861                                 if (cyl > drive->bios_cyl)
 862                                         drive->bios_cyl = cyl;
 863                         }
 864                 }
 865         }
 866         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
 867                          drive->name, capacity, sectors_to_MB(capacity));
 868
 869         /* Only print cache size when it was specified */
 870         if (id->buf_size)
 871                 printk (" w/%dKiB Cache", id->buf_size/2);
 872
 873         printk(KERN_CONT ", CHS=%d/%d/%d\n",
 874                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
 875
 876         /* write cache enabled? */
 877         if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
 878                 drive->wcache = 1;
 879
 880         write_cache(drive, 1);
 881 }
 882
 883 static void ide_cacheflush_p(ide_drive_t *drive)
 884 {
 885         if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
 886                 return;
 887
 888         if (do_idedisk_flushcache(drive))
 889                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 890 }
 891
 892 static void ide_disk_remove(ide_drive_t *drive)
 893 {
 894         struct ide_disk_obj *idkp = drive->driver_data;
 895         struct gendisk *g = idkp->disk;
 896
 897         ide_proc_unregister_driver(drive, idkp->driver);
 898
 899         del_gendisk(g);
 900
 901         ide_cacheflush_p(drive);
 902
 903         ide_disk_put(idkp);
 904 }
 905
 906 static void ide_disk_release(struct kref *kref)
 907 {
 908         struct ide_disk_obj *idkp = to_ide_disk(kref);
 909         ide_drive_t *drive = idkp->drive;
 910         struct gendisk *g = idkp->disk;
 911
 912         drive->driver_data = NULL;
 913         g->private_data = NULL;
 914         put_disk(g);
 915         kfree(idkp);
 916 }
 917
 918 static int ide_disk_probe(ide_drive_t *drive);
 919
 920 /*
 921  * On HPA drives the capacity needs to be
 922  * reinitilized on resume otherwise the disk
 923  * can not be used and a hard reset is required
 924  */
 925 static void ide_disk_resume(ide_drive_t *drive)
 926 {
 927         if (idedisk_supports_hpa(drive->id))
 928                 init_idedisk_capacity(drive);
 929 }
 930
 931 static void ide_device_shutdown(ide_drive_t *drive)
 932 {
 933 #ifdef  CONFIG_ALPHA
 934         /* On Alpha, halt(8) doesn't actually turn the machine off,
 935            it puts you into the sort of firmware monitor. Typically,
 936            it's used to boot another kernel image, so it's not much
 937            different from reboot(8). Therefore, we don't need to
 938            spin down the disk in this case, especially since Alpha
 939            firmware doesn't handle disks in standby mode properly.
 940            On the other hand, it's reasonably safe to turn the power
 941            off when the shutdown process reaches the firmware prompt,
 942            as the firmware initialization takes rather long time -
 943            at least 10 seconds, which should be sufficient for
 944            the disk to expire its write cache. */
 945         if (system_state != SYSTEM_POWER_OFF) {
 946 #else
 947         if (system_state == SYSTEM_RESTART) {
 948 #endif
 949                 ide_cacheflush_p(drive);
 950                 return;
 951         }
 952
 953         printk("Shutdown: %s\n", drive->name);
 954         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
 955 }
 956
 957 static ide_driver_t idedisk_driver = {
 958         .gen_driver = {
 959                 .owner          = THIS_MODULE,
 960                 .name           = "ide-disk",
 961                 .bus            = &ide_bus_type,
 962         },
 963         .probe                  = ide_disk_probe,
 964         .remove                 = ide_disk_remove,
 965         .resume                 = ide_disk_resume,
 966         .shutdown               = ide_device_shutdown,
 967         .version                = IDEDISK_VERSION,
 968         .media                  = ide_disk,
 969         .supports_dsc_overlap   = 0,
 970         .do_request             = ide_do_rw_disk,
 971         .end_request            = ide_end_request,
 972         .error                  = __ide_error,
 973         .abort                  = __ide_abort,
 974 #ifdef CONFIG_IDE_PROC_FS
 975         .proc                   = idedisk_proc,
 976 #endif
 977 };
 978
 979 static int idedisk_open(struct inode *inode, struct file *filp)
 980 {
 981         struct gendisk *disk = inode->i_bdev->bd_disk;
 982         struct ide_disk_obj *idkp;
 983         ide_drive_t *drive;
 984
 985         if (!(idkp = ide_disk_get(disk)))
 986                 return -ENXIO;
 987
 988         drive = idkp->drive;
 989
 990         idkp->openers++;
 991
 992         if (drive->removable && idkp->openers == 1) {
 993                 ide_task_t args;
 994                 memset(&args, 0, sizeof(ide_task_t));
 995                 args.tf.command = WIN_DOORLOCK;
 996                 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 997                 check_disk_change(inode->i_bdev);
 998                 /*
 999                  * Ignore the return code from door_lock,
1000                  * since the open() has already succeeded,
1001                  * and the door_lock is irrelevant at this point.
1002                  */
1003                 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
1004                         drive->doorlocking = 0;
1005         }
1006         return 0;
1007 }
1008
1009 static int idedisk_release(struct inode *inode, struct file *filp)
1010 {
1011         struct gendisk *disk = inode->i_bdev->bd_disk;
1012         struct ide_disk_obj *idkp = ide_disk_g(disk);
1013         ide_drive_t *drive = idkp->drive;
1014
1015         if (idkp->openers == 1)
1016                 ide_cacheflush_p(drive);
1017
1018         if (drive->removable && idkp->openers == 1) {
1019                 ide_task_t args;
1020                 memset(&args, 0, sizeof(ide_task_t));
1021                 args.tf.command = WIN_DOORUNLOCK;
1022                 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
1023                 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
1024                         drive->doorlocking = 0;
1025         }
1026
1027         idkp->openers--;
1028
1029         ide_disk_put(idkp);
1030
1031         return 0;
1032 }
1033
1034 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1035 {
1036         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1037         ide_drive_t *drive = idkp->drive;
1038
1039         geo->heads = drive->bios_head;
1040         geo->sectors = drive->bios_sect;
1041         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1042         return 0;
1043 }
1044
1045 static int idedisk_ioctl(struct inode *inode, struct file *file,
1046                         unsigned int cmd, unsigned long arg)
1047 {
1048         unsigned long flags;
1049         struct block_device *bdev = inode->i_bdev;
1050         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1051         ide_drive_t *drive = idkp->drive;
1052         int err, (*setfunc)(ide_drive_t *, int);
1053         u8 *val;
1054
1055         switch (cmd) {
1056         case HDIO_GET_ADDRESS:   val = &drive->addressing;      goto read_val;
1057         case HDIO_GET_MULTCOUNT: val = &drive->mult_count;      goto read_val;
1058         case HDIO_GET_NOWERR:    val = &drive->nowerr;          goto read_val;
1059         case HDIO_GET_WCACHE:    val = &drive->wcache;          goto read_val;
1060         case HDIO_GET_ACOUSTIC:  val = &drive->acoustic;        goto read_val;
1061         case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
1062         case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
1063         case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
1064         case HDIO_SET_WCACHE:    setfunc = write_cache;         goto set_val;
1065         case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
1066         }
1067
1068         return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1069
1070 read_val:
1071         mutex_lock(&ide_setting_mtx);
1072         spin_lock_irqsave(&ide_lock, flags);
1073         err = *val;
1074         spin_unlock_irqrestore(&ide_lock, flags);
1075         mutex_unlock(&ide_setting_mtx);
1076         return err >= 0 ? put_user(err, (long __user *)arg) : err;
1077
1078 set_val:
1079         if (bdev != bdev->bd_contains)
1080                 err = -EINVAL;
1081         else {
1082                 if (!capable(CAP_SYS_ADMIN))
1083                         err = -EACCES;
1084                 else {
1085                         mutex_lock(&ide_setting_mtx);
1086                         err = setfunc(drive, arg);
1087                         mutex_unlock(&ide_setting_mtx);
1088                 }
1089         }
1090         return err;
1091 }
1092
1093 static int idedisk_media_changed(struct gendisk *disk)
1094 {
1095         struct ide_disk_obj *idkp = ide_disk_g(disk);
1096         ide_drive_t *drive = idkp->drive;
1097
1098         /* do not scan partitions twice if this is a removable device */
1099         if (drive->attach) {
1100                 drive->attach = 0;
1101                 return 0;
1102         }
1103         /* if removable, always assume it was changed */
1104         return drive->removable;
1105 }
1106
1107 static int idedisk_revalidate_disk(struct gendisk *disk)
1108 {
1109         struct ide_disk_obj *idkp = ide_disk_g(disk);
1110         set_capacity(disk, idedisk_capacity(idkp->drive));
1111         return 0;
1112 }
1113
1114 static struct block_device_operations idedisk_ops = {
1115         .owner          = THIS_MODULE,
1116         .open           = idedisk_open,
1117         .release        = idedisk_release,
1118         .ioctl          = idedisk_ioctl,
1119         .getgeo         = idedisk_getgeo,
1120         .media_changed  = idedisk_media_changed,
1121         .revalidate_disk= idedisk_revalidate_disk
1122 };
1123
1124 MODULE_DESCRIPTION("ATA DISK Driver");
1125
1126 static int ide_disk_probe(ide_drive_t *drive)
1127 {
1128         struct ide_disk_obj *idkp;
1129         struct gendisk *g;
1130
1131         /* strstr("foo", "") is non-NULL */
1132         if (!strstr("ide-disk", drive->driver_req))
1133                 goto failed;
1134         if (!drive->present)
1135                 goto failed;
1136         if (drive->media != ide_disk)
1137                 goto failed;
1138
1139         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1140         if (!idkp)
1141                 goto failed;
1142
1143         g = alloc_disk_node(1 << PARTN_BITS,
1144                         hwif_to_node(drive->hwif));
1145         if (!g)
1146                 goto out_free_idkp;
1147
1148         ide_init_disk(g, drive);
1149
1150         ide_proc_register_driver(drive, &idedisk_driver);
1151
1152         kref_init(&idkp->kref);
1153
1154         idkp->drive = drive;
1155         idkp->driver = &idedisk_driver;
1156         idkp->disk = g;
1157
1158         g->private_data = &idkp->driver;
1159
1160         drive->driver_data = idkp;
1161
1162         idedisk_setup(drive);
1163         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1164                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1165                         drive->name, drive->head);
1166                 drive->attach = 0;
1167         } else
1168                 drive->attach = 1;
1169
1170         g->minors = 1 << PARTN_BITS;
1171         g->driverfs_dev = &drive->gendev;
1172         g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1173         set_capacity(g, idedisk_capacity(drive));
1174         g->fops = &idedisk_ops;
1175         add_disk(g);
1176         return 0;
1177
1178 out_free_idkp:
1179         kfree(idkp);
1180 failed:
1181         return -ENODEV;
1182 }
1183
1184 static void __exit idedisk_exit (void)
1185 {
1186         driver_unregister(&idedisk_driver.gen_driver);
1187 }
1188
1189 static int __init idedisk_init(void)
1190 {
1191         return driver_register(&idedisk_driver.gen_driver);
1192 }
1193
1194 MODULE_ALIAS("ide:*m-disk*");
1195 module_init(idedisk_init);
1196 module_exit(idedisk_exit);
1197 MODULE_LICENSE("GPL");