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