Pileus Git - ~andy/linux/blob - drivers/ide/ide-disk.c

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