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 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
  45 #define IDE_DISK_MINORS         (1 << PARTN_BITS)
  46 #else
  47 #define IDE_DISK_MINORS         0
  48 #endif
  49
  50 struct ide_disk_obj {
  51         ide_drive_t     *drive;
  52         ide_driver_t    *driver;
  53         struct gendisk  *disk;
  54         struct kref     kref;
  55         unsigned int    openers;        /* protected by BKL for now */
  56 };
  57
  58 static DEFINE_MUTEX(idedisk_ref_mutex);
  59
  60 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
  61
  62 #define ide_disk_g(disk) \
  63         container_of((disk)->private_data, struct ide_disk_obj, driver)
  64
  65 static void ide_disk_release(struct kref *);
  66
  67 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
  68 {
  69         struct ide_disk_obj *idkp = NULL;
  70
  71         mutex_lock(&idedisk_ref_mutex);
  72         idkp = ide_disk_g(disk);
  73         if (idkp) {
  74                 if (ide_device_get(idkp->drive))
  75                         idkp = NULL;
  76                 else
  77                         kref_get(&idkp->kref);
  78         }
  79         mutex_unlock(&idedisk_ref_mutex);
  80         return idkp;
  81 }
  82
  83 static void ide_disk_put(struct ide_disk_obj *idkp)
  84 {
  85         ide_drive_t *drive = idkp->drive;
  86
  87         mutex_lock(&idedisk_ref_mutex);
  88         kref_put(&idkp->kref, ide_disk_release);
  89         ide_device_put(drive);
  90         mutex_unlock(&idedisk_ref_mutex);
  91 }
  92
  93 /*
  94  * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
  95  * value for this drive (from its reported identification information).
  96  *
  97  * Returns:     1 if lba_capacity looks sensible
  98  *              0 otherwise
  99  *
 100  * It is called only once for each drive.
 101  */
 102 static int lba_capacity_is_ok(u16 *id)
 103 {
 104         unsigned long lba_sects, chs_sects, head, tail;
 105
 106         /* No non-LBA info .. so valid! */
 107         if (id[ATA_ID_CYLS] == 0)
 108                 return 1;
 109
 110         lba_sects = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
 111
 112         /*
 113          * The ATA spec tells large drives to return
 114          * C/H/S = 16383/16/63 independent of their size.
 115          * Some drives can be jumpered to use 15 heads instead of 16.
 116          * Some drives can be jumpered to use 4092 cyls instead of 16383.
 117          */
 118         if ((id[ATA_ID_CYLS] == 16383 ||
 119              (id[ATA_ID_CYLS] == 4092 && id[ATA_ID_CUR_CYLS] == 16383)) &&
 120             id[ATA_ID_SECTORS] == 63 &&
 121             (id[ATA_ID_HEADS] == 15 || id[ATA_ID_HEADS] == 16) &&
 122             (lba_sects >= 16383 * 63 * id[ATA_ID_HEADS]))
 123                 return 1;
 124
 125         chs_sects = id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * id[ATA_ID_SECTORS];
 126
 127         /* perform a rough sanity check on lba_sects:  within 10% is OK */
 128         if ((lba_sects - chs_sects) < chs_sects/10)
 129                 return 1;
 130
 131         /* some drives have the word order reversed */
 132         head = ((lba_sects >> 16) & 0xffff);
 133         tail = (lba_sects & 0xffff);
 134         lba_sects = (head | (tail << 16));
 135         if ((lba_sects - chs_sects) < chs_sects/10) {
 136                 *(__le32 *)&id[ATA_ID_LBA_CAPACITY] = __cpu_to_le32(lba_sects);
 137                 return 1;       /* lba_capacity is (now) good */
 138         }
 139
 140         return 0;       /* lba_capacity value may be bad */
 141 }
 142
 143 static const u8 ide_rw_cmds[] = {
 144         WIN_MULTREAD,
 145         WIN_MULTWRITE,
 146         WIN_MULTREAD_EXT,
 147         WIN_MULTWRITE_EXT,
 148         WIN_READ,
 149         WIN_WRITE,
 150         WIN_READ_EXT,
 151         WIN_WRITE_EXT,
 152         WIN_READDMA,
 153         WIN_WRITEDMA,
 154         WIN_READDMA_EXT,
 155         WIN_WRITEDMA_EXT,
 156 };
 157
 158 static const u8 ide_data_phases[] = {
 159         TASKFILE_MULTI_IN,
 160         TASKFILE_MULTI_OUT,
 161         TASKFILE_IN,
 162         TASKFILE_OUT,
 163         TASKFILE_IN_DMA,
 164         TASKFILE_OUT_DMA,
 165 };
 166
 167 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
 168 {
 169         u8 index, lba48, write;
 170
 171         lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
 172         write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
 173
 174         if (dma)
 175                 index = 8;
 176         else
 177                 index = drive->mult_count ? 0 : 4;
 178
 179         task->tf.command = ide_rw_cmds[index + lba48 + write];
 180
 181         if (dma)
 182                 index = 8; /* fixup index */
 183
 184         task->data_phase = ide_data_phases[index / 2 + write];
 185 }
 186
 187 /*
 188  * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
 189  * using LBA if supported, or CHS otherwise, to address sectors.
 190  */
 191 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
 192                                         sector_t block)
 193 {
 194         ide_hwif_t *hwif        = HWIF(drive);
 195         unsigned int dma        = drive->using_dma;
 196         u16 nsectors            = (u16)rq->nr_sectors;
 197         u8 lba48                = (drive->addressing == 1) ? 1 : 0;
 198         ide_task_t              task;
 199         struct ide_taskfile     *tf = &task.tf;
 200         ide_startstop_t         rc;
 201
 202         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
 203                 if (block + rq->nr_sectors > 1ULL << 28)
 204                         dma = 0;
 205                 else
 206                         lba48 = 0;
 207         }
 208
 209         if (!dma) {
 210                 ide_init_sg_cmd(drive, rq);
 211                 ide_map_sg(drive, rq);
 212         }
 213
 214         memset(&task, 0, sizeof(task));
 215         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 216
 217         if (drive->select.b.lba) {
 218                 if (lba48) {
 219                         pr_debug("%s: LBA=0x%012llx\n", drive->name,
 220                                         (unsigned long long)block);
 221
 222                         tf->hob_nsect = (nsectors >> 8) & 0xff;
 223                         tf->hob_lbal  = (u8)(block >> 24);
 224                         if (sizeof(block) != 4) {
 225                                 tf->hob_lbam = (u8)((u64)block >> 32);
 226                                 tf->hob_lbah = (u8)((u64)block >> 40);
 227                         }
 228
 229                         tf->nsect  = nsectors & 0xff;
 230                         tf->lbal   = (u8) block;
 231                         tf->lbam   = (u8)(block >>  8);
 232                         tf->lbah   = (u8)(block >> 16);
 233
 234                         task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
 235                 } else {
 236                         tf->nsect  = nsectors & 0xff;
 237                         tf->lbal   = block;
 238                         tf->lbam   = block >>= 8;
 239                         tf->lbah   = block >>= 8;
 240                         tf->device = (block >> 8) & 0xf;
 241                 }
 242         } else {
 243                 unsigned int sect, head, cyl, track;
 244
 245                 track = (int)block / drive->sect;
 246                 sect  = (int)block % drive->sect + 1;
 247                 head  = track % drive->head;
 248                 cyl   = track / drive->head;
 249
 250                 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
 251
 252                 tf->nsect  = nsectors & 0xff;
 253                 tf->lbal   = sect;
 254                 tf->lbam   = cyl;
 255                 tf->lbah   = cyl >> 8;
 256                 tf->device = head;
 257         }
 258
 259         if (rq_data_dir(rq))
 260                 task.tf_flags |= IDE_TFLAG_WRITE;
 261
 262         ide_tf_set_cmd(drive, &task, dma);
 263         if (!dma)
 264                 hwif->data_phase = task.data_phase;
 265         task.rq = rq;
 266
 267         rc = do_rw_taskfile(drive, &task);
 268
 269         if (rc == ide_stopped && dma) {
 270                 /* fallback to PIO */
 271                 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
 272                 ide_tf_set_cmd(drive, &task, 0);
 273                 hwif->data_phase = task.data_phase;
 274                 ide_init_sg_cmd(drive, rq);
 275                 rc = do_rw_taskfile(drive, &task);
 276         }
 277
 278         return rc;
 279 }
 280
 281 /*
 282  * 268435455  == 137439 MB or 28bit limit
 283  * 320173056  == 163929 MB or 48bit addressing
 284  * 1073741822 == 549756 MB or 48bit addressing fake drive
 285  */
 286
 287 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
 288                                       sector_t block)
 289 {
 290         ide_hwif_t *hwif = HWIF(drive);
 291
 292         BUG_ON(drive->blocked);
 293
 294         if (!blk_fs_request(rq)) {
 295                 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
 296                 ide_end_request(drive, 0, 0);
 297                 return ide_stopped;
 298         }
 299
 300         ledtrig_ide_activity();
 301
 302         pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
 303                  drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
 304                  (unsigned long long)block, rq->nr_sectors,
 305                  (unsigned long)rq->buffer);
 306
 307         if (hwif->rw_disk)
 308                 hwif->rw_disk(drive, rq);
 309
 310         return __ide_do_rw_disk(drive, rq, block);
 311 }
 312
 313 /*
 314  * Queries for true maximum capacity of the drive.
 315  * Returns maximum LBA address (> 0) of the drive, 0 if failed.
 316  */
 317 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
 318 {
 319         ide_task_t args;
 320         struct ide_taskfile *tf = &args.tf;
 321         u64 addr = 0;
 322
 323         /* Create IDE/ATA command request structure */
 324         memset(&args, 0, sizeof(ide_task_t));
 325         if (lba48)
 326                 tf->command = WIN_READ_NATIVE_MAX_EXT;
 327         else
 328                 tf->command = WIN_READ_NATIVE_MAX;
 329         tf->device  = ATA_LBA;
 330         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 331         if (lba48)
 332                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
 333         /* submit command request */
 334         ide_no_data_taskfile(drive, &args);
 335
 336         /* if OK, compute maximum address value */
 337         if ((tf->status & 0x01) == 0)
 338                 addr = ide_get_lba_addr(tf, lba48) + 1;
 339
 340         return addr;
 341 }
 342
 343 /*
 344  * Sets maximum virtual LBA address of the drive.
 345  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
 346  */
 347 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
 348 {
 349         ide_task_t args;
 350         struct ide_taskfile *tf = &args.tf;
 351         u64 addr_set = 0;
 352
 353         addr_req--;
 354         /* Create IDE/ATA command request structure */
 355         memset(&args, 0, sizeof(ide_task_t));
 356         tf->lbal     = (addr_req >>  0) & 0xff;
 357         tf->lbam     = (addr_req >>= 8) & 0xff;
 358         tf->lbah     = (addr_req >>= 8) & 0xff;
 359         if (lba48) {
 360                 tf->hob_lbal = (addr_req >>= 8) & 0xff;
 361                 tf->hob_lbam = (addr_req >>= 8) & 0xff;
 362                 tf->hob_lbah = (addr_req >>= 8) & 0xff;
 363                 tf->command  = WIN_SET_MAX_EXT;
 364         } else {
 365                 tf->device   = (addr_req >>= 8) & 0x0f;
 366                 tf->command  = WIN_SET_MAX;
 367         }
 368         tf->device |= ATA_LBA;
 369         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 370         if (lba48)
 371                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
 372         /* submit command request */
 373         ide_no_data_taskfile(drive, &args);
 374         /* if OK, compute maximum address value */
 375         if ((tf->status & 0x01) == 0)
 376                 addr_set = ide_get_lba_addr(tf, lba48) + 1;
 377
 378         return addr_set;
 379 }
 380
 381 static unsigned long long sectors_to_MB(unsigned long long n)
 382 {
 383         n <<= 9;                /* make it bytes */
 384         do_div(n, 1000000);     /* make it MB */
 385         return n;
 386 }
 387
 388 /*
 389  * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
 390  * so on non-buggy drives we need test only one.
 391  * However, we should also check whether these fields are valid.
 392  */
 393 static inline int idedisk_supports_hpa(const u16 *id)
 394 {
 395         return (id[ATA_ID_COMMAND_SET_1] & 0x0400) &&
 396                (id[ATA_ID_CFS_ENABLE_1] & 0x0400);
 397 }
 398
 399 /*
 400  * The same here.
 401  */
 402 static inline int idedisk_supports_lba48(const u16 *id)
 403 {
 404         return (id[ATA_ID_COMMAND_SET_2] & 0x0400) &&
 405                (id[ATA_ID_CFS_ENABLE_2] & 0x0400) &&
 406                ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
 407 }
 408
 409 /*
 410  * Some disks report total number of sectors instead of
 411  * maximum sector address.  We list them here.
 412  */
 413 static const struct drive_list_entry hpa_list[] = {
 414         { "ST340823A",  NULL },
 415         { "ST320413A",  NULL },
 416         { "ST310211A",  NULL },
 417         { NULL,         NULL }
 418 };
 419
 420 static void idedisk_check_hpa(ide_drive_t *drive)
 421 {
 422         unsigned long long capacity, set_max;
 423         int lba48 = idedisk_supports_lba48(drive->id);
 424
 425         capacity = drive->capacity64;
 426
 427         set_max = idedisk_read_native_max_address(drive, lba48);
 428
 429         if (ide_in_drive_list(drive->id, hpa_list)) {
 430                 /*
 431                  * Since we are inclusive wrt to firmware revisions do this
 432                  * extra check and apply the workaround only when needed.
 433                  */
 434                 if (set_max == capacity + 1)
 435                         set_max--;
 436         }
 437
 438         if (set_max <= capacity)
 439                 return;
 440
 441         printk(KERN_INFO "%s: Host Protected Area detected.\n"
 442                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
 443                          "\tnative  capacity is %llu sectors (%llu MB)\n",
 444                          drive->name,
 445                          capacity, sectors_to_MB(capacity),
 446                          set_max, sectors_to_MB(set_max));
 447
 448         set_max = idedisk_set_max_address(drive, set_max, lba48);
 449
 450         if (set_max) {
 451                 drive->capacity64 = set_max;
 452                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
 453                                  drive->name);
 454         }
 455 }
 456
 457 static void init_idedisk_capacity(ide_drive_t *drive)
 458 {
 459         u16 *id = drive->id;
 460         /*
 461          * If this drive supports the Host Protected Area feature set,
 462          * then we may need to change our opinion about the drive's capacity.
 463          */
 464         int hpa = idedisk_supports_hpa(id);
 465
 466         if (idedisk_supports_lba48(id)) {
 467                 /* drive speaks 48-bit LBA */
 468                 drive->select.b.lba = 1;
 469                 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
 470                 if (hpa)
 471                         idedisk_check_hpa(drive);
 472         } else if (ata_id_has_lba(id) && lba_capacity_is_ok(id)) {
 473                 /* drive speaks 28-bit LBA */
 474                 drive->select.b.lba = 1;
 475                 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
 476                 if (hpa)
 477                         idedisk_check_hpa(drive);
 478         } else {
 479                 /* drive speaks boring old 28-bit CHS */
 480                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
 481         }
 482 }
 483
 484 static sector_t idedisk_capacity(ide_drive_t *drive)
 485 {
 486         return drive->capacity64 - drive->sect0;
 487 }
 488
 489 #ifdef CONFIG_IDE_PROC_FS
 490 static int smart_enable(ide_drive_t *drive)
 491 {
 492         ide_task_t args;
 493         struct ide_taskfile *tf = &args.tf;
 494
 495         memset(&args, 0, sizeof(ide_task_t));
 496         tf->feature = SMART_ENABLE;
 497         tf->lbam    = SMART_LCYL_PASS;
 498         tf->lbah    = SMART_HCYL_PASS;
 499         tf->command = WIN_SMART;
 500         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 501         return ide_no_data_taskfile(drive, &args);
 502 }
 503
 504 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 505 {
 506         ide_task_t args;
 507         struct ide_taskfile *tf = &args.tf;
 508
 509         memset(&args, 0, sizeof(ide_task_t));
 510         tf->feature = sub_cmd;
 511         tf->nsect   = 0x01;
 512         tf->lbam    = SMART_LCYL_PASS;
 513         tf->lbah    = SMART_HCYL_PASS;
 514         tf->command = WIN_SMART;
 515         args.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 516         args.data_phase = TASKFILE_IN;
 517         (void) smart_enable(drive);
 518         return ide_raw_taskfile(drive, &args, buf, 1);
 519 }
 520
 521 static int proc_idedisk_read_cache
 522         (char *page, char **start, off_t off, int count, int *eof, void *data)
 523 {
 524         ide_drive_t     *drive = (ide_drive_t *) data;
 525         char            *out = page;
 526         int             len;
 527
 528         if (drive->id_read)
 529                 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
 530         else
 531                 len = sprintf(out, "(none)\n");
 532
 533         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 534 }
 535
 536 static int proc_idedisk_read_capacity
 537         (char *page, char **start, off_t off, int count, int *eof, void *data)
 538 {
 539         ide_drive_t*drive = (ide_drive_t *)data;
 540         int len;
 541
 542         len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
 543
 544         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 545 }
 546
 547 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
 548                                    int count, int *eof, void *data, u8 sub_cmd)
 549 {
 550         ide_drive_t     *drive = (ide_drive_t *)data;
 551         int             len = 0, i = 0;
 552
 553         if (get_smart_data(drive, page, sub_cmd) == 0) {
 554                 unsigned short *val = (unsigned short *) page;
 555                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 556                 page = out;
 557                 do {
 558                         out += sprintf(out, "%04x%c", le16_to_cpu(*val),
 559                                        (++i & 7) ? ' ' : '\n');
 560                         val += 1;
 561                 } while (i < (SECTOR_WORDS * 2));
 562                 len = out - page;
 563         }
 564
 565         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 566 }
 567
 568 static int proc_idedisk_read_sv
 569         (char *page, char **start, off_t off, int count, int *eof, void *data)
 570 {
 571         return proc_idedisk_read_smart(page, start, off, count, eof, data,
 572                                        SMART_READ_VALUES);
 573 }
 574
 575 static int proc_idedisk_read_st
 576         (char *page, char **start, off_t off, int count, int *eof, void *data)
 577 {
 578         return proc_idedisk_read_smart(page, start, off, count, eof, data,
 579                                        SMART_READ_THRESHOLDS);
 580 }
 581
 582 static ide_proc_entry_t idedisk_proc[] = {
 583         { "cache",        S_IFREG|S_IRUGO, proc_idedisk_read_cache,    NULL },
 584         { "capacity",     S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
 585         { "geometry",     S_IFREG|S_IRUGO, proc_ide_read_geometry,     NULL },
 586         { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv,       NULL },
 587         { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st,   NULL },
 588         { NULL, 0, NULL, NULL }
 589 };
 590 #endif  /* CONFIG_IDE_PROC_FS */
 591
 592 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 593 {
 594         ide_drive_t *drive = q->queuedata;
 595         ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
 596
 597         /* FIXME: map struct ide_taskfile on rq->cmd[] */
 598         BUG_ON(task == NULL);
 599
 600         memset(task, 0, sizeof(*task));
 601         if (ide_id_has_flush_cache_ext(drive->id) &&
 602             (drive->capacity64 >= (1UL << 28)))
 603                 task->tf.command = WIN_FLUSH_CACHE_EXT;
 604         else
 605                 task->tf.command = WIN_FLUSH_CACHE;
 606         task->tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
 607                            IDE_TFLAG_DYN;
 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         int error;
 623
 624         if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
 625                 return -EINVAL;
 626
 627         if (drive->special.b.set_multmode)
 628                 return -EBUSY;
 629
 630         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
 631         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
 632
 633         drive->mult_req = arg;
 634         drive->special.b.set_multmode = 1;
 635         error = blk_execute_rq(drive->queue, NULL, rq, 0);
 636         blk_put_request(rq);
 637
 638         return (drive->mult_count == arg) ? 0 : -EIO;
 639 }
 640
 641 static int set_nowerr(ide_drive_t *drive, int arg)
 642 {
 643         if (arg < 0 || arg > 1)
 644                 return -EINVAL;
 645
 646         if (ide_spin_wait_hwgroup(drive))
 647                 return -EBUSY;
 648         drive->nowerr = arg;
 649         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
 650         spin_unlock_irq(&ide_lock);
 651         return 0;
 652 }
 653
 654 static void update_ordered(ide_drive_t *drive)
 655 {
 656         u16 *id = drive->id;
 657         unsigned ordered = QUEUE_ORDERED_NONE;
 658         prepare_flush_fn *prep_fn = NULL;
 659
 660         if (drive->wcache) {
 661                 unsigned long long capacity;
 662                 int barrier;
 663                 /*
 664                  * We must avoid issuing commands a drive does not
 665                  * understand or we may crash it. We check flush cache
 666                  * is supported. We also check we have the LBA48 flush
 667                  * cache if the drive capacity is too large. By this
 668                  * time we have trimmed the drive capacity if LBA48 is
 669                  * not available so we don't need to recheck that.
 670                  */
 671                 capacity = idedisk_capacity(drive);
 672                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
 673                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
 674                          ide_id_has_flush_cache_ext(id));
 675
 676                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
 677                        drive->name, barrier ? "" : "not ");
 678
 679                 if (barrier) {
 680                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
 681                         prep_fn = idedisk_prepare_flush;
 682                 }
 683         } else
 684                 ordered = QUEUE_ORDERED_DRAIN;
 685
 686         blk_queue_ordered(drive->queue, ordered, prep_fn);
 687 }
 688
 689 static int write_cache(ide_drive_t *drive, int arg)
 690 {
 691         ide_task_t args;
 692         int err = 1;
 693
 694         if (arg < 0 || arg > 1)
 695                 return -EINVAL;
 696
 697         if (ide_id_has_flush_cache(drive->id)) {
 698                 memset(&args, 0, sizeof(ide_task_t));
 699                 args.tf.feature = arg ?
 700                         SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
 701                 args.tf.command = WIN_SETFEATURES;
 702                 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 703                 err = ide_no_data_taskfile(drive, &args);
 704                 if (err == 0)
 705                         drive->wcache = arg;
 706         }
 707
 708         update_ordered(drive);
 709
 710         return err;
 711 }
 712
 713 static int do_idedisk_flushcache(ide_drive_t *drive)
 714 {
 715         ide_task_t args;
 716
 717         memset(&args, 0, sizeof(ide_task_t));
 718         if (ide_id_has_flush_cache_ext(drive->id))
 719                 args.tf.command = WIN_FLUSH_CACHE_EXT;
 720         else
 721                 args.tf.command = WIN_FLUSH_CACHE;
 722         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 723         return ide_no_data_taskfile(drive, &args);
 724 }
 725
 726 static int set_acoustic(ide_drive_t *drive, int arg)
 727 {
 728         ide_task_t args;
 729
 730         if (arg < 0 || arg > 254)
 731                 return -EINVAL;
 732
 733         memset(&args, 0, sizeof(ide_task_t));
 734         args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
 735         args.tf.nsect   = arg;
 736         args.tf.command = WIN_SETFEATURES;
 737         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 738         ide_no_data_taskfile(drive, &args);
 739         drive->acoustic = arg;
 740         return 0;
 741 }
 742
 743 /*
 744  * drive->addressing:
 745  *      0: 28-bit
 746  *      1: 48-bit
 747  *      2: 48-bit capable doing 28-bit
 748  */
 749 static int set_lba_addressing(ide_drive_t *drive, int arg)
 750 {
 751         if (arg < 0 || arg > 2)
 752                 return -EINVAL;
 753
 754         drive->addressing =  0;
 755
 756         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
 757                 return 0;
 758
 759         if (!idedisk_supports_lba48(drive->id))
 760                 return -EIO;
 761         drive->addressing = arg;
 762         return 0;
 763 }
 764
 765 #ifdef CONFIG_IDE_PROC_FS
 766 static void idedisk_add_settings(ide_drive_t *drive)
 767 {
 768         ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
 769                         &drive->bios_cyl, NULL);
 770         ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
 771                         &drive->bios_head, NULL);
 772         ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1,
 773                         &drive->bios_sect, NULL);
 774         ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1,
 775                         &drive->addressing, set_lba_addressing);
 776         ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0,
 777                         drive->id[ATA_ID_MAX_MULTSECT] & 0xff, 1, 1,
 778                         &drive->mult_count, set_multcount);
 779         ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
 780                         &drive->nowerr, set_nowerr);
 781         ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1,
 782                         &drive->lun, NULL);
 783         ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
 784                         &drive->wcache, write_cache);
 785         ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1,
 786                         &drive->acoustic, set_acoustic);
 787         ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
 788                         &drive->failures, NULL);
 789         ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535,
 790                         1, 1, &drive->max_failures, NULL);
 791 }
 792 #else
 793 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
 794 #endif
 795
 796 static void idedisk_setup(ide_drive_t *drive)
 797 {
 798         ide_hwif_t *hwif = drive->hwif;
 799         u16 *id = drive->id;
 800         char *m = (char *)&id[ATA_ID_PROD];
 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 (m[0] != 'W' || m[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[ATA_ID_BUF_SIZE])
 886                 printk(KERN_CONT " w/%dKiB Cache", id[ATA_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[ATA_ID_CSFO] & 1) || (id[ATA_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 #ifdef CONFIG_IDE_PROC_FS
 990         .proc                   = idedisk_proc,
 991 #endif
 992 };
 993
 994 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
 995 {
 996         ide_task_t task;
 997
 998         memset(&task, 0, sizeof(task));
 999         task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK;
1000         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
1001
1002         return ide_no_data_taskfile(drive, &task);
1003 }
1004
1005 static int idedisk_open(struct inode *inode, struct file *filp)
1006 {
1007         struct gendisk *disk = inode->i_bdev->bd_disk;
1008         struct ide_disk_obj *idkp;
1009         ide_drive_t *drive;
1010
1011         idkp = ide_disk_get(disk);
1012         if (idkp == NULL)
1013                 return -ENXIO;
1014
1015         drive = idkp->drive;
1016
1017         idkp->openers++;
1018
1019         if (drive->removable && idkp->openers == 1) {
1020                 check_disk_change(inode->i_bdev);
1021                 /*
1022                  * Ignore the return code from door_lock,
1023                  * since the open() has already succeeded,
1024                  * and the door_lock is irrelevant at this point.
1025                  */
1026                 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1027                         drive->doorlocking = 0;
1028         }
1029         return 0;
1030 }
1031
1032 static int idedisk_release(struct inode *inode, struct file *filp)
1033 {
1034         struct gendisk *disk = inode->i_bdev->bd_disk;
1035         struct ide_disk_obj *idkp = ide_disk_g(disk);
1036         ide_drive_t *drive = idkp->drive;
1037
1038         if (idkp->openers == 1)
1039                 ide_cacheflush_p(drive);
1040
1041         if (drive->removable && idkp->openers == 1) {
1042                 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1043                         drive->doorlocking = 0;
1044         }
1045
1046         idkp->openers--;
1047
1048         ide_disk_put(idkp);
1049
1050         return 0;
1051 }
1052
1053 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1054 {
1055         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1056         ide_drive_t *drive = idkp->drive;
1057
1058         geo->heads = drive->bios_head;
1059         geo->sectors = drive->bios_sect;
1060         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1061         return 0;
1062 }
1063
1064 static int idedisk_ioctl(struct inode *inode, struct file *file,
1065                         unsigned int cmd, unsigned long arg)
1066 {
1067         unsigned long flags;
1068         struct block_device *bdev = inode->i_bdev;
1069         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1070         ide_drive_t *drive = idkp->drive;
1071         int err, (*setfunc)(ide_drive_t *, int);
1072         u8 *val;
1073
1074         switch (cmd) {
1075         case HDIO_GET_ADDRESS:   val = &drive->addressing;      goto read_val;
1076         case HDIO_GET_MULTCOUNT: val = &drive->mult_count;      goto read_val;
1077         case HDIO_GET_NOWERR:    val = &drive->nowerr;          goto read_val;
1078         case HDIO_GET_WCACHE:    val = &drive->wcache;          goto read_val;
1079         case HDIO_GET_ACOUSTIC:  val = &drive->acoustic;        goto read_val;
1080         case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
1081         case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
1082         case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
1083         case HDIO_SET_WCACHE:    setfunc = write_cache;         goto set_val;
1084         case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
1085         }
1086
1087         return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1088
1089 read_val:
1090         mutex_lock(&ide_setting_mtx);
1091         spin_lock_irqsave(&ide_lock, flags);
1092         err = *val;
1093         spin_unlock_irqrestore(&ide_lock, flags);
1094         mutex_unlock(&ide_setting_mtx);
1095         return err >= 0 ? put_user(err, (long __user *)arg) : err;
1096
1097 set_val:
1098         if (bdev != bdev->bd_contains)
1099                 err = -EINVAL;
1100         else {
1101                 if (!capable(CAP_SYS_ADMIN))
1102                         err = -EACCES;
1103                 else {
1104                         mutex_lock(&ide_setting_mtx);
1105                         err = setfunc(drive, arg);
1106                         mutex_unlock(&ide_setting_mtx);
1107                 }
1108         }
1109         return err;
1110 }
1111
1112 static int idedisk_media_changed(struct gendisk *disk)
1113 {
1114         struct ide_disk_obj *idkp = ide_disk_g(disk);
1115         ide_drive_t *drive = idkp->drive;
1116
1117         /* do not scan partitions twice if this is a removable device */
1118         if (drive->attach) {
1119                 drive->attach = 0;
1120                 return 0;
1121         }
1122         /* if removable, always assume it was changed */
1123         return drive->removable;
1124 }
1125
1126 static int idedisk_revalidate_disk(struct gendisk *disk)
1127 {
1128         struct ide_disk_obj *idkp = ide_disk_g(disk);
1129         set_capacity(disk, idedisk_capacity(idkp->drive));
1130         return 0;
1131 }
1132
1133 static struct block_device_operations idedisk_ops = {
1134         .owner                  = THIS_MODULE,
1135         .open                   = idedisk_open,
1136         .release                = idedisk_release,
1137         .ioctl                  = idedisk_ioctl,
1138         .getgeo                 = idedisk_getgeo,
1139         .media_changed          = idedisk_media_changed,
1140         .revalidate_disk        = idedisk_revalidate_disk
1141 };
1142
1143 MODULE_DESCRIPTION("ATA DISK Driver");
1144
1145 static int ide_disk_probe(ide_drive_t *drive)
1146 {
1147         struct ide_disk_obj *idkp;
1148         struct gendisk *g;
1149
1150         /* strstr("foo", "") is non-NULL */
1151         if (!strstr("ide-disk", drive->driver_req))
1152                 goto failed;
1153         if (!drive->present)
1154                 goto failed;
1155         if (drive->media != ide_disk)
1156                 goto failed;
1157
1158         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1159         if (!idkp)
1160                 goto failed;
1161
1162         g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1163         if (!g)
1164                 goto out_free_idkp;
1165
1166         ide_init_disk(g, drive);
1167
1168         ide_proc_register_driver(drive, &idedisk_driver);
1169
1170         kref_init(&idkp->kref);
1171
1172         idkp->drive = drive;
1173         idkp->driver = &idedisk_driver;
1174         idkp->disk = g;
1175
1176         g->private_data = &idkp->driver;
1177
1178         drive->driver_data = idkp;
1179
1180         idedisk_setup(drive);
1181         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1182                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1183                         drive->name, drive->head);
1184                 drive->attach = 0;
1185         } else
1186                 drive->attach = 1;
1187
1188         g->minors = IDE_DISK_MINORS;
1189         g->driverfs_dev = &drive->gendev;
1190         g->flags |= GENHD_FL_EXT_DEVT;
1191         if (drive->removable)
1192                 g->flags |= GENHD_FL_REMOVABLE;
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");