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         { NULL,         NULL }
 401 };
 402
 403 static void idedisk_check_hpa(ide_drive_t *drive)
 404 {
 405         unsigned long long capacity, set_max;
 406         int lba48 = idedisk_supports_lba48(drive->id);
 407
 408         capacity = drive->capacity64;
 409
 410         set_max = idedisk_read_native_max_address(drive, lba48);
 411
 412         if (ide_in_drive_list(drive->id, hpa_list)) {
 413                 /*
 414                  * Since we are inclusive wrt to firmware revisions do this
 415                  * extra check and apply the workaround only when needed.
 416                  */
 417                 if (set_max == capacity + 1)
 418                         set_max--;
 419         }
 420
 421         if (set_max <= capacity)
 422                 return;
 423
 424         printk(KERN_INFO "%s: Host Protected Area detected.\n"
 425                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
 426                          "\tnative  capacity is %llu sectors (%llu MB)\n",
 427                          drive->name,
 428                          capacity, sectors_to_MB(capacity),
 429                          set_max, sectors_to_MB(set_max));
 430
 431         set_max = idedisk_set_max_address(drive, set_max, lba48);
 432
 433         if (set_max) {
 434                 drive->capacity64 = set_max;
 435                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
 436                                  drive->name);
 437         }
 438 }
 439
 440 /*
 441  * Compute drive->capacity, the full capacity of the drive
 442  * Called with drive->id != NULL.
 443  *
 444  * To compute capacity, this uses either of
 445  *
 446  *    1. CHS value set by user       (whatever user sets will be trusted)
 447  *    2. LBA value from target drive (require new ATA feature)
 448  *    3. LBA value from system BIOS  (new one is OK, old one may break)
 449  *    4. CHS value from system BIOS  (traditional style)
 450  *
 451  * in above order (i.e., if value of higher priority is available,
 452  * reset will be ignored).
 453  */
 454 static void init_idedisk_capacity (ide_drive_t  *drive)
 455 {
 456         struct hd_driveid *id = drive->id;
 457         /*
 458          * If this drive supports the Host Protected Area feature set,
 459          * then we may need to change our opinion about the drive's capacity.
 460          */
 461         int hpa = idedisk_supports_hpa(id);
 462
 463         if (idedisk_supports_lba48(id)) {
 464                 /* drive speaks 48-bit LBA */
 465                 drive->select.b.lba = 1;
 466                 drive->capacity64 = id->lba_capacity_2;
 467                 if (hpa)
 468                         idedisk_check_hpa(drive);
 469         } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
 470                 /* drive speaks 28-bit LBA */
 471                 drive->select.b.lba = 1;
 472                 drive->capacity64 = id->lba_capacity;
 473                 if (hpa)
 474                         idedisk_check_hpa(drive);
 475         } else {
 476                 /* drive speaks boring old 28-bit CHS */
 477                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
 478         }
 479 }
 480
 481 static sector_t idedisk_capacity (ide_drive_t *drive)
 482 {
 483         return drive->capacity64 - drive->sect0;
 484 }
 485
 486 #ifdef CONFIG_IDE_PROC_FS
 487 static int smart_enable(ide_drive_t *drive)
 488 {
 489         ide_task_t args;
 490         struct ide_taskfile *tf = &args.tf;
 491
 492         memset(&args, 0, sizeof(ide_task_t));
 493         tf->feature = SMART_ENABLE;
 494         tf->lbam    = SMART_LCYL_PASS;
 495         tf->lbah    = SMART_HCYL_PASS;
 496         tf->command = WIN_SMART;
 497         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 498         return ide_no_data_taskfile(drive, &args);
 499 }
 500
 501 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 502 {
 503         ide_task_t args;
 504         struct ide_taskfile *tf = &args.tf;
 505
 506         memset(&args, 0, sizeof(ide_task_t));
 507         tf->feature = sub_cmd;
 508         tf->nsect   = 0x01;
 509         tf->lbam    = SMART_LCYL_PASS;
 510         tf->lbah    = SMART_HCYL_PASS;
 511         tf->command = WIN_SMART;
 512         args.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 513         args.data_phase = TASKFILE_IN;
 514         (void) smart_enable(drive);
 515         return ide_raw_taskfile(drive, &args, buf, 1);
 516 }
 517
 518 static int proc_idedisk_read_cache
 519         (char *page, char **start, off_t off, int count, int *eof, void *data)
 520 {
 521         ide_drive_t     *drive = (ide_drive_t *) data;
 522         char            *out = page;
 523         int             len;
 524
 525         if (drive->id_read)
 526                 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
 527         else
 528                 len = sprintf(out,"(none)\n");
 529         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 530 }
 531
 532 static int proc_idedisk_read_capacity
 533         (char *page, char **start, off_t off, int count, int *eof, void *data)
 534 {
 535         ide_drive_t*drive = (ide_drive_t *)data;
 536         int len;
 537
 538         len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
 539         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 540 }
 541
 542 static int proc_idedisk_read_smart_thresholds
 543         (char *page, char **start, off_t off, int count, int *eof, void *data)
 544 {
 545         ide_drive_t     *drive = (ide_drive_t *)data;
 546         int             len = 0, i = 0;
 547
 548         if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
 549                 unsigned short *val = (unsigned short *) page;
 550                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 551                 page = out;
 552                 do {
 553                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 554                         val += 1;
 555                 } while (i < (SECTOR_WORDS * 2));
 556                 len = out - page;
 557         }
 558         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 559 }
 560
 561 static int proc_idedisk_read_smart_values
 562         (char *page, char **start, off_t off, int count, int *eof, void *data)
 563 {
 564         ide_drive_t     *drive = (ide_drive_t *)data;
 565         int             len = 0, i = 0;
 566
 567         if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
 568                 unsigned short *val = (unsigned short *) page;
 569                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 570                 page = out;
 571                 do {
 572                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 573                         val += 1;
 574                 } while (i < (SECTOR_WORDS * 2));
 575                 len = out - page;
 576         }
 577         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 578 }
 579
 580 static ide_proc_entry_t idedisk_proc[] = {
 581         { "cache",              S_IFREG|S_IRUGO,        proc_idedisk_read_cache,                NULL },
 582         { "capacity",           S_IFREG|S_IRUGO,        proc_idedisk_read_capacity,             NULL },
 583         { "geometry",           S_IFREG|S_IRUGO,        proc_ide_read_geometry,                 NULL },
 584         { "smart_values",       S_IFREG|S_IRUSR,        proc_idedisk_read_smart_values,         NULL },
 585         { "smart_thresholds",   S_IFREG|S_IRUSR,        proc_idedisk_read_smart_thresholds,     NULL },
 586         { NULL, 0, NULL, NULL }
 587 };
 588 #endif  /* CONFIG_IDE_PROC_FS */
 589
 590 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 591 {
 592         ide_drive_t *drive = q->queuedata;
 593         ide_task_t task;
 594
 595         memset(&task, 0, sizeof(task));
 596         if (ide_id_has_flush_cache_ext(drive->id) &&
 597             (drive->capacity64 >= (1UL << 28)))
 598                 task.tf.command = WIN_FLUSH_CACHE_EXT;
 599         else
 600                 task.tf.command = WIN_FLUSH_CACHE;
 601         task.tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
 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 (" 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_TF | IDE_TFLAG_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");