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