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 /*
  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  * The same here.
 388  */
 389 static inline int idedisk_supports_lba48(const u16 *id)
 390 {
 391         return (id[ATA_ID_COMMAND_SET_2] & 0x0400) &&
 392                (id[ATA_ID_CFS_ENABLE_2] & 0x0400) &&
 393                ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
 394 }
 395
 396 /*
 397  * Some disks report total number of sectors instead of
 398  * maximum sector address.  We list them here.
 399  */
 400 static const struct drive_list_entry hpa_list[] = {
 401         { "ST340823A",  NULL },
 402         { "ST320413A",  NULL },
 403         { "ST310211A",  NULL },
 404         { NULL,         NULL }
 405 };
 406
 407 static void idedisk_check_hpa(ide_drive_t *drive)
 408 {
 409         unsigned long long capacity, set_max;
 410         int lba48 = idedisk_supports_lba48(drive->id);
 411
 412         capacity = drive->capacity64;
 413
 414         set_max = idedisk_read_native_max_address(drive, lba48);
 415
 416         if (ide_in_drive_list(drive->id, hpa_list)) {
 417                 /*
 418                  * Since we are inclusive wrt to firmware revisions do this
 419                  * extra check and apply the workaround only when needed.
 420                  */
 421                 if (set_max == capacity + 1)
 422                         set_max--;
 423         }
 424
 425         if (set_max <= capacity)
 426                 return;
 427
 428         printk(KERN_INFO "%s: Host Protected Area detected.\n"
 429                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
 430                          "\tnative  capacity is %llu sectors (%llu MB)\n",
 431                          drive->name,
 432                          capacity, sectors_to_MB(capacity),
 433                          set_max, sectors_to_MB(set_max));
 434
 435         set_max = idedisk_set_max_address(drive, set_max, lba48);
 436
 437         if (set_max) {
 438                 drive->capacity64 = set_max;
 439                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
 440                                  drive->name);
 441         }
 442 }
 443
 444 static void init_idedisk_capacity(ide_drive_t *drive)
 445 {
 446         u16 *id = drive->id;
 447         /*
 448          * If this drive supports the Host Protected Area feature set,
 449          * then we may need to change our opinion about the drive's capacity.
 450          */
 451         int hpa = ata_id_hpa_enabled(id);
 452
 453         if (idedisk_supports_lba48(id)) {
 454                 /* drive speaks 48-bit LBA */
 455                 drive->select.b.lba = 1;
 456                 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
 457                 if (hpa)
 458                         idedisk_check_hpa(drive);
 459         } else if (ata_id_has_lba(id) && lba_capacity_is_ok(id)) {
 460                 /* drive speaks 28-bit LBA */
 461                 drive->select.b.lba = 1;
 462                 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
 463                 if (hpa)
 464                         idedisk_check_hpa(drive);
 465         } else {
 466                 /* drive speaks boring old 28-bit CHS */
 467                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
 468         }
 469 }
 470
 471 static sector_t idedisk_capacity(ide_drive_t *drive)
 472 {
 473         return drive->capacity64;
 474 }
 475
 476 #ifdef CONFIG_IDE_PROC_FS
 477 static int smart_enable(ide_drive_t *drive)
 478 {
 479         ide_task_t args;
 480         struct ide_taskfile *tf = &args.tf;
 481
 482         memset(&args, 0, sizeof(ide_task_t));
 483         tf->feature = ATA_SMART_ENABLE;
 484         tf->lbam    = ATA_SMART_LBAM_PASS;
 485         tf->lbah    = ATA_SMART_LBAH_PASS;
 486         tf->command = ATA_CMD_SMART;
 487         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 488         return ide_no_data_taskfile(drive, &args);
 489 }
 490
 491 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 492 {
 493         ide_task_t args;
 494         struct ide_taskfile *tf = &args.tf;
 495
 496         memset(&args, 0, sizeof(ide_task_t));
 497         tf->feature = sub_cmd;
 498         tf->nsect   = 0x01;
 499         tf->lbam    = ATA_SMART_LBAM_PASS;
 500         tf->lbah    = ATA_SMART_LBAH_PASS;
 501         tf->command = ATA_CMD_SMART;
 502         args.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 503         args.data_phase = TASKFILE_IN;
 504         (void) smart_enable(drive);
 505         return ide_raw_taskfile(drive, &args, buf, 1);
 506 }
 507
 508 static int proc_idedisk_read_cache
 509         (char *page, char **start, off_t off, int count, int *eof, void *data)
 510 {
 511         ide_drive_t     *drive = (ide_drive_t *) data;
 512         char            *out = page;
 513         int             len;
 514
 515         if (drive->id_read)
 516                 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
 517         else
 518                 len = sprintf(out, "(none)\n");
 519
 520         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 521 }
 522
 523 static int proc_idedisk_read_capacity
 524         (char *page, char **start, off_t off, int count, int *eof, void *data)
 525 {
 526         ide_drive_t*drive = (ide_drive_t *)data;
 527         int len;
 528
 529         len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
 530
 531         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 532 }
 533
 534 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
 535                                    int count, int *eof, void *data, u8 sub_cmd)
 536 {
 537         ide_drive_t     *drive = (ide_drive_t *)data;
 538         int             len = 0, i = 0;
 539
 540         if (get_smart_data(drive, page, sub_cmd) == 0) {
 541                 unsigned short *val = (unsigned short *) page;
 542                 char *out = (char *)val + SECTOR_SIZE;
 543
 544                 page = out;
 545                 do {
 546                         out += sprintf(out, "%04x%c", le16_to_cpu(*val),
 547                                        (++i & 7) ? ' ' : '\n');
 548                         val += 1;
 549                 } while (i < SECTOR_SIZE / 2);
 550                 len = out - page;
 551         }
 552
 553         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 554 }
 555
 556 static int proc_idedisk_read_sv
 557         (char *page, char **start, off_t off, int count, int *eof, void *data)
 558 {
 559         return proc_idedisk_read_smart(page, start, off, count, eof, data,
 560                                        ATA_SMART_READ_VALUES);
 561 }
 562
 563 static int proc_idedisk_read_st
 564         (char *page, char **start, off_t off, int count, int *eof, void *data)
 565 {
 566         return proc_idedisk_read_smart(page, start, off, count, eof, data,
 567                                        ATA_SMART_READ_THRESHOLDS);
 568 }
 569
 570 static ide_proc_entry_t idedisk_proc[] = {
 571         { "cache",        S_IFREG|S_IRUGO, proc_idedisk_read_cache,    NULL },
 572         { "capacity",     S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
 573         { "geometry",     S_IFREG|S_IRUGO, proc_ide_read_geometry,     NULL },
 574         { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv,       NULL },
 575         { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st,   NULL },
 576         { NULL, 0, NULL, NULL }
 577 };
 578 #endif  /* CONFIG_IDE_PROC_FS */
 579
 580 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 581 {
 582         ide_drive_t *drive = q->queuedata;
 583         ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
 584
 585         /* FIXME: map struct ide_taskfile on rq->cmd[] */
 586         BUG_ON(task == NULL);
 587
 588         memset(task, 0, sizeof(*task));
 589         if (ide_id_has_flush_cache_ext(drive->id) &&
 590             (drive->capacity64 >= (1UL << 28)))
 591                 task->tf.command = ATA_CMD_FLUSH_EXT;
 592         else
 593                 task->tf.command = ATA_CMD_FLUSH;
 594         task->tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
 595                            IDE_TFLAG_DYN;
 596         task->data_phase = TASKFILE_NO_DATA;
 597
 598         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
 599         rq->cmd_flags |= REQ_SOFTBARRIER;
 600         rq->special = task;
 601 }
 602
 603 ide_devset_get(multcount, mult_count);
 604
 605 /*
 606  * This is tightly woven into the driver->do_special can not touch.
 607  * DON'T do it again until a total personality rewrite is committed.
 608  */
 609 static int set_multcount(ide_drive_t *drive, int arg)
 610 {
 611         struct request *rq;
 612         int error;
 613
 614         if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
 615                 return -EINVAL;
 616
 617         if (drive->special.b.set_multmode)
 618                 return -EBUSY;
 619
 620         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
 621         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
 622
 623         drive->mult_req = arg;
 624         drive->special.b.set_multmode = 1;
 625         error = blk_execute_rq(drive->queue, NULL, rq, 0);
 626         blk_put_request(rq);
 627
 628         return (drive->mult_count == arg) ? 0 : -EIO;
 629 }
 630
 631 ide_devset_get(nowerr, nowerr);
 632
 633 static int set_nowerr(ide_drive_t *drive, int arg)
 634 {
 635         if (arg < 0 || arg > 1)
 636                 return -EINVAL;
 637
 638         if (ide_spin_wait_hwgroup(drive))
 639                 return -EBUSY;
 640         drive->nowerr = arg;
 641         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
 642         spin_unlock_irq(&ide_lock);
 643         return 0;
 644 }
 645
 646 static void update_ordered(ide_drive_t *drive)
 647 {
 648         u16 *id = drive->id;
 649         unsigned ordered = QUEUE_ORDERED_NONE;
 650         prepare_flush_fn *prep_fn = NULL;
 651
 652         if (drive->wcache) {
 653                 unsigned long long capacity;
 654                 int barrier;
 655                 /*
 656                  * We must avoid issuing commands a drive does not
 657                  * understand or we may crash it. We check flush cache
 658                  * is supported. We also check we have the LBA48 flush
 659                  * cache if the drive capacity is too large. By this
 660                  * time we have trimmed the drive capacity if LBA48 is
 661                  * not available so we don't need to recheck that.
 662                  */
 663                 capacity = idedisk_capacity(drive);
 664                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
 665                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
 666                          ide_id_has_flush_cache_ext(id));
 667
 668                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
 669                        drive->name, barrier ? "" : "not ");
 670
 671                 if (barrier) {
 672                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
 673                         prep_fn = idedisk_prepare_flush;
 674                 }
 675         } else
 676                 ordered = QUEUE_ORDERED_DRAIN;
 677
 678         blk_queue_ordered(drive->queue, ordered, prep_fn);
 679 }
 680
 681 ide_devset_get(wcache, wcache);
 682
 683 static int set_wcache(ide_drive_t *drive, int arg)
 684 {
 685         ide_task_t args;
 686         int err = 1;
 687
 688         if (arg < 0 || arg > 1)
 689                 return -EINVAL;
 690
 691         if (ide_id_has_flush_cache(drive->id)) {
 692                 memset(&args, 0, sizeof(ide_task_t));
 693                 args.tf.feature = arg ?
 694                         SETFEATURES_WC_ON : SETFEATURES_WC_OFF;
 695                 args.tf.command = ATA_CMD_SET_FEATURES;
 696                 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 697                 err = ide_no_data_taskfile(drive, &args);
 698                 if (err == 0)
 699                         drive->wcache = arg;
 700         }
 701
 702         update_ordered(drive);
 703
 704         return err;
 705 }
 706
 707 static int do_idedisk_flushcache(ide_drive_t *drive)
 708 {
 709         ide_task_t args;
 710
 711         memset(&args, 0, sizeof(ide_task_t));
 712         if (ide_id_has_flush_cache_ext(drive->id))
 713                 args.tf.command = ATA_CMD_FLUSH_EXT;
 714         else
 715                 args.tf.command = ATA_CMD_FLUSH;
 716         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 717         return ide_no_data_taskfile(drive, &args);
 718 }
 719
 720 ide_devset_get(acoustic, acoustic);
 721
 722 static int set_acoustic(ide_drive_t *drive, int arg)
 723 {
 724         ide_task_t args;
 725
 726         if (arg < 0 || arg > 254)
 727                 return -EINVAL;
 728
 729         memset(&args, 0, sizeof(ide_task_t));
 730         args.tf.feature = arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF;
 731         args.tf.nsect   = arg;
 732         args.tf.command = ATA_CMD_SET_FEATURES;
 733         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 734         ide_no_data_taskfile(drive, &args);
 735         drive->acoustic = arg;
 736         return 0;
 737 }
 738
 739 ide_devset_get(lba_addressing, addressing);
 740
 741 /*
 742  * drive->addressing:
 743  *      0: 28-bit
 744  *      1: 48-bit
 745  *      2: 48-bit capable doing 28-bit
 746  */
 747 static int set_lba_addressing(ide_drive_t *drive, int arg)
 748 {
 749         if (arg < 0 || arg > 2)
 750                 return -EINVAL;
 751
 752         drive->addressing =  0;
 753
 754         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
 755                 return 0;
 756
 757         if (!idedisk_supports_lba48(drive->id))
 758                 return -EIO;
 759         drive->addressing = arg;
 760         return 0;
 761 }
 762
 763 #ifdef CONFIG_IDE_PROC_FS
 764 ide_devset_rw_nolock(acoustic,  0, 254, acoustic);
 765 ide_devset_rw_nolock(address,   0,   2, lba_addressing);
 766 ide_devset_rw_nolock(multcount, 0,  16, multcount);
 767 ide_devset_rw_nolock(nowerr,    0,   1, nowerr);
 768 ide_devset_rw_nolock(wcache,    0,   1, wcache);
 769
 770 ide_devset_rw(bios_cyl,         0, 65535, bios_cyl);
 771 ide_devset_rw(bios_head,        0,   255, bios_head);
 772 ide_devset_rw(bios_sect,        0,    63, bios_sect);
 773 ide_devset_rw(failures,         0, 65535, failures);
 774 ide_devset_rw(lun,              0,     7, lun);
 775 ide_devset_rw(max_failures,     0, 65535, max_failures);
 776
 777 static const struct ide_devset *idedisk_settings[] = {
 778         &ide_devset_acoustic,
 779         &ide_devset_address,
 780         &ide_devset_bios_cyl,
 781         &ide_devset_bios_head,
 782         &ide_devset_bios_sect,
 783         &ide_devset_failures,
 784         &ide_devset_lun,
 785         &ide_devset_max_failures,
 786         &ide_devset_multcount,
 787         &ide_devset_nowerr,
 788         &ide_devset_wcache,
 789         NULL
 790 };
 791 #endif
 792
 793 static void idedisk_setup(ide_drive_t *drive)
 794 {
 795         struct ide_disk_obj *idkp = drive->driver_data;
 796         ide_hwif_t *hwif = drive->hwif;
 797         u16 *id = drive->id;
 798         char *m = (char *)&id[ATA_ID_PROD];
 799         unsigned long long capacity;
 800
 801         ide_proc_register_driver(drive, idkp->driver);
 802
 803         if (drive->id_read == 0)
 804                 return;
 805
 806         if (drive->removable) {
 807                 /*
 808                  * Removable disks (eg. SYQUEST); ignore 'WD' drives
 809                  */
 810                 if (m[0] != 'W' || m[1] != 'D')
 811                         drive->doorlocking = 1;
 812         }
 813
 814         (void)set_lba_addressing(drive, 1);
 815
 816         if (drive->addressing == 1) {
 817                 int max_s = 2048;
 818
 819                 if (max_s > hwif->rqsize)
 820                         max_s = hwif->rqsize;
 821
 822                 blk_queue_max_sectors(drive->queue, max_s);
 823         }
 824
 825         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
 826                          drive->queue->max_sectors / 2);
 827
 828         /* calculate drive capacity, and select LBA if possible */
 829         init_idedisk_capacity(drive);
 830
 831         /* limit drive capacity to 137GB if LBA48 cannot be used */
 832         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
 833                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
 834                        "%llu sectors (%llu MB)\n",
 835                        drive->name, (unsigned long long)drive->capacity64,
 836                        sectors_to_MB(drive->capacity64));
 837                 drive->capacity64 = 1ULL << 28;
 838         }
 839
 840         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
 841                 if (drive->capacity64 > 1ULL << 28) {
 842                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
 843                                          " will be used for accessing sectors "
 844                                          "> %u\n", drive->name, 1 << 28);
 845                 } else
 846                         drive->addressing = 0;
 847         }
 848
 849         /*
 850          * if possible, give fdisk access to more of the drive,
 851          * by correcting bios_cyls:
 852          */
 853         capacity = idedisk_capacity(drive);
 854
 855         if (!drive->forced_geom) {
 856
 857                 if (idedisk_supports_lba48(drive->id)) {
 858                         /* compatibility */
 859                         drive->bios_sect = 63;
 860                         drive->bios_head = 255;
 861                 }
 862
 863                 if (drive->bios_sect && drive->bios_head) {
 864                         unsigned int cap0 = capacity; /* truncate to 32 bits */
 865                         unsigned int cylsz, cyl;
 866
 867                         if (cap0 != capacity)
 868                                 drive->bios_cyl = 65535;
 869                         else {
 870                                 cylsz = drive->bios_sect * drive->bios_head;
 871                                 cyl = cap0 / cylsz;
 872                                 if (cyl > 65535)
 873                                         cyl = 65535;
 874                                 if (cyl > drive->bios_cyl)
 875                                         drive->bios_cyl = cyl;
 876                         }
 877                 }
 878         }
 879         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
 880                          drive->name, capacity, sectors_to_MB(capacity));
 881
 882         /* Only print cache size when it was specified */
 883         if (id[ATA_ID_BUF_SIZE])
 884                 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
 885
 886         printk(KERN_CONT ", CHS=%d/%d/%d\n",
 887                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
 888
 889         /* write cache enabled? */
 890         if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
 891                 drive->wcache = 1;
 892
 893         set_wcache(drive, 1);
 894 }
 895
 896 static void ide_cacheflush_p(ide_drive_t *drive)
 897 {
 898         if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
 899                 return;
 900
 901         if (do_idedisk_flushcache(drive))
 902                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 903 }
 904
 905 static void ide_disk_remove(ide_drive_t *drive)
 906 {
 907         struct ide_disk_obj *idkp = drive->driver_data;
 908         struct gendisk *g = idkp->disk;
 909
 910         ide_proc_unregister_driver(drive, idkp->driver);
 911
 912         del_gendisk(g);
 913
 914         ide_cacheflush_p(drive);
 915
 916         ide_disk_put(idkp);
 917 }
 918
 919 static void ide_disk_release(struct kref *kref)
 920 {
 921         struct ide_disk_obj *idkp = to_ide_disk(kref);
 922         ide_drive_t *drive = idkp->drive;
 923         struct gendisk *g = idkp->disk;
 924
 925         drive->driver_data = NULL;
 926         g->private_data = NULL;
 927         put_disk(g);
 928         kfree(idkp);
 929 }
 930
 931 static int ide_disk_probe(ide_drive_t *drive);
 932
 933 /*
 934  * On HPA drives the capacity needs to be
 935  * reinitilized on resume otherwise the disk
 936  * can not be used and a hard reset is required
 937  */
 938 static void ide_disk_resume(ide_drive_t *drive)
 939 {
 940         if (ata_id_hpa_enabled(drive->id))
 941                 init_idedisk_capacity(drive);
 942 }
 943
 944 static void ide_device_shutdown(ide_drive_t *drive)
 945 {
 946 #ifdef  CONFIG_ALPHA
 947         /* On Alpha, halt(8) doesn't actually turn the machine off,
 948            it puts you into the sort of firmware monitor. Typically,
 949            it's used to boot another kernel image, so it's not much
 950            different from reboot(8). Therefore, we don't need to
 951            spin down the disk in this case, especially since Alpha
 952            firmware doesn't handle disks in standby mode properly.
 953            On the other hand, it's reasonably safe to turn the power
 954            off when the shutdown process reaches the firmware prompt,
 955            as the firmware initialization takes rather long time -
 956            at least 10 seconds, which should be sufficient for
 957            the disk to expire its write cache. */
 958         if (system_state != SYSTEM_POWER_OFF) {
 959 #else
 960         if (system_state == SYSTEM_RESTART) {
 961 #endif
 962                 ide_cacheflush_p(drive);
 963                 return;
 964         }
 965
 966         printk(KERN_INFO "Shutdown: %s\n", drive->name);
 967
 968         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
 969 }
 970
 971 static ide_driver_t idedisk_driver = {
 972         .gen_driver = {
 973                 .owner          = THIS_MODULE,
 974                 .name           = "ide-disk",
 975                 .bus            = &ide_bus_type,
 976         },
 977         .probe                  = ide_disk_probe,
 978         .remove                 = ide_disk_remove,
 979         .resume                 = ide_disk_resume,
 980         .shutdown               = ide_device_shutdown,
 981         .version                = IDEDISK_VERSION,
 982         .media                  = ide_disk,
 983         .supports_dsc_overlap   = 0,
 984         .do_request             = ide_do_rw_disk,
 985         .end_request            = ide_end_request,
 986         .error                  = __ide_error,
 987 #ifdef CONFIG_IDE_PROC_FS
 988         .proc                   = idedisk_proc,
 989         .settings               = idedisk_settings,
 990 #endif
 991 };
 992
 993 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
 994 {
 995         ide_task_t task;
 996
 997         memset(&task, 0, sizeof(task));
 998         task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
 999         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
1000
1001         return ide_no_data_taskfile(drive, &task);
1002 }
1003
1004 static int idedisk_open(struct inode *inode, struct file *filp)
1005 {
1006         struct gendisk *disk = inode->i_bdev->bd_disk;
1007         struct ide_disk_obj *idkp;
1008         ide_drive_t *drive;
1009
1010         idkp = ide_disk_get(disk);
1011         if (idkp == NULL)
1012                 return -ENXIO;
1013
1014         drive = idkp->drive;
1015
1016         idkp->openers++;
1017
1018         if (drive->removable && idkp->openers == 1) {
1019                 check_disk_change(inode->i_bdev);
1020                 /*
1021                  * Ignore the return code from door_lock,
1022                  * since the open() has already succeeded,
1023                  * and the door_lock is irrelevant at this point.
1024                  */
1025                 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1026                         drive->doorlocking = 0;
1027         }
1028         return 0;
1029 }
1030
1031 static int idedisk_release(struct inode *inode, struct file *filp)
1032 {
1033         struct gendisk *disk = inode->i_bdev->bd_disk;
1034         struct ide_disk_obj *idkp = ide_disk_g(disk);
1035         ide_drive_t *drive = idkp->drive;
1036
1037         if (idkp->openers == 1)
1038                 ide_cacheflush_p(drive);
1039
1040         if (drive->removable && idkp->openers == 1) {
1041                 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1042                         drive->doorlocking = 0;
1043         }
1044
1045         idkp->openers--;
1046
1047         ide_disk_put(idkp);
1048
1049         return 0;
1050 }
1051
1052 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1053 {
1054         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1055         ide_drive_t *drive = idkp->drive;
1056
1057         geo->heads = drive->bios_head;
1058         geo->sectors = drive->bios_sect;
1059         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1060         return 0;
1061 }
1062
1063 static int idedisk_ioctl(struct inode *inode, struct file *file,
1064                         unsigned int cmd, unsigned long arg)
1065 {
1066         unsigned long flags;
1067         struct block_device *bdev = inode->i_bdev;
1068         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1069         ide_drive_t *drive = idkp->drive;
1070         int err, (*getfunc)(ide_drive_t *), (*setfunc)(ide_drive_t *, int);
1071
1072         switch (cmd) {
1073         case HDIO_GET_ADDRESS:   getfunc = get_lba_addressing;  goto read_val;
1074         case HDIO_GET_MULTCOUNT: getfunc = get_multcount;       goto read_val;
1075         case HDIO_GET_NOWERR:    getfunc = get_nowerr;          goto read_val;
1076         case HDIO_GET_WCACHE:    getfunc = get_wcache;          goto read_val;
1077         case HDIO_GET_ACOUSTIC:  getfunc = get_acoustic;        goto read_val;
1078         case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
1079         case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
1080         case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
1081         case HDIO_SET_WCACHE:    setfunc = set_wcache;          goto set_val;
1082         case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
1083         }
1084
1085         return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1086
1087 read_val:
1088         mutex_lock(&ide_setting_mtx);
1089         spin_lock_irqsave(&ide_lock, flags);
1090         err = getfunc(drive);
1091         spin_unlock_irqrestore(&ide_lock, flags);
1092         mutex_unlock(&ide_setting_mtx);
1093         return err >= 0 ? put_user(err, (long __user *)arg) : err;
1094
1095 set_val:
1096         if (bdev != bdev->bd_contains)
1097                 err = -EINVAL;
1098         else {
1099                 if (!capable(CAP_SYS_ADMIN))
1100                         err = -EACCES;
1101                 else {
1102                         mutex_lock(&ide_setting_mtx);
1103                         err = setfunc(drive, arg);
1104                         mutex_unlock(&ide_setting_mtx);
1105                 }
1106         }
1107         return err;
1108 }
1109
1110 static int idedisk_media_changed(struct gendisk *disk)
1111 {
1112         struct ide_disk_obj *idkp = ide_disk_g(disk);
1113         ide_drive_t *drive = idkp->drive;
1114
1115         /* do not scan partitions twice if this is a removable device */
1116         if (drive->attach) {
1117                 drive->attach = 0;
1118                 return 0;
1119         }
1120         /* if removable, always assume it was changed */
1121         return drive->removable;
1122 }
1123
1124 static int idedisk_revalidate_disk(struct gendisk *disk)
1125 {
1126         struct ide_disk_obj *idkp = ide_disk_g(disk);
1127         set_capacity(disk, idedisk_capacity(idkp->drive));
1128         return 0;
1129 }
1130
1131 static struct block_device_operations idedisk_ops = {
1132         .owner                  = THIS_MODULE,
1133         .open                   = idedisk_open,
1134         .release                = idedisk_release,
1135         .ioctl                  = idedisk_ioctl,
1136         .getgeo                 = idedisk_getgeo,
1137         .media_changed          = idedisk_media_changed,
1138         .revalidate_disk        = idedisk_revalidate_disk
1139 };
1140
1141 MODULE_DESCRIPTION("ATA DISK Driver");
1142
1143 static int ide_disk_probe(ide_drive_t *drive)
1144 {
1145         struct ide_disk_obj *idkp;
1146         struct gendisk *g;
1147
1148         /* strstr("foo", "") is non-NULL */
1149         if (!strstr("ide-disk", drive->driver_req))
1150                 goto failed;
1151
1152         if (drive->media != ide_disk)
1153                 goto failed;
1154
1155         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1156         if (!idkp)
1157                 goto failed;
1158
1159         g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1160         if (!g)
1161                 goto out_free_idkp;
1162
1163         ide_init_disk(g, drive);
1164
1165         kref_init(&idkp->kref);
1166
1167         idkp->drive = drive;
1168         idkp->driver = &idedisk_driver;
1169         idkp->disk = g;
1170
1171         g->private_data = &idkp->driver;
1172
1173         drive->driver_data = idkp;
1174
1175         idedisk_setup(drive);
1176         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1177                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1178                         drive->name, drive->head);
1179                 drive->attach = 0;
1180         } else
1181                 drive->attach = 1;
1182
1183         g->minors = IDE_DISK_MINORS;
1184         g->driverfs_dev = &drive->gendev;
1185         g->flags |= GENHD_FL_EXT_DEVT;
1186         if (drive->removable)
1187                 g->flags |= GENHD_FL_REMOVABLE;
1188         set_capacity(g, idedisk_capacity(drive));
1189         g->fops = &idedisk_ops;
1190         add_disk(g);
1191         return 0;
1192
1193 out_free_idkp:
1194         kfree(idkp);
1195 failed:
1196         return -ENODEV;
1197 }
1198
1199 static void __exit idedisk_exit(void)
1200 {
1201         driver_unregister(&idedisk_driver.gen_driver);
1202 }
1203
1204 static int __init idedisk_init(void)
1205 {
1206         return driver_register(&idedisk_driver.gen_driver);
1207 }
1208
1209 MODULE_ALIAS("ide:*m-disk*");
1210 module_init(idedisk_init);
1211 module_exit(idedisk_exit);
1212 MODULE_LICENSE("GPL");