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