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

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