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

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