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