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