SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/ide/ide-disk.c

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