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