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