Pileus Git - ~andy/linux/blob - drivers/ide/ide-disk.c

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