drivers/ide/ide-disk.c

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