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 //#define DEBUG
  20
  21 #include <linux/module.h>
  22 #include <linux/types.h>
  23 #include <linux/string.h>
  24 #include <linux/kernel.h>
  25 #include <linux/timer.h>
  26 #include <linux/mm.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/major.h>
  29 #include <linux/errno.h>
  30 #include <linux/genhd.h>
  31 #include <linux/slab.h>
  32 #include <linux/delay.h>
  33 #include <linux/mutex.h>
  34 #include <linux/leds.h>
  35
  36 #define _IDE_DISK
  37
  38 #include <linux/ide.h>
  39
  40 #include <asm/byteorder.h>
  41 #include <asm/irq.h>
  42 #include <asm/uaccess.h>
  43 #include <asm/io.h>
  44 #include <asm/div64.h>
  45
  46 struct ide_disk_obj {
  47         ide_drive_t     *drive;
  48         ide_driver_t    *driver;
  49         struct gendisk  *disk;
  50         struct kref     kref;
  51         unsigned int    openers;        /* protected by BKL for now */
  52 };
  53
  54 static DEFINE_MUTEX(idedisk_ref_mutex);
  55
  56 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
  57
  58 #define ide_disk_g(disk) \
  59         container_of((disk)->private_data, struct ide_disk_obj, driver)
  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         mutex_unlock(&idedisk_ref_mutex);
  70         return idkp;
  71 }
  72
  73 static void ide_disk_release(struct kref *);
  74
  75 static void ide_disk_put(struct ide_disk_obj *idkp)
  76 {
  77         mutex_lock(&idedisk_ref_mutex);
  78         kref_put(&idkp->kref, ide_disk_release);
  79         mutex_unlock(&idedisk_ref_mutex);
  80 }
  81
  82 /*
  83  * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
  84  * value for this drive (from its reported identification information).
  85  *
  86  * Returns:     1 if lba_capacity looks sensible
  87  *              0 otherwise
  88  *
  89  * It is called only once for each drive.
  90  */
  91 static int lba_capacity_is_ok (struct hd_driveid *id)
  92 {
  93         unsigned long lba_sects, chs_sects, head, tail;
  94
  95         /* No non-LBA info .. so valid! */
  96         if (id->cyls == 0)
  97                 return 1;
  98
  99         /*
 100          * The ATA spec tells large drives to return
 101          * C/H/S = 16383/16/63 independent of their size.
 102          * Some drives can be jumpered to use 15 heads instead of 16.
 103          * Some drives can be jumpered to use 4092 cyls instead of 16383.
 104          */
 105         if ((id->cyls == 16383
 106              || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
 107             id->sectors == 63 &&
 108             (id->heads == 15 || id->heads == 16) &&
 109             (id->lba_capacity >= 16383*63*id->heads))
 110                 return 1;
 111
 112         lba_sects   = id->lba_capacity;
 113         chs_sects   = id->cyls * id->heads * id->sectors;
 114
 115         /* perform a rough sanity check on lba_sects:  within 10% is OK */
 116         if ((lba_sects - chs_sects) < chs_sects/10)
 117                 return 1;
 118
 119         /* some drives have the word order reversed */
 120         head = ((lba_sects >> 16) & 0xffff);
 121         tail = (lba_sects & 0xffff);
 122         lba_sects = (head | (tail << 16));
 123         if ((lba_sects - chs_sects) < chs_sects/10) {
 124                 id->lba_capacity = lba_sects;
 125                 return 1;       /* lba_capacity is (now) good */
 126         }
 127
 128         return 0;       /* lba_capacity value may be bad */
 129 }
 130
 131 static const u8 ide_rw_cmds[] = {
 132         WIN_MULTREAD,
 133         WIN_MULTWRITE,
 134         WIN_MULTREAD_EXT,
 135         WIN_MULTWRITE_EXT,
 136         WIN_READ,
 137         WIN_WRITE,
 138         WIN_READ_EXT,
 139         WIN_WRITE_EXT,
 140         WIN_READDMA,
 141         WIN_WRITEDMA,
 142         WIN_READDMA_EXT,
 143         WIN_WRITEDMA_EXT,
 144 };
 145
 146 static const u8 ide_data_phases[] = {
 147         TASKFILE_MULTI_IN,
 148         TASKFILE_MULTI_OUT,
 149         TASKFILE_IN,
 150         TASKFILE_OUT,
 151         TASKFILE_IN_DMA,
 152         TASKFILE_OUT_DMA,
 153 };
 154
 155 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
 156 {
 157         u8 index, lba48, write;
 158
 159         lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
 160         write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
 161
 162         if (dma)
 163                 index = drive->vdma ? 4 : 8;
 164         else
 165                 index = drive->mult_count ? 0 : 4;
 166
 167         task->tf.command = ide_rw_cmds[index + lba48 + write];
 168
 169         if (dma)
 170                 index = 8; /* fixup index */
 171
 172         task->data_phase = ide_data_phases[index / 2 + write];
 173 }
 174
 175 /*
 176  * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
 177  * using LBA if supported, or CHS otherwise, to address sectors.
 178  */
 179 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
 180 {
 181         ide_hwif_t *hwif        = HWIF(drive);
 182         unsigned int dma        = drive->using_dma;
 183         u16 nsectors            = (u16)rq->nr_sectors;
 184         u8 lba48                = (drive->addressing == 1) ? 1 : 0;
 185         ide_task_t              task;
 186         struct ide_taskfile     *tf = &task.tf;
 187         ide_startstop_t         rc;
 188
 189         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
 190                 if (block + rq->nr_sectors > 1ULL << 28)
 191                         dma = 0;
 192                 else
 193                         lba48 = 0;
 194         }
 195
 196         if (!dma) {
 197                 ide_init_sg_cmd(drive, rq);
 198                 ide_map_sg(drive, rq);
 199         }
 200
 201         memset(&task, 0, sizeof(task));
 202         task.tf_flags = IDE_TFLAG_NO_SELECT_MASK;  /* FIXME? */
 203         task.tf_flags |= (IDE_TFLAG_TF | IDE_TFLAG_DEVICE);
 204
 205         if (drive->select.b.lba) {
 206                 if (lba48) {
 207                         pr_debug("%s: LBA=0x%012llx\n", drive->name,
 208                                         (unsigned long long)block);
 209
 210                         tf->hob_nsect = (nsectors >> 8) & 0xff;
 211                         tf->hob_lbal  = (u8)(block >> 24);
 212                         if (sizeof(block) != 4) {
 213                                 tf->hob_lbam = (u8)((u64)block >> 32);
 214                                 tf->hob_lbah = (u8)((u64)block >> 40);
 215                         }
 216
 217                         tf->nsect  = nsectors & 0xff;
 218                         tf->lbal   = (u8) block;
 219                         tf->lbam   = (u8)(block >>  8);
 220                         tf->lbah   = (u8)(block >> 16);
 221
 222                         task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
 223                 } else {
 224                         tf->nsect  = nsectors & 0xff;
 225                         tf->lbal   = block;
 226                         tf->lbam   = block >>= 8;
 227                         tf->lbah   = block >>= 8;
 228                         tf->device = (block >> 8) & 0xf;
 229                 }
 230         } else {
 231                 unsigned int sect,head,cyl,track;
 232                 track = (int)block / drive->sect;
 233                 sect  = (int)block % drive->sect + 1;
 234                 head  = track % drive->head;
 235                 cyl   = track / drive->head;
 236
 237                 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
 238
 239                 tf->nsect  = nsectors & 0xff;
 240                 tf->lbal   = sect;
 241                 tf->lbam   = cyl;
 242                 tf->lbah   = cyl >> 8;
 243                 tf->device = head;
 244         }
 245
 246         if (rq_data_dir(rq))
 247                 task.tf_flags |= IDE_TFLAG_WRITE;
 248
 249         ide_tf_set_cmd(drive, &task, dma);
 250         if (!dma)
 251                 hwif->data_phase = task.data_phase;
 252         task.rq = rq;
 253
 254         rc = do_rw_taskfile(drive, &task);
 255
 256         if (rc == ide_stopped && dma) {
 257                 /* fallback to PIO */
 258                 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
 259                 ide_tf_set_cmd(drive, &task, 0);
 260                 hwif->data_phase = task.data_phase;
 261                 ide_init_sg_cmd(drive, rq);
 262                 rc = do_rw_taskfile(drive, &task);
 263         }
 264
 265         return rc;
 266 }
 267
 268 /*
 269  * 268435455  == 137439 MB or 28bit limit
 270  * 320173056  == 163929 MB or 48bit addressing
 271  * 1073741822 == 549756 MB or 48bit addressing fake drive
 272  */
 273
 274 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
 275 {
 276         ide_hwif_t *hwif = HWIF(drive);
 277
 278         BUG_ON(drive->blocked);
 279
 280         if (!blk_fs_request(rq)) {
 281                 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
 282                 ide_end_request(drive, 0, 0);
 283                 return ide_stopped;
 284         }
 285
 286         ledtrig_ide_activity();
 287
 288         pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
 289                  drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
 290                  (unsigned long long)block, rq->nr_sectors,
 291                  (unsigned long)rq->buffer);
 292
 293         if (hwif->rw_disk)
 294                 hwif->rw_disk(drive, rq);
 295
 296         return __ide_do_rw_disk(drive, rq, block);
 297 }
 298
 299 /*
 300  * Queries for true maximum capacity of the drive.
 301  * Returns maximum LBA address (> 0) of the drive, 0 if failed.
 302  */
 303 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
 304 {
 305         ide_task_t args;
 306         struct ide_taskfile *tf = &args.tf;
 307         u64 addr = 0;
 308
 309         /* Create IDE/ATA command request structure */
 310         memset(&args, 0, sizeof(ide_task_t));
 311         if (lba48)
 312                 tf->command = WIN_READ_NATIVE_MAX_EXT;
 313         else
 314                 tf->command = WIN_READ_NATIVE_MAX;
 315         tf->device  = ATA_LBA;
 316         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 317         if (lba48)
 318                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
 319         /* submit command request */
 320         ide_no_data_taskfile(drive, &args);
 321
 322         /* if OK, compute maximum address value */
 323         if ((tf->status & 0x01) == 0)
 324                 addr = ide_get_lba_addr(tf, lba48) + 1;
 325
 326         return addr;
 327 }
 328
 329 /*
 330  * Sets maximum virtual LBA address of the drive.
 331  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
 332  */
 333 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
 334 {
 335         ide_task_t args;
 336         struct ide_taskfile *tf = &args.tf;
 337         u64 addr_set = 0;
 338
 339         addr_req--;
 340         /* Create IDE/ATA command request structure */
 341         memset(&args, 0, sizeof(ide_task_t));
 342         tf->lbal     = (addr_req >>  0) & 0xff;
 343         tf->lbam     = (addr_req >>= 8) & 0xff;
 344         tf->lbah     = (addr_req >>= 8) & 0xff;
 345         if (lba48) {
 346                 tf->hob_lbal = (addr_req >>= 8) & 0xff;
 347                 tf->hob_lbam = (addr_req >>= 8) & 0xff;
 348                 tf->hob_lbah = (addr_req >>= 8) & 0xff;
 349                 tf->command  = WIN_SET_MAX_EXT;
 350         } else {
 351                 tf->device   = (addr_req >>= 8) & 0x0f;
 352                 tf->command  = WIN_SET_MAX;
 353         }
 354         tf->device |= ATA_LBA;
 355         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 356         if (lba48)
 357                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
 358         /* submit command request */
 359         ide_no_data_taskfile(drive, &args);
 360         /* if OK, compute maximum address value */
 361         if ((tf->status & 0x01) == 0)
 362                 addr_set = ide_get_lba_addr(tf, lba48) + 1;
 363
 364         return addr_set;
 365 }
 366
 367 static unsigned long long sectors_to_MB(unsigned long long n)
 368 {
 369         n <<= 9;                /* make it bytes */
 370         do_div(n, 1000000);     /* make it MB */
 371         return n;
 372 }
 373
 374 /*
 375  * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
 376  * so on non-buggy drives we need test only one.
 377  * However, we should also check whether these fields are valid.
 378  */
 379 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
 380 {
 381         return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
 382 }
 383
 384 /*
 385  * The same here.
 386  */
 387 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
 388 {
 389         return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
 390                && id->lba_capacity_2;
 391 }
 392
 393 /*
 394  * Some disks report total number of sectors instead of
 395  * maximum sector address.  We list them here.
 396  */
 397 static const struct drive_list_entry hpa_list[] = {
 398         { "ST340823A",  NULL },
 399         { "ST320413A",  NULL },
 400         { "ST310211A",  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_TF | IDE_TFLAG_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_TF | IDE_TFLAG_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(char *page, char **start, off_t off,
 544                                    int count, int *eof, void *data, u8 sub_cmd)
 545 {
 546         ide_drive_t     *drive = (ide_drive_t *)data;
 547         int             len = 0, i = 0;
 548
 549         if (get_smart_data(drive, page, sub_cmd) == 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_sv
 563         (char *page, char **start, off_t off, int count, int *eof, void *data)
 564 {
 565         return proc_idedisk_read_smart(page, start, off, count, eof, data,
 566                                        SMART_READ_VALUES);
 567 }
 568
 569 static int proc_idedisk_read_st
 570         (char *page, char **start, off_t off, int count, int *eof, void *data)
 571 {
 572         return proc_idedisk_read_smart(page, start, off, count, eof, data,
 573                                        SMART_READ_THRESHOLDS);
 574 }
 575
 576 static ide_proc_entry_t idedisk_proc[] = {
 577         { "cache",        S_IFREG|S_IRUGO, proc_idedisk_read_cache,    NULL },
 578         { "capacity",     S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
 579         { "geometry",     S_IFREG|S_IRUGO, proc_ide_read_geometry,     NULL },
 580         { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv,       NULL },
 581         { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st,   NULL },
 582         { NULL, 0, NULL, NULL }
 583 };
 584 #endif  /* CONFIG_IDE_PROC_FS */
 585
 586 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 587 {
 588         ide_drive_t *drive = q->queuedata;
 589         ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
 590
 591         /* FIXME: map struct ide_taskfile on rq->cmd[] */
 592         BUG_ON(task == NULL);
 593
 594         memset(task, 0, sizeof(*task));
 595         if (ide_id_has_flush_cache_ext(drive->id) &&
 596             (drive->capacity64 >= (1UL << 28)))
 597                 task->tf.command = WIN_FLUSH_CACHE_EXT;
 598         else
 599                 task->tf.command = WIN_FLUSH_CACHE;
 600         task->tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
 601                            IDE_TFLAG_DYN;
 602         task->data_phase = TASKFILE_NO_DATA;
 603
 604         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
 605         rq->cmd_flags |= REQ_SOFTBARRIER;
 606         rq->special = task;
 607 }
 608
 609 /*
 610  * This is tightly woven into the driver->do_special can not touch.
 611  * DON'T do it again until a total personality rewrite is committed.
 612  */
 613 static int set_multcount(ide_drive_t *drive, int arg)
 614 {
 615         struct request rq;
 616
 617         if (arg < 0 || arg > drive->id->max_multsect)
 618                 return -EINVAL;
 619
 620         if (drive->special.b.set_multmode)
 621                 return -EBUSY;
 622
 623         ide_init_drive_cmd (&rq);
 624         rq.cmd_type = REQ_TYPE_ATA_TASKFILE;
 625
 626         drive->mult_req = arg;
 627         drive->special.b.set_multmode = 1;
 628         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
 629         return (drive->mult_count == arg) ? 0 : -EIO;
 630 }
 631
 632 static int set_nowerr(ide_drive_t *drive, int arg)
 633 {
 634         if (arg < 0 || arg > 1)
 635                 return -EINVAL;
 636
 637         if (ide_spin_wait_hwgroup(drive))
 638                 return -EBUSY;
 639         drive->nowerr = arg;
 640         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
 641         spin_unlock_irq(&ide_lock);
 642         return 0;
 643 }
 644
 645 static void update_ordered(ide_drive_t *drive)
 646 {
 647         struct hd_driveid *id = drive->id;
 648         unsigned ordered = QUEUE_ORDERED_NONE;
 649         prepare_flush_fn *prep_fn = NULL;
 650
 651         if (drive->wcache) {
 652                 unsigned long long capacity;
 653                 int barrier;
 654                 /*
 655                  * We must avoid issuing commands a drive does not
 656                  * understand or we may crash it. We check flush cache
 657                  * is supported. We also check we have the LBA48 flush
 658                  * cache if the drive capacity is too large. By this
 659                  * time we have trimmed the drive capacity if LBA48 is
 660                  * not available so we don't need to recheck that.
 661                  */
 662                 capacity = idedisk_capacity(drive);
 663                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
 664                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
 665                          ide_id_has_flush_cache_ext(id));
 666
 667                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
 668                        drive->name, barrier ? "" : "not ");
 669
 670                 if (barrier) {
 671                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
 672                         prep_fn = idedisk_prepare_flush;
 673                 }
 674         } else
 675                 ordered = QUEUE_ORDERED_DRAIN;
 676
 677         blk_queue_ordered(drive->queue, ordered, prep_fn);
 678 }
 679
 680 static int write_cache(ide_drive_t *drive, int arg)
 681 {
 682         ide_task_t args;
 683         int err = 1;
 684
 685         if (arg < 0 || arg > 1)
 686                 return -EINVAL;
 687
 688         if (ide_id_has_flush_cache(drive->id)) {
 689                 memset(&args, 0, sizeof(ide_task_t));
 690                 args.tf.feature = arg ?
 691                         SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
 692                 args.tf.command = WIN_SETFEATURES;
 693                 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 694                 err = ide_no_data_taskfile(drive, &args);
 695                 if (err == 0)
 696                         drive->wcache = arg;
 697         }
 698
 699         update_ordered(drive);
 700
 701         return err;
 702 }
 703
 704 static int do_idedisk_flushcache (ide_drive_t *drive)
 705 {
 706         ide_task_t args;
 707
 708         memset(&args, 0, sizeof(ide_task_t));
 709         if (ide_id_has_flush_cache_ext(drive->id))
 710                 args.tf.command = WIN_FLUSH_CACHE_EXT;
 711         else
 712                 args.tf.command = WIN_FLUSH_CACHE;
 713         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 714         return ide_no_data_taskfile(drive, &args);
 715 }
 716
 717 static int set_acoustic (ide_drive_t *drive, int arg)
 718 {
 719         ide_task_t args;
 720
 721         if (arg < 0 || arg > 254)
 722                 return -EINVAL;
 723
 724         memset(&args, 0, sizeof(ide_task_t));
 725         args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
 726         args.tf.nsect   = arg;
 727         args.tf.command = WIN_SETFEATURES;
 728         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 729         ide_no_data_taskfile(drive, &args);
 730         drive->acoustic = arg;
 731         return 0;
 732 }
 733
 734 /*
 735  * drive->addressing:
 736  *      0: 28-bit
 737  *      1: 48-bit
 738  *      2: 48-bit capable doing 28-bit
 739  */
 740 static int set_lba_addressing(ide_drive_t *drive, int arg)
 741 {
 742         if (arg < 0 || arg > 2)
 743                 return -EINVAL;
 744
 745         drive->addressing =  0;
 746
 747         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
 748                 return 0;
 749
 750         if (!idedisk_supports_lba48(drive->id))
 751                 return -EIO;
 752         drive->addressing = arg;
 753         return 0;
 754 }
 755
 756 #ifdef CONFIG_IDE_PROC_FS
 757 static void idedisk_add_settings(ide_drive_t *drive)
 758 {
 759         struct hd_driveid *id = drive->id;
 760
 761         ide_add_setting(drive,  "bios_cyl",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->bios_cyl,       NULL);
 762         ide_add_setting(drive,  "bios_head",    SETTING_RW,     TYPE_BYTE,      0,      255,                    1,      1,      &drive->bios_head,      NULL);
 763         ide_add_setting(drive,  "bios_sect",    SETTING_RW,     TYPE_BYTE,      0,      63,                     1,      1,      &drive->bios_sect,      NULL);
 764         ide_add_setting(drive,  "address",      SETTING_RW,     TYPE_BYTE,      0,      2,                      1,      1,      &drive->addressing,     set_lba_addressing);
 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(KERN_CONT " 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(KERN_INFO "Shutdown: %s\n", drive->name);
 948
 949         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
 950 }
 951
 952 static ide_driver_t idedisk_driver = {
 953         .gen_driver = {
 954                 .owner          = THIS_MODULE,
 955                 .name           = "ide-disk",
 956                 .bus            = &ide_bus_type,
 957         },
 958         .probe                  = ide_disk_probe,
 959         .remove                 = ide_disk_remove,
 960         .resume                 = ide_disk_resume,
 961         .shutdown               = ide_device_shutdown,
 962         .version                = IDEDISK_VERSION,
 963         .media                  = ide_disk,
 964         .supports_dsc_overlap   = 0,
 965         .do_request             = ide_do_rw_disk,
 966         .end_request            = ide_end_request,
 967         .error                  = __ide_error,
 968         .abort                  = __ide_abort,
 969 #ifdef CONFIG_IDE_PROC_FS
 970         .proc                   = idedisk_proc,
 971 #endif
 972 };
 973
 974 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
 975 {
 976         ide_task_t task;
 977
 978         memset(&task, 0, sizeof(task));
 979         task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK;
 980         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 981
 982         return ide_no_data_taskfile(drive, &task);
 983 }
 984
 985 static int idedisk_open(struct inode *inode, struct file *filp)
 986 {
 987         struct gendisk *disk = inode->i_bdev->bd_disk;
 988         struct ide_disk_obj *idkp;
 989         ide_drive_t *drive;
 990
 991         if (!(idkp = ide_disk_get(disk)))
 992                 return -ENXIO;
 993
 994         drive = idkp->drive;
 995
 996         idkp->openers++;
 997
 998         if (drive->removable && idkp->openers == 1) {
 999                 check_disk_change(inode->i_bdev);
1000                 /*
1001                  * Ignore the return code from door_lock,
1002                  * since the open() has already succeeded,
1003                  * and the door_lock is irrelevant at this point.
1004                  */
1005                 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1006                         drive->doorlocking = 0;
1007         }
1008         return 0;
1009 }
1010
1011 static int idedisk_release(struct inode *inode, struct file *filp)
1012 {
1013         struct gendisk *disk = inode->i_bdev->bd_disk;
1014         struct ide_disk_obj *idkp = ide_disk_g(disk);
1015         ide_drive_t *drive = idkp->drive;
1016
1017         if (idkp->openers == 1)
1018                 ide_cacheflush_p(drive);
1019
1020         if (drive->removable && idkp->openers == 1) {
1021                 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1022                         drive->doorlocking = 0;
1023         }
1024
1025         idkp->openers--;
1026
1027         ide_disk_put(idkp);
1028
1029         return 0;
1030 }
1031
1032 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1033 {
1034         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1035         ide_drive_t *drive = idkp->drive;
1036
1037         geo->heads = drive->bios_head;
1038         geo->sectors = drive->bios_sect;
1039         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1040         return 0;
1041 }
1042
1043 static int idedisk_ioctl(struct inode *inode, struct file *file,
1044                         unsigned int cmd, unsigned long arg)
1045 {
1046         unsigned long flags;
1047         struct block_device *bdev = inode->i_bdev;
1048         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1049         ide_drive_t *drive = idkp->drive;
1050         int err, (*setfunc)(ide_drive_t *, int);
1051         u8 *val;
1052
1053         switch (cmd) {
1054         case HDIO_GET_ADDRESS:   val = &drive->addressing;      goto read_val;
1055         case HDIO_GET_MULTCOUNT: val = &drive->mult_count;      goto read_val;
1056         case HDIO_GET_NOWERR:    val = &drive->nowerr;          goto read_val;
1057         case HDIO_GET_WCACHE:    val = &drive->wcache;          goto read_val;
1058         case HDIO_GET_ACOUSTIC:  val = &drive->acoustic;        goto read_val;
1059         case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
1060         case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
1061         case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
1062         case HDIO_SET_WCACHE:    setfunc = write_cache;         goto set_val;
1063         case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
1064         }
1065
1066         return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1067
1068 read_val:
1069         mutex_lock(&ide_setting_mtx);
1070         spin_lock_irqsave(&ide_lock, flags);
1071         err = *val;
1072         spin_unlock_irqrestore(&ide_lock, flags);
1073         mutex_unlock(&ide_setting_mtx);
1074         return err >= 0 ? put_user(err, (long __user *)arg) : err;
1075
1076 set_val:
1077         if (bdev != bdev->bd_contains)
1078                 err = -EINVAL;
1079         else {
1080                 if (!capable(CAP_SYS_ADMIN))
1081                         err = -EACCES;
1082                 else {
1083                         mutex_lock(&ide_setting_mtx);
1084                         err = setfunc(drive, arg);
1085                         mutex_unlock(&ide_setting_mtx);
1086                 }
1087         }
1088         return err;
1089 }
1090
1091 static int idedisk_media_changed(struct gendisk *disk)
1092 {
1093         struct ide_disk_obj *idkp = ide_disk_g(disk);
1094         ide_drive_t *drive = idkp->drive;
1095
1096         /* do not scan partitions twice if this is a removable device */
1097         if (drive->attach) {
1098                 drive->attach = 0;
1099                 return 0;
1100         }
1101         /* if removable, always assume it was changed */
1102         return drive->removable;
1103 }
1104
1105 static int idedisk_revalidate_disk(struct gendisk *disk)
1106 {
1107         struct ide_disk_obj *idkp = ide_disk_g(disk);
1108         set_capacity(disk, idedisk_capacity(idkp->drive));
1109         return 0;
1110 }
1111
1112 static struct block_device_operations idedisk_ops = {
1113         .owner          = THIS_MODULE,
1114         .open           = idedisk_open,
1115         .release        = idedisk_release,
1116         .ioctl          = idedisk_ioctl,
1117         .getgeo         = idedisk_getgeo,
1118         .media_changed  = idedisk_media_changed,
1119         .revalidate_disk= idedisk_revalidate_disk
1120 };
1121
1122 MODULE_DESCRIPTION("ATA DISK Driver");
1123
1124 static int ide_disk_probe(ide_drive_t *drive)
1125 {
1126         struct ide_disk_obj *idkp;
1127         struct gendisk *g;
1128
1129         /* strstr("foo", "") is non-NULL */
1130         if (!strstr("ide-disk", drive->driver_req))
1131                 goto failed;
1132         if (!drive->present)
1133                 goto failed;
1134         if (drive->media != ide_disk)
1135                 goto failed;
1136
1137         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1138         if (!idkp)
1139                 goto failed;
1140
1141         g = alloc_disk_node(1 << PARTN_BITS,
1142                         hwif_to_node(drive->hwif));
1143         if (!g)
1144                 goto out_free_idkp;
1145
1146         ide_init_disk(g, drive);
1147
1148         ide_proc_register_driver(drive, &idedisk_driver);
1149
1150         kref_init(&idkp->kref);
1151
1152         idkp->drive = drive;
1153         idkp->driver = &idedisk_driver;
1154         idkp->disk = g;
1155
1156         g->private_data = &idkp->driver;
1157
1158         drive->driver_data = idkp;
1159
1160         idedisk_setup(drive);
1161         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1162                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1163                         drive->name, drive->head);
1164                 drive->attach = 0;
1165         } else
1166                 drive->attach = 1;
1167
1168         g->minors = 1 << PARTN_BITS;
1169         g->driverfs_dev = &drive->gendev;
1170         g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1171         set_capacity(g, idedisk_capacity(drive));
1172         g->fops = &idedisk_ops;
1173         add_disk(g);
1174         return 0;
1175
1176 out_free_idkp:
1177         kfree(idkp);
1178 failed:
1179         return -ENODEV;
1180 }
1181
1182 static void __exit idedisk_exit (void)
1183 {
1184         driver_unregister(&idedisk_driver.gen_driver);
1185 }
1186
1187 static int __init idedisk_init(void)
1188 {
1189         return driver_register(&idedisk_driver.gen_driver);
1190 }
1191
1192 MODULE_ALIAS("ide:*m-disk*");
1193 module_init(idedisk_init);
1194 module_exit(idedisk_exit);
1195 MODULE_LICENSE("GPL");