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