drivers/ide/ide-disk.c

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