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