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
 252                 return pre_task_out_intr(drive, rq);
 253         }
 254 }
 255
 256 /*
 257  * 268435455  == 137439 MB or 28bit limit
 258  * 320173056  == 163929 MB or 48bit addressing
 259  * 1073741822 == 549756 MB or 48bit addressing fake drive
 260  */
 261
 262 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
 263 {
 264         ide_hwif_t *hwif = HWIF(drive);
 265
 266         BUG_ON(drive->blocked);
 267
 268         if (!blk_fs_request(rq)) {
 269                 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
 270                 ide_end_request(drive, 0, 0);
 271                 return ide_stopped;
 272         }
 273
 274         ledtrig_ide_activity();
 275
 276         pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
 277                  drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
 278                  (unsigned long long)block, rq->nr_sectors,
 279                  (unsigned long)rq->buffer);
 280
 281         if (hwif->rw_disk)
 282                 hwif->rw_disk(drive, rq);
 283
 284         return __ide_do_rw_disk(drive, rq, block);
 285 }
 286
 287 /*
 288  * Queries for true maximum capacity of the drive.
 289  * Returns maximum LBA address (> 0) of the drive, 0 if failed.
 290  */
 291 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
 292 {
 293         ide_task_t args;
 294         struct ide_taskfile *tf = &args.tf;
 295         u64 addr = 0;
 296
 297         /* Create IDE/ATA command request structure */
 298         memset(&args, 0, sizeof(ide_task_t));
 299         if (lba48)
 300                 tf->command = WIN_READ_NATIVE_MAX_EXT;
 301         else
 302                 tf->command = WIN_READ_NATIVE_MAX;
 303         tf->device  = ATA_LBA;
 304         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 305         if (lba48)
 306                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
 307         /* submit command request */
 308         ide_no_data_taskfile(drive, &args);
 309
 310         /* if OK, compute maximum address value */
 311         if ((tf->status & 0x01) == 0) {
 312                 u32 high, low;
 313
 314                 if (lba48)
 315                         high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
 316                                 tf->hob_lbal;
 317                 else
 318                         high = tf->device & 0xf;
 319                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 320                 addr = ((__u64)high << 24) | low;
 321                 addr++; /* since the return value is (maxlba - 1), we add 1 */
 322         }
 323         return addr;
 324 }
 325
 326 /*
 327  * Sets maximum virtual LBA address of the drive.
 328  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
 329  */
 330 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
 331 {
 332         ide_task_t args;
 333         struct ide_taskfile *tf = &args.tf;
 334         u64 addr_set = 0;
 335
 336         addr_req--;
 337         /* Create IDE/ATA command request structure */
 338         memset(&args, 0, sizeof(ide_task_t));
 339         tf->lbal     = (addr_req >>  0) & 0xff;
 340         tf->lbam     = (addr_req >>= 8) & 0xff;
 341         tf->lbah     = (addr_req >>= 8) & 0xff;
 342         if (lba48) {
 343                 tf->hob_lbal = (addr_req >>= 8) & 0xff;
 344                 tf->hob_lbam = (addr_req >>= 8) & 0xff;
 345                 tf->hob_lbah = (addr_req >>= 8) & 0xff;
 346                 tf->command  = WIN_SET_MAX_EXT;
 347         } else {
 348                 tf->device   = (addr_req >>= 8) & 0x0f;
 349                 tf->command  = WIN_SET_MAX;
 350         }
 351         tf->device |= ATA_LBA;
 352         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 353         if (lba48)
 354                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
 355         /* submit command request */
 356         ide_no_data_taskfile(drive, &args);
 357         /* if OK, compute maximum address value */
 358         if ((tf->status & 0x01) == 0) {
 359                 u32 high, low;
 360
 361                 if (lba48)
 362                         high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
 363                                 tf->hob_lbal;
 364                 else
 365                         high = tf->device & 0xf;
 366                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 367                 addr_set = ((__u64)high << 24) | low;
 368                 addr_set++;
 369         }
 370         return addr_set;
 371 }
 372
 373 static unsigned long long sectors_to_MB(unsigned long long n)
 374 {
 375         n <<= 9;                /* make it bytes */
 376         do_div(n, 1000000);     /* make it MB */
 377         return n;
 378 }
 379
 380 /*
 381  * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
 382  * so on non-buggy drives we need test only one.
 383  * However, we should also check whether these fields are valid.
 384  */
 385 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
 386 {
 387         return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
 388 }
 389
 390 /*
 391  * The same here.
 392  */
 393 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
 394 {
 395         return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
 396                && id->lba_capacity_2;
 397 }
 398
 399 /*
 400  * Some disks report total number of sectors instead of
 401  * maximum sector address.  We list them here.
 402  */
 403 static const struct drive_list_entry hpa_list[] = {
 404         { "ST340823A",  NULL },
 405         { "ST320413A",  NULL },
 406         { NULL,         NULL }
 407 };
 408
 409 static void idedisk_check_hpa(ide_drive_t *drive)
 410 {
 411         unsigned long long capacity, set_max;
 412         int lba48 = idedisk_supports_lba48(drive->id);
 413
 414         capacity = drive->capacity64;
 415
 416         set_max = idedisk_read_native_max_address(drive, lba48);
 417
 418         if (ide_in_drive_list(drive->id, hpa_list)) {
 419                 /*
 420                  * Since we are inclusive wrt to firmware revisions do this
 421                  * extra check and apply the workaround only when needed.
 422                  */
 423                 if (set_max == capacity + 1)
 424                         set_max--;
 425         }
 426
 427         if (set_max <= capacity)
 428                 return;
 429
 430         printk(KERN_INFO "%s: Host Protected Area detected.\n"
 431                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
 432                          "\tnative  capacity is %llu sectors (%llu MB)\n",
 433                          drive->name,
 434                          capacity, sectors_to_MB(capacity),
 435                          set_max, sectors_to_MB(set_max));
 436
 437         set_max = idedisk_set_max_address(drive, set_max, lba48);
 438
 439         if (set_max) {
 440                 drive->capacity64 = set_max;
 441                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
 442                                  drive->name);
 443         }
 444 }
 445
 446 /*
 447  * Compute drive->capacity, the full capacity of the drive
 448  * Called with drive->id != NULL.
 449  *
 450  * To compute capacity, this uses either of
 451  *
 452  *    1. CHS value set by user       (whatever user sets will be trusted)
 453  *    2. LBA value from target drive (require new ATA feature)
 454  *    3. LBA value from system BIOS  (new one is OK, old one may break)
 455  *    4. CHS value from system BIOS  (traditional style)
 456  *
 457  * in above order (i.e., if value of higher priority is available,
 458  * reset will be ignored).
 459  */
 460 static void init_idedisk_capacity (ide_drive_t  *drive)
 461 {
 462         struct hd_driveid *id = drive->id;
 463         /*
 464          * If this drive supports the Host Protected Area feature set,
 465          * then we may need to change our opinion about the drive's capacity.
 466          */
 467         int hpa = idedisk_supports_hpa(id);
 468
 469         if (idedisk_supports_lba48(id)) {
 470                 /* drive speaks 48-bit LBA */
 471                 drive->select.b.lba = 1;
 472                 drive->capacity64 = id->lba_capacity_2;
 473                 if (hpa)
 474                         idedisk_check_hpa(drive);
 475         } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
 476                 /* drive speaks 28-bit LBA */
 477                 drive->select.b.lba = 1;
 478                 drive->capacity64 = id->lba_capacity;
 479                 if (hpa)
 480                         idedisk_check_hpa(drive);
 481         } else {
 482                 /* drive speaks boring old 28-bit CHS */
 483                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
 484         }
 485 }
 486
 487 static sector_t idedisk_capacity (ide_drive_t *drive)
 488 {
 489         return drive->capacity64 - drive->sect0;
 490 }
 491
 492 #ifdef CONFIG_IDE_PROC_FS
 493 static int smart_enable(ide_drive_t *drive)
 494 {
 495         ide_task_t args;
 496         struct ide_taskfile *tf = &args.tf;
 497
 498         memset(&args, 0, sizeof(ide_task_t));
 499         tf->feature = SMART_ENABLE;
 500         tf->lbam    = SMART_LCYL_PASS;
 501         tf->lbah    = SMART_HCYL_PASS;
 502         tf->command = WIN_SMART;
 503         args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 504         return ide_no_data_taskfile(drive, &args);
 505 }
 506
 507 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 508 {
 509         ide_task_t args;
 510         struct ide_taskfile *tf = &args.tf;
 511
 512         memset(&args, 0, sizeof(ide_task_t));
 513         tf->feature = sub_cmd;
 514         tf->nsect   = 0x01;
 515         tf->lbam    = SMART_LCYL_PASS;
 516         tf->lbah    = SMART_HCYL_PASS;
 517         tf->command = WIN_SMART;
 518         args.tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 519         args.data_phase = TASKFILE_IN;
 520         args.handler    = task_in_intr;
 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         task.handler    = task_no_data_intr;
 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");