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