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