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