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