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 #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         ATA_CMD_READ_MULTI,
 145         ATA_CMD_WRITE_MULTI,
 146         ATA_CMD_READ_MULTI_EXT,
 147         ATA_CMD_WRITE_MULTI_EXT,
 148         ATA_CMD_PIO_READ,
 149         ATA_CMD_PIO_WRITE,
 150         ATA_CMD_PIO_READ_EXT,
 151         ATA_CMD_PIO_WRITE_EXT,
 152         ATA_CMD_READ,
 153         ATA_CMD_WRITE,
 154         ATA_CMD_READ_EXT,
 155         ATA_CMD_WRITE_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 = ATA_CMD_READ_NATIVE_MAX_EXT;
 327         else
 328                 tf->command = ATA_CMD_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  = ATA_CMD_SET_MAX_EXT;
 364         } else {
 365                 tf->device   = (addr_req >>= 8) & 0x0f;
 366                 tf->command  = ATA_CMD_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  * The same here.
 390  */
 391 static inline int idedisk_supports_lba48(const u16 *id)
 392 {
 393         return (id[ATA_ID_COMMAND_SET_2] & 0x0400) &&
 394                (id[ATA_ID_CFS_ENABLE_2] & 0x0400) &&
 395                ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
 396 }
 397
 398 /*
 399  * Some disks report total number of sectors instead of
 400  * maximum sector address.  We list them here.
 401  */
 402 static const struct drive_list_entry hpa_list[] = {
 403         { "ST340823A",  NULL },
 404         { "ST320413A",  NULL },
 405         { "ST310211A",  NULL },
 406         { NULL,         NULL }
 407 };
 408
 409 static void idedisk_check_hpa(ide_drive_t *drive)
 410 {
 411         unsigned long long capacity, set_max;
 412         int lba48 = idedisk_supports_lba48(drive->id);
 413
 414         capacity = drive->capacity64;
 415
 416         set_max = idedisk_read_native_max_address(drive, lba48);
 417
 418         if (ide_in_drive_list(drive->id, hpa_list)) {
 419                 /*
 420                  * Since we are inclusive wrt to firmware revisions do this
 421                  * extra check and apply the workaround only when needed.
 422                  */
 423                 if (set_max == capacity + 1)
 424                         set_max--;
 425         }
 426
 427         if (set_max <= capacity)
 428                 return;
 429
 430         printk(KERN_INFO "%s: Host Protected Area detected.\n"
 431                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
 432                          "\tnative  capacity is %llu sectors (%llu MB)\n",
 433                          drive->name,
 434                          capacity, sectors_to_MB(capacity),
 435                          set_max, sectors_to_MB(set_max));
 436
 437         set_max = idedisk_set_max_address(drive, set_max, lba48);
 438
 439         if (set_max) {
 440                 drive->capacity64 = set_max;
 441                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
 442                                  drive->name);
 443         }
 444 }
 445
 446 static void init_idedisk_capacity(ide_drive_t *drive)
 447 {
 448         u16 *id = drive->id;
 449         /*
 450          * If this drive supports the Host Protected Area feature set,
 451          * then we may need to change our opinion about the drive's capacity.
 452          */
 453         int hpa = ata_id_hpa_enabled(id);
 454
 455         if (idedisk_supports_lba48(id)) {
 456                 /* drive speaks 48-bit LBA */
 457                 drive->select.b.lba = 1;
 458                 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
 459                 if (hpa)
 460                         idedisk_check_hpa(drive);
 461         } else if (ata_id_has_lba(id) && lba_capacity_is_ok(id)) {
 462                 /* drive speaks 28-bit LBA */
 463                 drive->select.b.lba = 1;
 464                 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
 465                 if (hpa)
 466                         idedisk_check_hpa(drive);
 467         } else {
 468                 /* drive speaks boring old 28-bit CHS */
 469                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
 470         }
 471 }
 472
 473 static sector_t idedisk_capacity(ide_drive_t *drive)
 474 {
 475         return drive->capacity64;
 476 }
 477
 478 #ifdef CONFIG_IDE_PROC_FS
 479 static int smart_enable(ide_drive_t *drive)
 480 {
 481         ide_task_t args;
 482         struct ide_taskfile *tf = &args.tf;
 483
 484         memset(&args, 0, sizeof(ide_task_t));
 485         tf->feature = ATA_SMART_ENABLE;
 486         tf->lbam    = ATA_SMART_LBAM_PASS;
 487         tf->lbah    = ATA_SMART_LBAH_PASS;
 488         tf->command = ATA_CMD_SMART;
 489         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 490         return ide_no_data_taskfile(drive, &args);
 491 }
 492
 493 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 494 {
 495         ide_task_t args;
 496         struct ide_taskfile *tf = &args.tf;
 497
 498         memset(&args, 0, sizeof(ide_task_t));
 499         tf->feature = sub_cmd;
 500         tf->nsect   = 0x01;
 501         tf->lbam    = ATA_SMART_LBAM_PASS;
 502         tf->lbah    = ATA_SMART_LBAH_PASS;
 503         tf->command = ATA_CMD_SMART;
 504         args.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 505         args.data_phase = TASKFILE_IN;
 506         (void) smart_enable(drive);
 507         return ide_raw_taskfile(drive, &args, buf, 1);
 508 }
 509
 510 static int proc_idedisk_read_cache
 511         (char *page, char **start, off_t off, int count, int *eof, void *data)
 512 {
 513         ide_drive_t     *drive = (ide_drive_t *) data;
 514         char            *out = page;
 515         int             len;
 516
 517         if (drive->id_read)
 518                 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
 519         else
 520                 len = sprintf(out, "(none)\n");
 521
 522         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 523 }
 524
 525 static int proc_idedisk_read_capacity
 526         (char *page, char **start, off_t off, int count, int *eof, void *data)
 527 {
 528         ide_drive_t*drive = (ide_drive_t *)data;
 529         int len;
 530
 531         len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
 532
 533         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 534 }
 535
 536 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
 537                                    int count, int *eof, void *data, u8 sub_cmd)
 538 {
 539         ide_drive_t     *drive = (ide_drive_t *)data;
 540         int             len = 0, i = 0;
 541
 542         if (get_smart_data(drive, page, sub_cmd) == 0) {
 543                 unsigned short *val = (unsigned short *) page;
 544                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 545                 page = out;
 546                 do {
 547                         out += sprintf(out, "%04x%c", le16_to_cpu(*val),
 548                                        (++i & 7) ? ' ' : '\n');
 549                         val += 1;
 550                 } while (i < (SECTOR_WORDS * 2));
 551                 len = out - page;
 552         }
 553
 554         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 555 }
 556
 557 static int proc_idedisk_read_sv
 558         (char *page, char **start, off_t off, int count, int *eof, void *data)
 559 {
 560         return proc_idedisk_read_smart(page, start, off, count, eof, data,
 561                                        ATA_SMART_READ_VALUES);
 562 }
 563
 564 static int proc_idedisk_read_st
 565         (char *page, char **start, off_t off, int count, int *eof, void *data)
 566 {
 567         return proc_idedisk_read_smart(page, start, off, count, eof, data,
 568                                        ATA_SMART_READ_THRESHOLDS);
 569 }
 570
 571 static ide_proc_entry_t idedisk_proc[] = {
 572         { "cache",        S_IFREG|S_IRUGO, proc_idedisk_read_cache,    NULL },
 573         { "capacity",     S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
 574         { "geometry",     S_IFREG|S_IRUGO, proc_ide_read_geometry,     NULL },
 575         { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv,       NULL },
 576         { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st,   NULL },
 577         { NULL, 0, NULL, NULL }
 578 };
 579 #endif  /* CONFIG_IDE_PROC_FS */
 580
 581 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 582 {
 583         ide_drive_t *drive = q->queuedata;
 584         ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
 585
 586         /* FIXME: map struct ide_taskfile on rq->cmd[] */
 587         BUG_ON(task == NULL);
 588
 589         memset(task, 0, sizeof(*task));
 590         if (ide_id_has_flush_cache_ext(drive->id) &&
 591             (drive->capacity64 >= (1UL << 28)))
 592                 task->tf.command = ATA_CMD_FLUSH_EXT;
 593         else
 594                 task->tf.command = ATA_CMD_FLUSH;
 595         task->tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
 596                            IDE_TFLAG_DYN;
 597         task->data_phase = TASKFILE_NO_DATA;
 598
 599         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
 600         rq->cmd_flags |= REQ_SOFTBARRIER;
 601         rq->special = task;
 602 }
 603
 604 /*
 605  * This is tightly woven into the driver->do_special can not touch.
 606  * DON'T do it again until a total personality rewrite is committed.
 607  */
 608 static int set_multcount(ide_drive_t *drive, int arg)
 609 {
 610         struct request *rq;
 611         int error;
 612
 613         if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
 614                 return -EINVAL;
 615
 616         if (drive->special.b.set_multmode)
 617                 return -EBUSY;
 618
 619         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
 620         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
 621
 622         drive->mult_req = arg;
 623         drive->special.b.set_multmode = 1;
 624         error = blk_execute_rq(drive->queue, NULL, rq, 0);
 625         blk_put_request(rq);
 626
 627         return (drive->mult_count == arg) ? 0 : -EIO;
 628 }
 629
 630 static int set_nowerr(ide_drive_t *drive, int arg)
 631 {
 632         if (arg < 0 || arg > 1)
 633                 return -EINVAL;
 634
 635         if (ide_spin_wait_hwgroup(drive))
 636                 return -EBUSY;
 637         drive->nowerr = arg;
 638         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
 639         spin_unlock_irq(&ide_lock);
 640         return 0;
 641 }
 642
 643 static void update_ordered(ide_drive_t *drive)
 644 {
 645         u16 *id = drive->id;
 646         unsigned ordered = QUEUE_ORDERED_NONE;
 647         prepare_flush_fn *prep_fn = NULL;
 648
 649         if (drive->wcache) {
 650                 unsigned long long capacity;
 651                 int barrier;
 652                 /*
 653                  * We must avoid issuing commands a drive does not
 654                  * understand or we may crash it. We check flush cache
 655                  * is supported. We also check we have the LBA48 flush
 656                  * cache if the drive capacity is too large. By this
 657                  * time we have trimmed the drive capacity if LBA48 is
 658                  * not available so we don't need to recheck that.
 659                  */
 660                 capacity = idedisk_capacity(drive);
 661                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
 662                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
 663                          ide_id_has_flush_cache_ext(id));
 664
 665                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
 666                        drive->name, barrier ? "" : "not ");
 667
 668                 if (barrier) {
 669                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
 670                         prep_fn = idedisk_prepare_flush;
 671                 }
 672         } else
 673                 ordered = QUEUE_ORDERED_DRAIN;
 674
 675         blk_queue_ordered(drive->queue, ordered, prep_fn);
 676 }
 677
 678 static int write_cache(ide_drive_t *drive, int arg)
 679 {
 680         ide_task_t args;
 681         int err = 1;
 682
 683         if (arg < 0 || arg > 1)
 684                 return -EINVAL;
 685
 686         if (ide_id_has_flush_cache(drive->id)) {
 687                 memset(&args, 0, sizeof(ide_task_t));
 688                 args.tf.feature = arg ?
 689                         SETFEATURES_WC_ON : SETFEATURES_WC_OFF;
 690                 args.tf.command = ATA_CMD_SET_FEATURES;
 691                 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 692                 err = ide_no_data_taskfile(drive, &args);
 693                 if (err == 0)
 694                         drive->wcache = arg;
 695         }
 696
 697         update_ordered(drive);
 698
 699         return err;
 700 }
 701
 702 static int do_idedisk_flushcache(ide_drive_t *drive)
 703 {
 704         ide_task_t args;
 705
 706         memset(&args, 0, sizeof(ide_task_t));
 707         if (ide_id_has_flush_cache_ext(drive->id))
 708                 args.tf.command = ATA_CMD_FLUSH_EXT;
 709         else
 710                 args.tf.command = ATA_CMD_FLUSH;
 711         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 712         return ide_no_data_taskfile(drive, &args);
 713 }
 714
 715 static int set_acoustic(ide_drive_t *drive, int arg)
 716 {
 717         ide_task_t args;
 718
 719         if (arg < 0 || arg > 254)
 720                 return -EINVAL;
 721
 722         memset(&args, 0, sizeof(ide_task_t));
 723         args.tf.feature = arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF;
 724         args.tf.nsect   = arg;
 725         args.tf.command = ATA_CMD_SET_FEATURES;
 726         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 727         ide_no_data_taskfile(drive, &args);
 728         drive->acoustic = arg;
 729         return 0;
 730 }
 731
 732 /*
 733  * drive->addressing:
 734  *      0: 28-bit
 735  *      1: 48-bit
 736  *      2: 48-bit capable doing 28-bit
 737  */
 738 static int set_lba_addressing(ide_drive_t *drive, int arg)
 739 {
 740         if (arg < 0 || arg > 2)
 741                 return -EINVAL;
 742
 743         drive->addressing =  0;
 744
 745         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
 746                 return 0;
 747
 748         if (!idedisk_supports_lba48(drive->id))
 749                 return -EIO;
 750         drive->addressing = arg;
 751         return 0;
 752 }
 753
 754 #ifdef CONFIG_IDE_PROC_FS
 755 static void idedisk_add_settings(ide_drive_t *drive)
 756 {
 757         ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
 758                         &drive->bios_cyl, NULL);
 759         ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
 760                         &drive->bios_head, NULL);
 761         ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1,
 762                         &drive->bios_sect, NULL);
 763         ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1,
 764                         &drive->addressing, set_lba_addressing);
 765         ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0,
 766                         drive->id[ATA_ID_MAX_MULTSECT] & 0xff, 1, 1,
 767                         &drive->mult_count, set_multcount);
 768         ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
 769                         &drive->nowerr, set_nowerr);
 770         ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1,
 771                         &drive->lun, NULL);
 772         ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
 773                         &drive->wcache, write_cache);
 774         ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1,
 775                         &drive->acoustic, set_acoustic);
 776         ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
 777                         &drive->failures, NULL);
 778         ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535,
 779                         1, 1, &drive->max_failures, NULL);
 780 }
 781 #else
 782 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
 783 #endif
 784
 785 static void idedisk_setup(ide_drive_t *drive)
 786 {
 787         ide_hwif_t *hwif = drive->hwif;
 788         u16 *id = drive->id;
 789         char *m = (char *)&id[ATA_ID_PROD];
 790         unsigned long long capacity;
 791
 792         idedisk_add_settings(drive);
 793
 794         if (drive->id_read == 0)
 795                 return;
 796
 797         if (drive->removable) {
 798                 /*
 799                  * Removable disks (eg. SYQUEST); ignore 'WD' drives
 800                  */
 801                 if (m[0] != 'W' || m[1] != 'D')
 802                         drive->doorlocking = 1;
 803         }
 804
 805         (void)set_lba_addressing(drive, 1);
 806
 807         if (drive->addressing == 1) {
 808                 int max_s = 2048;
 809
 810                 if (max_s > hwif->rqsize)
 811                         max_s = hwif->rqsize;
 812
 813                 blk_queue_max_sectors(drive->queue, max_s);
 814         }
 815
 816         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
 817                          drive->queue->max_sectors / 2);
 818
 819         /* calculate drive capacity, and select LBA if possible */
 820         init_idedisk_capacity(drive);
 821
 822         /* limit drive capacity to 137GB if LBA48 cannot be used */
 823         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
 824                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
 825                        "%llu sectors (%llu MB)\n",
 826                        drive->name, (unsigned long long)drive->capacity64,
 827                        sectors_to_MB(drive->capacity64));
 828                 drive->capacity64 = 1ULL << 28;
 829         }
 830
 831         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
 832                 if (drive->capacity64 > 1ULL << 28) {
 833                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
 834                                          " will be used for accessing sectors "
 835                                          "> %u\n", drive->name, 1 << 28);
 836                 } else
 837                         drive->addressing = 0;
 838         }
 839
 840         /*
 841          * if possible, give fdisk access to more of the drive,
 842          * by correcting bios_cyls:
 843          */
 844         capacity = idedisk_capacity(drive);
 845
 846         if (!drive->forced_geom) {
 847
 848                 if (idedisk_supports_lba48(drive->id)) {
 849                         /* compatibility */
 850                         drive->bios_sect = 63;
 851                         drive->bios_head = 255;
 852                 }
 853
 854                 if (drive->bios_sect && drive->bios_head) {
 855                         unsigned int cap0 = capacity; /* truncate to 32 bits */
 856                         unsigned int cylsz, cyl;
 857
 858                         if (cap0 != capacity)
 859                                 drive->bios_cyl = 65535;
 860                         else {
 861                                 cylsz = drive->bios_sect * drive->bios_head;
 862                                 cyl = cap0 / cylsz;
 863                                 if (cyl > 65535)
 864                                         cyl = 65535;
 865                                 if (cyl > drive->bios_cyl)
 866                                         drive->bios_cyl = cyl;
 867                         }
 868                 }
 869         }
 870         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
 871                          drive->name, capacity, sectors_to_MB(capacity));
 872
 873         /* Only print cache size when it was specified */
 874         if (id[ATA_ID_BUF_SIZE])
 875                 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
 876
 877         printk(KERN_CONT ", CHS=%d/%d/%d\n",
 878                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
 879
 880         /* write cache enabled? */
 881         if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
 882                 drive->wcache = 1;
 883
 884         write_cache(drive, 1);
 885 }
 886
 887 static void ide_cacheflush_p(ide_drive_t *drive)
 888 {
 889         if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
 890                 return;
 891
 892         if (do_idedisk_flushcache(drive))
 893                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 894 }
 895
 896 static void ide_disk_remove(ide_drive_t *drive)
 897 {
 898         struct ide_disk_obj *idkp = drive->driver_data;
 899         struct gendisk *g = idkp->disk;
 900
 901         ide_proc_unregister_driver(drive, idkp->driver);
 902
 903         del_gendisk(g);
 904
 905         ide_cacheflush_p(drive);
 906
 907         ide_disk_put(idkp);
 908 }
 909
 910 static void ide_disk_release(struct kref *kref)
 911 {
 912         struct ide_disk_obj *idkp = to_ide_disk(kref);
 913         ide_drive_t *drive = idkp->drive;
 914         struct gendisk *g = idkp->disk;
 915
 916         drive->driver_data = NULL;
 917         g->private_data = NULL;
 918         put_disk(g);
 919         kfree(idkp);
 920 }
 921
 922 static int ide_disk_probe(ide_drive_t *drive);
 923
 924 /*
 925  * On HPA drives the capacity needs to be
 926  * reinitilized on resume otherwise the disk
 927  * can not be used and a hard reset is required
 928  */
 929 static void ide_disk_resume(ide_drive_t *drive)
 930 {
 931         if (ata_id_hpa_enabled(drive->id))
 932                 init_idedisk_capacity(drive);
 933 }
 934
 935 static void ide_device_shutdown(ide_drive_t *drive)
 936 {
 937 #ifdef  CONFIG_ALPHA
 938         /* On Alpha, halt(8) doesn't actually turn the machine off,
 939            it puts you into the sort of firmware monitor. Typically,
 940            it's used to boot another kernel image, so it's not much
 941            different from reboot(8). Therefore, we don't need to
 942            spin down the disk in this case, especially since Alpha
 943            firmware doesn't handle disks in standby mode properly.
 944            On the other hand, it's reasonably safe to turn the power
 945            off when the shutdown process reaches the firmware prompt,
 946            as the firmware initialization takes rather long time -
 947            at least 10 seconds, which should be sufficient for
 948            the disk to expire its write cache. */
 949         if (system_state != SYSTEM_POWER_OFF) {
 950 #else
 951         if (system_state == SYSTEM_RESTART) {
 952 #endif
 953                 ide_cacheflush_p(drive);
 954                 return;
 955         }
 956
 957         printk(KERN_INFO "Shutdown: %s\n", drive->name);
 958
 959         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
 960 }
 961
 962 static ide_driver_t idedisk_driver = {
 963         .gen_driver = {
 964                 .owner          = THIS_MODULE,
 965                 .name           = "ide-disk",
 966                 .bus            = &ide_bus_type,
 967         },
 968         .probe                  = ide_disk_probe,
 969         .remove                 = ide_disk_remove,
 970         .resume                 = ide_disk_resume,
 971         .shutdown               = ide_device_shutdown,
 972         .version                = IDEDISK_VERSION,
 973         .media                  = ide_disk,
 974         .supports_dsc_overlap   = 0,
 975         .do_request             = ide_do_rw_disk,
 976         .end_request            = ide_end_request,
 977         .error                  = __ide_error,
 978 #ifdef CONFIG_IDE_PROC_FS
 979         .proc                   = idedisk_proc,
 980 #endif
 981 };
 982
 983 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
 984 {
 985         ide_task_t task;
 986
 987         memset(&task, 0, sizeof(task));
 988         task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
 989         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 990
 991         return ide_no_data_taskfile(drive, &task);
 992 }
 993
 994 static int idedisk_open(struct inode *inode, struct file *filp)
 995 {
 996         struct gendisk *disk = inode->i_bdev->bd_disk;
 997         struct ide_disk_obj *idkp;
 998         ide_drive_t *drive;
 999
1000         idkp = ide_disk_get(disk);
1001         if (idkp == NULL)
1002                 return -ENXIO;
1003
1004         drive = idkp->drive;
1005
1006         idkp->openers++;
1007
1008         if (drive->removable && idkp->openers == 1) {
1009                 check_disk_change(inode->i_bdev);
1010                 /*
1011                  * Ignore the return code from door_lock,
1012                  * since the open() has already succeeded,
1013                  * and the door_lock is irrelevant at this point.
1014                  */
1015                 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1016                         drive->doorlocking = 0;
1017         }
1018         return 0;
1019 }
1020
1021 static int idedisk_release(struct inode *inode, struct file *filp)
1022 {
1023         struct gendisk *disk = inode->i_bdev->bd_disk;
1024         struct ide_disk_obj *idkp = ide_disk_g(disk);
1025         ide_drive_t *drive = idkp->drive;
1026
1027         if (idkp->openers == 1)
1028                 ide_cacheflush_p(drive);
1029
1030         if (drive->removable && idkp->openers == 1) {
1031                 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1032                         drive->doorlocking = 0;
1033         }
1034
1035         idkp->openers--;
1036
1037         ide_disk_put(idkp);
1038
1039         return 0;
1040 }
1041
1042 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1043 {
1044         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1045         ide_drive_t *drive = idkp->drive;
1046
1047         geo->heads = drive->bios_head;
1048         geo->sectors = drive->bios_sect;
1049         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1050         return 0;
1051 }
1052
1053 static int idedisk_ioctl(struct inode *inode, struct file *file,
1054                         unsigned int cmd, unsigned long arg)
1055 {
1056         unsigned long flags;
1057         struct block_device *bdev = inode->i_bdev;
1058         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1059         ide_drive_t *drive = idkp->drive;
1060         int err, (*setfunc)(ide_drive_t *, int);
1061         u8 *val;
1062
1063         switch (cmd) {
1064         case HDIO_GET_ADDRESS:   val = &drive->addressing;      goto read_val;
1065         case HDIO_GET_MULTCOUNT: val = &drive->mult_count;      goto read_val;
1066         case HDIO_GET_NOWERR:    val = &drive->nowerr;          goto read_val;
1067         case HDIO_GET_WCACHE:    val = &drive->wcache;          goto read_val;
1068         case HDIO_GET_ACOUSTIC:  val = &drive->acoustic;        goto read_val;
1069         case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
1070         case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
1071         case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
1072         case HDIO_SET_WCACHE:    setfunc = write_cache;         goto set_val;
1073         case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
1074         }
1075
1076         return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1077
1078 read_val:
1079         mutex_lock(&ide_setting_mtx);
1080         spin_lock_irqsave(&ide_lock, flags);
1081         err = *val;
1082         spin_unlock_irqrestore(&ide_lock, flags);
1083         mutex_unlock(&ide_setting_mtx);
1084         return err >= 0 ? put_user(err, (long __user *)arg) : err;
1085
1086 set_val:
1087         if (bdev != bdev->bd_contains)
1088                 err = -EINVAL;
1089         else {
1090                 if (!capable(CAP_SYS_ADMIN))
1091                         err = -EACCES;
1092                 else {
1093                         mutex_lock(&ide_setting_mtx);
1094                         err = setfunc(drive, arg);
1095                         mutex_unlock(&ide_setting_mtx);
1096                 }
1097         }
1098         return err;
1099 }
1100
1101 static int idedisk_media_changed(struct gendisk *disk)
1102 {
1103         struct ide_disk_obj *idkp = ide_disk_g(disk);
1104         ide_drive_t *drive = idkp->drive;
1105
1106         /* do not scan partitions twice if this is a removable device */
1107         if (drive->attach) {
1108                 drive->attach = 0;
1109                 return 0;
1110         }
1111         /* if removable, always assume it was changed */
1112         return drive->removable;
1113 }
1114
1115 static int idedisk_revalidate_disk(struct gendisk *disk)
1116 {
1117         struct ide_disk_obj *idkp = ide_disk_g(disk);
1118         set_capacity(disk, idedisk_capacity(idkp->drive));
1119         return 0;
1120 }
1121
1122 static struct block_device_operations idedisk_ops = {
1123         .owner                  = THIS_MODULE,
1124         .open                   = idedisk_open,
1125         .release                = idedisk_release,
1126         .ioctl                  = idedisk_ioctl,
1127         .getgeo                 = idedisk_getgeo,
1128         .media_changed          = idedisk_media_changed,
1129         .revalidate_disk        = idedisk_revalidate_disk
1130 };
1131
1132 MODULE_DESCRIPTION("ATA DISK Driver");
1133
1134 static int ide_disk_probe(ide_drive_t *drive)
1135 {
1136         struct ide_disk_obj *idkp;
1137         struct gendisk *g;
1138
1139         /* strstr("foo", "") is non-NULL */
1140         if (!strstr("ide-disk", drive->driver_req))
1141                 goto failed;
1142         if (!drive->present)
1143                 goto failed;
1144         if (drive->media != ide_disk)
1145                 goto failed;
1146
1147         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1148         if (!idkp)
1149                 goto failed;
1150
1151         g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1152         if (!g)
1153                 goto out_free_idkp;
1154
1155         ide_init_disk(g, drive);
1156
1157         ide_proc_register_driver(drive, &idedisk_driver);
1158
1159         kref_init(&idkp->kref);
1160
1161         idkp->drive = drive;
1162         idkp->driver = &idedisk_driver;
1163         idkp->disk = g;
1164
1165         g->private_data = &idkp->driver;
1166
1167         drive->driver_data = idkp;
1168
1169         idedisk_setup(drive);
1170         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1171                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1172                         drive->name, drive->head);
1173                 drive->attach = 0;
1174         } else
1175                 drive->attach = 1;
1176
1177         g->minors = IDE_DISK_MINORS;
1178         g->driverfs_dev = &drive->gendev;
1179         g->flags |= GENHD_FL_EXT_DEVT;
1180         if (drive->removable)
1181                 g->flags |= GENHD_FL_REMOVABLE;
1182         set_capacity(g, idedisk_capacity(drive));
1183         g->fops = &idedisk_ops;
1184         add_disk(g);
1185         return 0;
1186
1187 out_free_idkp:
1188         kfree(idkp);
1189 failed:
1190         return -ENODEV;
1191 }
1192
1193 static void __exit idedisk_exit(void)
1194 {
1195         driver_unregister(&idedisk_driver.gen_driver);
1196 }
1197
1198 static int __init idedisk_init(void)
1199 {
1200         return driver_register(&idedisk_driver.gen_driver);
1201 }
1202
1203 MODULE_ALIAS("ide:*m-disk*");
1204 module_init(idedisk_init);
1205 module_exit(idedisk_exit);
1206 MODULE_LICENSE("GPL");