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