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