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