git.oblomov.eu Git - linux-2.6/blob - drivers/ide/ide-disk.c

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