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