SAFE public projects git trees. - safe/jmp/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         u8 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                         u8 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] = (u8) block;
 175                         tasklets[5] = (u8)(block >>  8);
 176                         tasklets[6] = (u8)(block >> 16);
 177                         tasklets[7] = (u8)(block >> 24);
 178                         if (sizeof(block) == 4) {
 179                                 tasklets[8] = 0;
 180                                 tasklets[9] = 0;
 181                         } else {
 182                                 tasklets[8] = (u8)((u64)block >> 32);
 183                                 tasklets[9] = (u8)((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         struct ide_taskfile *tf = &args.tf;
 314         unsigned long addr = 0;
 315
 316         /* Create IDE/ATA command request structure */
 317         memset(&args, 0, sizeof(ide_task_t));
 318         tf->device  = ATA_LBA;
 319         tf->command = WIN_READ_NATIVE_MAX;
 320         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 321         args.handler                            = &task_no_data_intr;
 322         /* submit command request */
 323         ide_raw_taskfile(drive, &args, NULL);
 324
 325         /* if OK, compute maximum address value */
 326         if ((tf->status & 0x01) == 0) {
 327                 addr = ((tf->device & 0xf) << 24) |
 328                        (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 329                 addr++; /* since the return value is (maxlba - 1), we add 1 */
 330         }
 331         return addr;
 332 }
 333
 334 static unsigned long long idedisk_read_native_max_address_ext(ide_drive_t *drive)
 335 {
 336         ide_task_t args;
 337         struct ide_taskfile *tf = &args.tf;
 338         unsigned long long addr = 0;
 339
 340         /* Create IDE/ATA command request structure */
 341         memset(&args, 0, sizeof(ide_task_t));
 342         tf->device  = ATA_LBA;
 343         tf->command = WIN_READ_NATIVE_MAX_EXT;
 344         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 345         args.handler                            = &task_no_data_intr;
 346         /* submit command request */
 347         ide_raw_taskfile(drive, &args, NULL);
 348
 349         /* if OK, compute maximum address value */
 350         if ((tf->status & 0x01) == 0) {
 351                 u32 high, low;
 352
 353                 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) | tf->hob_lbal;
 354                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 355                 addr = ((__u64)high << 24) | low;
 356                 addr++; /* since the return value is (maxlba - 1), we add 1 */
 357         }
 358         return addr;
 359 }
 360
 361 /*
 362  * Sets maximum virtual LBA address of the drive.
 363  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
 364  */
 365 static unsigned long idedisk_set_max_address(ide_drive_t *drive, unsigned long addr_req)
 366 {
 367         ide_task_t args;
 368         struct ide_taskfile *tf = &args.tf;
 369         unsigned long addr_set = 0;
 370
 371         addr_req--;
 372         /* Create IDE/ATA command request structure */
 373         memset(&args, 0, sizeof(ide_task_t));
 374         tf->lbal    =  (addr_req >>  0) & 0xff;
 375         tf->lbam    =  (addr_req >>  8) & 0xff;
 376         tf->lbah    =  (addr_req >> 16) & 0xff;
 377         tf->device  = ((addr_req >> 24) & 0x0f) | ATA_LBA;
 378         tf->command = WIN_SET_MAX;
 379         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 380         args.handler                            = &task_no_data_intr;
 381         /* submit command request */
 382         ide_raw_taskfile(drive, &args, NULL);
 383         /* if OK, read new maximum address value */
 384         if ((tf->status & 0x01) == 0) {
 385                 addr_set = ((tf->device & 0xf) << 24) |
 386                            (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 387                 addr_set++;
 388         }
 389         return addr_set;
 390 }
 391
 392 static unsigned long long idedisk_set_max_address_ext(ide_drive_t *drive, unsigned long long addr_req)
 393 {
 394         ide_task_t args;
 395         struct ide_taskfile *tf = &args.tf;
 396         unsigned long long addr_set = 0;
 397
 398         addr_req--;
 399         /* Create IDE/ATA command request structure */
 400         memset(&args, 0, sizeof(ide_task_t));
 401         tf->lbal     = (addr_req >>  0) & 0xff;
 402         tf->lbam     = (addr_req >>= 8) & 0xff;
 403         tf->lbah     = (addr_req >>= 8) & 0xff;
 404         tf->device   = ATA_LBA;
 405         tf->command  = WIN_SET_MAX_EXT;
 406         tf->hob_lbal = (addr_req >>= 8) & 0xff;
 407         tf->hob_lbam = (addr_req >>= 8) & 0xff;
 408         tf->hob_lbah = (addr_req >>= 8) & 0xff;
 409         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 410         args.handler                            = &task_no_data_intr;
 411         /* submit command request */
 412         ide_raw_taskfile(drive, &args, NULL);
 413         /* if OK, compute maximum address value */
 414         if ((tf->status & 0x01) == 0) {
 415                 u32 high, low;
 416
 417                 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) | tf->hob_lbal;
 418                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 419                 addr_set = ((__u64)high << 24) | low;
 420                 addr_set++;
 421         }
 422         return addr_set;
 423 }
 424
 425 static unsigned long long sectors_to_MB(unsigned long long n)
 426 {
 427         n <<= 9;                /* make it bytes */
 428         do_div(n, 1000000);     /* make it MB */
 429         return n;
 430 }
 431
 432 /*
 433  * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
 434  * so on non-buggy drives we need test only one.
 435  * However, we should also check whether these fields are valid.
 436  */
 437 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
 438 {
 439         return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
 440 }
 441
 442 /*
 443  * The same here.
 444  */
 445 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
 446 {
 447         return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
 448                && id->lba_capacity_2;
 449 }
 450
 451 /*
 452  * Some disks report total number of sectors instead of
 453  * maximum sector address.  We list them here.
 454  */
 455 static const struct drive_list_entry hpa_list[] = {
 456         { "ST340823A",  NULL },
 457         { "ST320413A",  NULL },
 458         { NULL,         NULL }
 459 };
 460
 461 static void idedisk_check_hpa(ide_drive_t *drive)
 462 {
 463         unsigned long long capacity, set_max;
 464         int lba48 = idedisk_supports_lba48(drive->id);
 465
 466         capacity = drive->capacity64;
 467         if (lba48)
 468                 set_max = idedisk_read_native_max_address_ext(drive);
 469         else
 470                 set_max = idedisk_read_native_max_address(drive);
 471
 472         if (ide_in_drive_list(drive->id, hpa_list)) {
 473                 /*
 474                  * Since we are inclusive wrt to firmware revisions do this
 475                  * extra check and apply the workaround only when needed.
 476                  */
 477                 if (set_max == capacity + 1)
 478                         set_max--;
 479         }
 480
 481         if (set_max <= capacity)
 482                 return;
 483
 484         printk(KERN_INFO "%s: Host Protected Area detected.\n"
 485                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
 486                          "\tnative  capacity is %llu sectors (%llu MB)\n",
 487                          drive->name,
 488                          capacity, sectors_to_MB(capacity),
 489                          set_max, sectors_to_MB(set_max));
 490
 491         if (lba48)
 492                 set_max = idedisk_set_max_address_ext(drive, set_max);
 493         else
 494                 set_max = idedisk_set_max_address(drive, set_max);
 495         if (set_max) {
 496                 drive->capacity64 = set_max;
 497                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
 498                                  drive->name);
 499         }
 500 }
 501
 502 /*
 503  * Compute drive->capacity, the full capacity of the drive
 504  * Called with drive->id != NULL.
 505  *
 506  * To compute capacity, this uses either of
 507  *
 508  *    1. CHS value set by user       (whatever user sets will be trusted)
 509  *    2. LBA value from target drive (require new ATA feature)
 510  *    3. LBA value from system BIOS  (new one is OK, old one may break)
 511  *    4. CHS value from system BIOS  (traditional style)
 512  *
 513  * in above order (i.e., if value of higher priority is available,
 514  * reset will be ignored).
 515  */
 516 static void init_idedisk_capacity (ide_drive_t  *drive)
 517 {
 518         struct hd_driveid *id = drive->id;
 519         /*
 520          * If this drive supports the Host Protected Area feature set,
 521          * then we may need to change our opinion about the drive's capacity.
 522          */
 523         int hpa = idedisk_supports_hpa(id);
 524
 525         if (idedisk_supports_lba48(id)) {
 526                 /* drive speaks 48-bit LBA */
 527                 drive->select.b.lba = 1;
 528                 drive->capacity64 = id->lba_capacity_2;
 529                 if (hpa)
 530                         idedisk_check_hpa(drive);
 531         } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
 532                 /* drive speaks 28-bit LBA */
 533                 drive->select.b.lba = 1;
 534                 drive->capacity64 = id->lba_capacity;
 535                 if (hpa)
 536                         idedisk_check_hpa(drive);
 537         } else {
 538                 /* drive speaks boring old 28-bit CHS */
 539                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
 540         }
 541 }
 542
 543 static sector_t idedisk_capacity (ide_drive_t *drive)
 544 {
 545         return drive->capacity64 - drive->sect0;
 546 }
 547
 548 #ifdef CONFIG_IDE_PROC_FS
 549 static int smart_enable(ide_drive_t *drive)
 550 {
 551         ide_task_t args;
 552         struct ide_taskfile *tf = &args.tf;
 553
 554         memset(&args, 0, sizeof(ide_task_t));
 555         tf->feature = SMART_ENABLE;
 556         tf->lbam    = SMART_LCYL_PASS;
 557         tf->lbah    = SMART_HCYL_PASS;
 558         tf->command = WIN_SMART;
 559         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 560         args.handler                            = &task_no_data_intr;
 561         return ide_raw_taskfile(drive, &args, NULL);
 562 }
 563
 564 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 565 {
 566         ide_task_t args;
 567         struct ide_taskfile *tf = &args.tf;
 568
 569         memset(&args, 0, sizeof(ide_task_t));
 570         tf->feature = sub_cmd;
 571         tf->nsect   = 0x01;
 572         tf->lbam    = SMART_LCYL_PASS;
 573         tf->lbah    = SMART_HCYL_PASS;
 574         tf->command = WIN_SMART;
 575         args.command_type                       = IDE_DRIVE_TASK_IN;
 576         args.data_phase                         = TASKFILE_IN;
 577         args.handler                            = &task_in_intr;
 578         (void) smart_enable(drive);
 579         return ide_raw_taskfile(drive, &args, buf);
 580 }
 581
 582 static int proc_idedisk_read_cache
 583         (char *page, char **start, off_t off, int count, int *eof, void *data)
 584 {
 585         ide_drive_t     *drive = (ide_drive_t *) data;
 586         char            *out = page;
 587         int             len;
 588
 589         if (drive->id_read)
 590                 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
 591         else
 592                 len = sprintf(out,"(none)\n");
 593         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 594 }
 595
 596 static int proc_idedisk_read_capacity
 597         (char *page, char **start, off_t off, int count, int *eof, void *data)
 598 {
 599         ide_drive_t*drive = (ide_drive_t *)data;
 600         int len;
 601
 602         len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
 603         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 604 }
 605
 606 static int proc_idedisk_read_smart_thresholds
 607         (char *page, char **start, off_t off, int count, int *eof, void *data)
 608 {
 609         ide_drive_t     *drive = (ide_drive_t *)data;
 610         int             len = 0, i = 0;
 611
 612         if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
 613                 unsigned short *val = (unsigned short *) page;
 614                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 615                 page = out;
 616                 do {
 617                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 618                         val += 1;
 619                 } while (i < (SECTOR_WORDS * 2));
 620                 len = out - page;
 621         }
 622         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 623 }
 624
 625 static int proc_idedisk_read_smart_values
 626         (char *page, char **start, off_t off, int count, int *eof, void *data)
 627 {
 628         ide_drive_t     *drive = (ide_drive_t *)data;
 629         int             len = 0, i = 0;
 630
 631         if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
 632                 unsigned short *val = (unsigned short *) page;
 633                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 634                 page = out;
 635                 do {
 636                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 637                         val += 1;
 638                 } while (i < (SECTOR_WORDS * 2));
 639                 len = out - page;
 640         }
 641         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 642 }
 643
 644 static ide_proc_entry_t idedisk_proc[] = {
 645         { "cache",              S_IFREG|S_IRUGO,        proc_idedisk_read_cache,                NULL },
 646         { "capacity",           S_IFREG|S_IRUGO,        proc_idedisk_read_capacity,             NULL },
 647         { "geometry",           S_IFREG|S_IRUGO,        proc_ide_read_geometry,                 NULL },
 648         { "smart_values",       S_IFREG|S_IRUSR,        proc_idedisk_read_smart_values,         NULL },
 649         { "smart_thresholds",   S_IFREG|S_IRUSR,        proc_idedisk_read_smart_thresholds,     NULL },
 650         { NULL, 0, NULL, NULL }
 651 };
 652 #endif  /* CONFIG_IDE_PROC_FS */
 653
 654 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 655 {
 656         ide_drive_t *drive = q->queuedata;
 657
 658         memset(rq->cmd, 0, sizeof(rq->cmd));
 659
 660         if (ide_id_has_flush_cache_ext(drive->id) &&
 661             (drive->capacity64 >= (1UL << 28)))
 662                 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
 663         else
 664                 rq->cmd[0] = WIN_FLUSH_CACHE;
 665
 666
 667         rq->cmd_type = REQ_TYPE_ATA_TASK;
 668         rq->cmd_flags |= REQ_SOFTBARRIER;
 669         rq->buffer = rq->cmd;
 670 }
 671
 672 /*
 673  * This is tightly woven into the driver->do_special can not touch.
 674  * DON'T do it again until a total personality rewrite is committed.
 675  */
 676 static int set_multcount(ide_drive_t *drive, int arg)
 677 {
 678         struct request rq;
 679
 680         if (arg < 0 || arg > drive->id->max_multsect)
 681                 return -EINVAL;
 682
 683         if (drive->special.b.set_multmode)
 684                 return -EBUSY;
 685         ide_init_drive_cmd (&rq);
 686         rq.cmd_type = REQ_TYPE_ATA_CMD;
 687         drive->mult_req = arg;
 688         drive->special.b.set_multmode = 1;
 689         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
 690         return (drive->mult_count == arg) ? 0 : -EIO;
 691 }
 692
 693 static int set_nowerr(ide_drive_t *drive, int arg)
 694 {
 695         if (arg < 0 || arg > 1)
 696                 return -EINVAL;
 697
 698         if (ide_spin_wait_hwgroup(drive))
 699                 return -EBUSY;
 700         drive->nowerr = arg;
 701         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
 702         spin_unlock_irq(&ide_lock);
 703         return 0;
 704 }
 705
 706 static void update_ordered(ide_drive_t *drive)
 707 {
 708         struct hd_driveid *id = drive->id;
 709         unsigned ordered = QUEUE_ORDERED_NONE;
 710         prepare_flush_fn *prep_fn = NULL;
 711
 712         if (drive->wcache) {
 713                 unsigned long long capacity;
 714                 int barrier;
 715                 /*
 716                  * We must avoid issuing commands a drive does not
 717                  * understand or we may crash it. We check flush cache
 718                  * is supported. We also check we have the LBA48 flush
 719                  * cache if the drive capacity is too large. By this
 720                  * time we have trimmed the drive capacity if LBA48 is
 721                  * not available so we don't need to recheck that.
 722                  */
 723                 capacity = idedisk_capacity(drive);
 724                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
 725                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
 726                          ide_id_has_flush_cache_ext(id));
 727
 728                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
 729                        drive->name, barrier ? "" : "not ");
 730
 731                 if (barrier) {
 732                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
 733                         prep_fn = idedisk_prepare_flush;
 734                 }
 735         } else
 736                 ordered = QUEUE_ORDERED_DRAIN;
 737
 738         blk_queue_ordered(drive->queue, ordered, prep_fn);
 739 }
 740
 741 static int write_cache(ide_drive_t *drive, int arg)
 742 {
 743         ide_task_t args;
 744         int err = 1;
 745
 746         if (arg < 0 || arg > 1)
 747                 return -EINVAL;
 748
 749         if (ide_id_has_flush_cache(drive->id)) {
 750                 memset(&args, 0, sizeof(ide_task_t));
 751                 args.tf.feature = arg ?
 752                         SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
 753                 args.tf.command = WIN_SETFEATURES;
 754                 args.command_type               = IDE_DRIVE_TASK_NO_DATA;
 755                 args.handler                    = &task_no_data_intr;
 756                 err = ide_raw_taskfile(drive, &args, NULL);
 757                 if (err == 0)
 758                         drive->wcache = arg;
 759         }
 760
 761         update_ordered(drive);
 762
 763         return err;
 764 }
 765
 766 static int do_idedisk_flushcache (ide_drive_t *drive)
 767 {
 768         ide_task_t args;
 769
 770         memset(&args, 0, sizeof(ide_task_t));
 771         if (ide_id_has_flush_cache_ext(drive->id))
 772                 args.tf.command = WIN_FLUSH_CACHE_EXT;
 773         else
 774                 args.tf.command = WIN_FLUSH_CACHE;
 775         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 776         args.handler                            = &task_no_data_intr;
 777         return ide_raw_taskfile(drive, &args, NULL);
 778 }
 779
 780 static int set_acoustic (ide_drive_t *drive, int arg)
 781 {
 782         ide_task_t args;
 783
 784         if (arg < 0 || arg > 254)
 785                 return -EINVAL;
 786
 787         memset(&args, 0, sizeof(ide_task_t));
 788         args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
 789         args.tf.nsect   = arg;
 790         args.tf.command = WIN_SETFEATURES;
 791         args.command_type = IDE_DRIVE_TASK_NO_DATA;
 792         args.handler      = &task_no_data_intr;
 793         ide_raw_taskfile(drive, &args, NULL);
 794         drive->acoustic = arg;
 795         return 0;
 796 }
 797
 798 /*
 799  * drive->addressing:
 800  *      0: 28-bit
 801  *      1: 48-bit
 802  *      2: 48-bit capable doing 28-bit
 803  */
 804 static int set_lba_addressing(ide_drive_t *drive, int arg)
 805 {
 806         if (arg < 0 || arg > 2)
 807                 return -EINVAL;
 808
 809         drive->addressing =  0;
 810
 811         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
 812                 return 0;
 813
 814         if (!idedisk_supports_lba48(drive->id))
 815                 return -EIO;
 816         drive->addressing = arg;
 817         return 0;
 818 }
 819
 820 #ifdef CONFIG_IDE_PROC_FS
 821 static void idedisk_add_settings(ide_drive_t *drive)
 822 {
 823         struct hd_driveid *id = drive->id;
 824
 825         ide_add_setting(drive,  "bios_cyl",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->bios_cyl,       NULL);
 826         ide_add_setting(drive,  "bios_head",    SETTING_RW,     TYPE_BYTE,      0,      255,                    1,      1,      &drive->bios_head,      NULL);
 827         ide_add_setting(drive,  "bios_sect",    SETTING_RW,     TYPE_BYTE,      0,      63,                     1,      1,      &drive->bios_sect,      NULL);
 828         ide_add_setting(drive,  "address",      SETTING_RW,     TYPE_BYTE,      0,      2,                      1,      1,      &drive->addressing,     set_lba_addressing);
 829         ide_add_setting(drive,  "bswap",        SETTING_READ,   TYPE_BYTE,      0,      1,                      1,      1,      &drive->bswap,          NULL);
 830         ide_add_setting(drive,  "multcount",    SETTING_RW,     TYPE_BYTE,      0,      id->max_multsect,       1,      1,      &drive->mult_count,     set_multcount);
 831         ide_add_setting(drive,  "nowerr",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->nowerr,         set_nowerr);
 832         ide_add_setting(drive,  "lun",          SETTING_RW,     TYPE_INT,       0,      7,                      1,      1,      &drive->lun,            NULL);
 833         ide_add_setting(drive,  "wcache",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->wcache,         write_cache);
 834         ide_add_setting(drive,  "acoustic",     SETTING_RW,     TYPE_BYTE,      0,      254,                    1,      1,      &drive->acoustic,       set_acoustic);
 835         ide_add_setting(drive,  "failures",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->failures,       NULL);
 836         ide_add_setting(drive,  "max_failures", SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->max_failures,   NULL);
 837 }
 838 #else
 839 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
 840 #endif
 841
 842 static void idedisk_setup (ide_drive_t *drive)
 843 {
 844         ide_hwif_t *hwif = drive->hwif;
 845         struct hd_driveid *id = drive->id;
 846         unsigned long long capacity;
 847
 848         idedisk_add_settings(drive);
 849
 850         if (drive->id_read == 0)
 851                 return;
 852
 853         if (drive->removable) {
 854                 /*
 855                  * Removable disks (eg. SYQUEST); ignore 'WD' drives
 856                  */
 857                 if (id->model[0] != 'W' || id->model[1] != 'D') {
 858                         drive->doorlocking = 1;
 859                 }
 860         }
 861
 862         (void)set_lba_addressing(drive, 1);
 863
 864         if (drive->addressing == 1) {
 865                 int max_s = 2048;
 866
 867                 if (max_s > hwif->rqsize)
 868                         max_s = hwif->rqsize;
 869
 870                 blk_queue_max_sectors(drive->queue, max_s);
 871         }
 872
 873         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
 874
 875         /* calculate drive capacity, and select LBA if possible */
 876         init_idedisk_capacity (drive);
 877
 878         /* limit drive capacity to 137GB if LBA48 cannot be used */
 879         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
 880                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
 881                        "%llu sectors (%llu MB)\n",
 882                        drive->name, (unsigned long long)drive->capacity64,
 883                        sectors_to_MB(drive->capacity64));
 884                 drive->capacity64 = 1ULL << 28;
 885         }
 886
 887         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
 888                 if (drive->capacity64 > 1ULL << 28) {
 889                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
 890                                          " be used for accessing sectors > %u\n",
 891                                          drive->name, 1 << 28);
 892                 } else
 893                         drive->addressing = 0;
 894         }
 895
 896         /*
 897          * if possible, give fdisk access to more of the drive,
 898          * by correcting bios_cyls:
 899          */
 900         capacity = idedisk_capacity (drive);
 901         if (!drive->forced_geom) {
 902
 903                 if (idedisk_supports_lba48(drive->id)) {
 904                         /* compatibility */
 905                         drive->bios_sect = 63;
 906                         drive->bios_head = 255;
 907                 }
 908
 909                 if (drive->bios_sect && drive->bios_head) {
 910                         unsigned int cap0 = capacity; /* truncate to 32 bits */
 911                         unsigned int cylsz, cyl;
 912
 913                         if (cap0 != capacity)
 914                                 drive->bios_cyl = 65535;
 915                         else {
 916                                 cylsz = drive->bios_sect * drive->bios_head;
 917                                 cyl = cap0 / cylsz;
 918                                 if (cyl > 65535)
 919                                         cyl = 65535;
 920                                 if (cyl > drive->bios_cyl)
 921                                         drive->bios_cyl = cyl;
 922                         }
 923                 }
 924         }
 925         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
 926                          drive->name, capacity, sectors_to_MB(capacity));
 927
 928         /* Only print cache size when it was specified */
 929         if (id->buf_size)
 930                 printk (" w/%dKiB Cache", id->buf_size/2);
 931
 932         printk(KERN_CONT ", CHS=%d/%d/%d\n",
 933                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
 934
 935         /* write cache enabled? */
 936         if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
 937                 drive->wcache = 1;
 938
 939         write_cache(drive, 1);
 940 }
 941
 942 static void ide_cacheflush_p(ide_drive_t *drive)
 943 {
 944         if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
 945                 return;
 946
 947         if (do_idedisk_flushcache(drive))
 948                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 949 }
 950
 951 static void ide_disk_remove(ide_drive_t *drive)
 952 {
 953         struct ide_disk_obj *idkp = drive->driver_data;
 954         struct gendisk *g = idkp->disk;
 955
 956         ide_proc_unregister_driver(drive, idkp->driver);
 957
 958         del_gendisk(g);
 959
 960         ide_cacheflush_p(drive);
 961
 962         ide_disk_put(idkp);
 963 }
 964
 965 static void ide_disk_release(struct kref *kref)
 966 {
 967         struct ide_disk_obj *idkp = to_ide_disk(kref);
 968         ide_drive_t *drive = idkp->drive;
 969         struct gendisk *g = idkp->disk;
 970
 971         drive->driver_data = NULL;
 972         g->private_data = NULL;
 973         put_disk(g);
 974         kfree(idkp);
 975 }
 976
 977 static int ide_disk_probe(ide_drive_t *drive);
 978
 979 /*
 980  * On HPA drives the capacity needs to be
 981  * reinitilized on resume otherwise the disk
 982  * can not be used and a hard reset is required
 983  */
 984 static void ide_disk_resume(ide_drive_t *drive)
 985 {
 986         if (idedisk_supports_hpa(drive->id))
 987                 init_idedisk_capacity(drive);
 988 }
 989
 990 static void ide_device_shutdown(ide_drive_t *drive)
 991 {
 992 #ifdef  CONFIG_ALPHA
 993         /* On Alpha, halt(8) doesn't actually turn the machine off,
 994            it puts you into the sort of firmware monitor. Typically,
 995            it's used to boot another kernel image, so it's not much
 996            different from reboot(8). Therefore, we don't need to
 997            spin down the disk in this case, especially since Alpha
 998            firmware doesn't handle disks in standby mode properly.
 999            On the other hand, it's reasonably safe to turn the power
1000            off when the shutdown process reaches the firmware prompt,
1001            as the firmware initialization takes rather long time -
1002            at least 10 seconds, which should be sufficient for
1003            the disk to expire its write cache. */
1004         if (system_state != SYSTEM_POWER_OFF) {
1005 #else
1006         if (system_state == SYSTEM_RESTART) {
1007 #endif
1008                 ide_cacheflush_p(drive);
1009                 return;
1010         }
1011
1012         printk("Shutdown: %s\n", drive->name);
1013         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
1014 }
1015
1016 static ide_driver_t idedisk_driver = {
1017         .gen_driver = {
1018                 .owner          = THIS_MODULE,
1019                 .name           = "ide-disk",
1020                 .bus            = &ide_bus_type,
1021         },
1022         .probe                  = ide_disk_probe,
1023         .remove                 = ide_disk_remove,
1024         .resume                 = ide_disk_resume,
1025         .shutdown               = ide_device_shutdown,
1026         .version                = IDEDISK_VERSION,
1027         .media                  = ide_disk,
1028         .supports_dsc_overlap   = 0,
1029         .do_request             = ide_do_rw_disk,
1030         .end_request            = ide_end_request,
1031         .error                  = __ide_error,
1032         .abort                  = __ide_abort,
1033 #ifdef CONFIG_IDE_PROC_FS
1034         .proc                   = idedisk_proc,
1035 #endif
1036 };
1037
1038 static int idedisk_open(struct inode *inode, struct file *filp)
1039 {
1040         struct gendisk *disk = inode->i_bdev->bd_disk;
1041         struct ide_disk_obj *idkp;
1042         ide_drive_t *drive;
1043
1044         if (!(idkp = ide_disk_get(disk)))
1045                 return -ENXIO;
1046
1047         drive = idkp->drive;
1048
1049         idkp->openers++;
1050
1051         if (drive->removable && idkp->openers == 1) {
1052                 ide_task_t args;
1053                 memset(&args, 0, sizeof(ide_task_t));
1054                 args.tf.command = WIN_DOORLOCK;
1055                 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1056                 args.handler      = &task_no_data_intr;
1057                 check_disk_change(inode->i_bdev);
1058                 /*
1059                  * Ignore the return code from door_lock,
1060                  * since the open() has already succeeded,
1061                  * and the door_lock is irrelevant at this point.
1062                  */
1063                 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1064                         drive->doorlocking = 0;
1065         }
1066         return 0;
1067 }
1068
1069 static int idedisk_release(struct inode *inode, struct file *filp)
1070 {
1071         struct gendisk *disk = inode->i_bdev->bd_disk;
1072         struct ide_disk_obj *idkp = ide_disk_g(disk);
1073         ide_drive_t *drive = idkp->drive;
1074
1075         if (idkp->openers == 1)
1076                 ide_cacheflush_p(drive);
1077
1078         if (drive->removable && idkp->openers == 1) {
1079                 ide_task_t args;
1080                 memset(&args, 0, sizeof(ide_task_t));
1081                 args.tf.command = WIN_DOORUNLOCK;
1082                 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1083                 args.handler      = &task_no_data_intr;
1084                 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1085                         drive->doorlocking = 0;
1086         }
1087
1088         idkp->openers--;
1089
1090         ide_disk_put(idkp);
1091
1092         return 0;
1093 }
1094
1095 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1096 {
1097         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1098         ide_drive_t *drive = idkp->drive;
1099
1100         geo->heads = drive->bios_head;
1101         geo->sectors = drive->bios_sect;
1102         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1103         return 0;
1104 }
1105
1106 static int idedisk_ioctl(struct inode *inode, struct file *file,
1107                         unsigned int cmd, unsigned long arg)
1108 {
1109         unsigned long flags;
1110         struct block_device *bdev = inode->i_bdev;
1111         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1112         ide_drive_t *drive = idkp->drive;
1113         int err, (*setfunc)(ide_drive_t *, int);
1114         u8 *val;
1115
1116         switch (cmd) {
1117         case HDIO_GET_ADDRESS:   val = &drive->addressing;      goto read_val;
1118         case HDIO_GET_MULTCOUNT: val = &drive->mult_count;      goto read_val;
1119         case HDIO_GET_NOWERR:    val = &drive->nowerr;          goto read_val;
1120         case HDIO_GET_WCACHE:    val = &drive->wcache;          goto read_val;
1121         case HDIO_GET_ACOUSTIC:  val = &drive->acoustic;        goto read_val;
1122         case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
1123         case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
1124         case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
1125         case HDIO_SET_WCACHE:    setfunc = write_cache;         goto set_val;
1126         case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
1127         }
1128
1129         return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1130
1131 read_val:
1132         mutex_lock(&ide_setting_mtx);
1133         spin_lock_irqsave(&ide_lock, flags);
1134         err = *val;
1135         spin_unlock_irqrestore(&ide_lock, flags);
1136         mutex_unlock(&ide_setting_mtx);
1137         return err >= 0 ? put_user(err, (long __user *)arg) : err;
1138
1139 set_val:
1140         if (bdev != bdev->bd_contains)
1141                 err = -EINVAL;
1142         else {
1143                 if (!capable(CAP_SYS_ADMIN))
1144                         err = -EACCES;
1145                 else {
1146                         mutex_lock(&ide_setting_mtx);
1147                         err = setfunc(drive, arg);
1148                         mutex_unlock(&ide_setting_mtx);
1149                 }
1150         }
1151         return err;
1152 }
1153
1154 static int idedisk_media_changed(struct gendisk *disk)
1155 {
1156         struct ide_disk_obj *idkp = ide_disk_g(disk);
1157         ide_drive_t *drive = idkp->drive;
1158
1159         /* do not scan partitions twice if this is a removable device */
1160         if (drive->attach) {
1161                 drive->attach = 0;
1162                 return 0;
1163         }
1164         /* if removable, always assume it was changed */
1165         return drive->removable;
1166 }
1167
1168 static int idedisk_revalidate_disk(struct gendisk *disk)
1169 {
1170         struct ide_disk_obj *idkp = ide_disk_g(disk);
1171         set_capacity(disk, idedisk_capacity(idkp->drive));
1172         return 0;
1173 }
1174
1175 static struct block_device_operations idedisk_ops = {
1176         .owner          = THIS_MODULE,
1177         .open           = idedisk_open,
1178         .release        = idedisk_release,
1179         .ioctl          = idedisk_ioctl,
1180         .getgeo         = idedisk_getgeo,
1181         .media_changed  = idedisk_media_changed,
1182         .revalidate_disk= idedisk_revalidate_disk
1183 };
1184
1185 MODULE_DESCRIPTION("ATA DISK Driver");
1186
1187 static int ide_disk_probe(ide_drive_t *drive)
1188 {
1189         struct ide_disk_obj *idkp;
1190         struct gendisk *g;
1191
1192         /* strstr("foo", "") is non-NULL */
1193         if (!strstr("ide-disk", drive->driver_req))
1194                 goto failed;
1195         if (!drive->present)
1196                 goto failed;
1197         if (drive->media != ide_disk)
1198                 goto failed;
1199
1200         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1201         if (!idkp)
1202                 goto failed;
1203
1204         g = alloc_disk_node(1 << PARTN_BITS,
1205                         hwif_to_node(drive->hwif));
1206         if (!g)
1207                 goto out_free_idkp;
1208
1209         ide_init_disk(g, drive);
1210
1211         ide_proc_register_driver(drive, &idedisk_driver);
1212
1213         kref_init(&idkp->kref);
1214
1215         idkp->drive = drive;
1216         idkp->driver = &idedisk_driver;
1217         idkp->disk = g;
1218
1219         g->private_data = &idkp->driver;
1220
1221         drive->driver_data = idkp;
1222
1223         idedisk_setup(drive);
1224         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1225                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1226                         drive->name, drive->head);
1227                 drive->attach = 0;
1228         } else
1229                 drive->attach = 1;
1230
1231         g->minors = 1 << PARTN_BITS;
1232         g->driverfs_dev = &drive->gendev;
1233         g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1234         set_capacity(g, idedisk_capacity(drive));
1235         g->fops = &idedisk_ops;
1236         add_disk(g);
1237         return 0;
1238
1239 out_free_idkp:
1240         kfree(idkp);
1241 failed:
1242         return -ENODEV;
1243 }
1244
1245 static void __exit idedisk_exit (void)
1246 {
1247         driver_unregister(&idedisk_driver.gen_driver);
1248 }
1249
1250 static int __init idedisk_init(void)
1251 {
1252         return driver_register(&idedisk_driver.gen_driver);
1253 }
1254
1255 MODULE_ALIAS("ide:*m-disk*");
1256 module_init(idedisk_init);
1257 module_exit(idedisk_exit);
1258 MODULE_LICENSE("GPL");