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