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