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         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 307         args.handler                            = &task_no_data_intr;
 308         /* submit command request */
 309         ide_raw_taskfile(drive, &args, NULL);
 310
 311         /* if OK, compute maximum address value */
 312         if ((tf->status & 0x01) == 0) {
 313                 u32 high, low;
 314
 315                 if (lba48)
 316                         high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
 317                                 tf->hob_lbal;
 318                 else
 319                         high = tf->device & 0xf;
 320                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 321                 addr = ((__u64)high << 24) | low;
 322                 addr++; /* since the return value is (maxlba - 1), we add 1 */
 323         }
 324         return addr;
 325 }
 326
 327 /*
 328  * Sets maximum virtual LBA address of the drive.
 329  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
 330  */
 331 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
 332 {
 333         ide_task_t args;
 334         struct ide_taskfile *tf = &args.tf;
 335         u64 addr_set = 0;
 336
 337         addr_req--;
 338         /* Create IDE/ATA command request structure */
 339         memset(&args, 0, sizeof(ide_task_t));
 340         tf->lbal     = (addr_req >>  0) & 0xff;
 341         tf->lbam     = (addr_req >>= 8) & 0xff;
 342         tf->lbah     = (addr_req >>= 8) & 0xff;
 343         if (lba48) {
 344                 tf->hob_lbal = (addr_req >>= 8) & 0xff;
 345                 tf->hob_lbam = (addr_req >>= 8) & 0xff;
 346                 tf->hob_lbah = (addr_req >>= 8) & 0xff;
 347                 tf->command  = WIN_SET_MAX_EXT;
 348         } else {
 349                 tf->device   = (addr_req >>= 8) & 0x0f;
 350                 tf->command  = WIN_SET_MAX;
 351         }
 352         tf->device |= ATA_LBA;
 353         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 354         args.handler                            = &task_no_data_intr;
 355         /* submit command request */
 356         ide_raw_taskfile(drive, &args, NULL);
 357         /* if OK, compute maximum address value */
 358         if ((tf->status & 0x01) == 0) {
 359                 u32 high, low;
 360
 361                 if (lba48)
 362                         high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
 363                                 tf->hob_lbal;
 364                 else
 365                         high = tf->device & 0xf;
 366                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
 367                 addr_set = ((__u64)high << 24) | low;
 368                 addr_set++;
 369         }
 370         return addr_set;
 371 }
 372
 373 static unsigned long long sectors_to_MB(unsigned long long n)
 374 {
 375         n <<= 9;                /* make it bytes */
 376         do_div(n, 1000000);     /* make it MB */
 377         return n;
 378 }
 379
 380 /*
 381  * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
 382  * so on non-buggy drives we need test only one.
 383  * However, we should also check whether these fields are valid.
 384  */
 385 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
 386 {
 387         return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
 388 }
 389
 390 /*
 391  * The same here.
 392  */
 393 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
 394 {
 395         return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
 396                && id->lba_capacity_2;
 397 }
 398
 399 /*
 400  * Some disks report total number of sectors instead of
 401  * maximum sector address.  We list them here.
 402  */
 403 static const struct drive_list_entry hpa_list[] = {
 404         { "ST340823A",  NULL },
 405         { "ST320413A",  NULL },
 406         { NULL,         NULL }
 407 };
 408
 409 static void idedisk_check_hpa(ide_drive_t *drive)
 410 {
 411         unsigned long long capacity, set_max;
 412         int lba48 = idedisk_supports_lba48(drive->id);
 413
 414         capacity = drive->capacity64;
 415
 416         set_max = idedisk_read_native_max_address(drive, lba48);
 417
 418         if (ide_in_drive_list(drive->id, hpa_list)) {
 419                 /*
 420                  * Since we are inclusive wrt to firmware revisions do this
 421                  * extra check and apply the workaround only when needed.
 422                  */
 423                 if (set_max == capacity + 1)
 424                         set_max--;
 425         }
 426
 427         if (set_max <= capacity)
 428                 return;
 429
 430         printk(KERN_INFO "%s: Host Protected Area detected.\n"
 431                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
 432                          "\tnative  capacity is %llu sectors (%llu MB)\n",
 433                          drive->name,
 434                          capacity, sectors_to_MB(capacity),
 435                          set_max, sectors_to_MB(set_max));
 436
 437         set_max = idedisk_set_max_address(drive, set_max, lba48);
 438
 439         if (set_max) {
 440                 drive->capacity64 = set_max;
 441                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
 442                                  drive->name);
 443         }
 444 }
 445
 446 /*
 447  * Compute drive->capacity, the full capacity of the drive
 448  * Called with drive->id != NULL.
 449  *
 450  * To compute capacity, this uses either of
 451  *
 452  *    1. CHS value set by user       (whatever user sets will be trusted)
 453  *    2. LBA value from target drive (require new ATA feature)
 454  *    3. LBA value from system BIOS  (new one is OK, old one may break)
 455  *    4. CHS value from system BIOS  (traditional style)
 456  *
 457  * in above order (i.e., if value of higher priority is available,
 458  * reset will be ignored).
 459  */
 460 static void init_idedisk_capacity (ide_drive_t  *drive)
 461 {
 462         struct hd_driveid *id = drive->id;
 463         /*
 464          * If this drive supports the Host Protected Area feature set,
 465          * then we may need to change our opinion about the drive's capacity.
 466          */
 467         int hpa = idedisk_supports_hpa(id);
 468
 469         if (idedisk_supports_lba48(id)) {
 470                 /* drive speaks 48-bit LBA */
 471                 drive->select.b.lba = 1;
 472                 drive->capacity64 = id->lba_capacity_2;
 473                 if (hpa)
 474                         idedisk_check_hpa(drive);
 475         } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
 476                 /* drive speaks 28-bit LBA */
 477                 drive->select.b.lba = 1;
 478                 drive->capacity64 = id->lba_capacity;
 479                 if (hpa)
 480                         idedisk_check_hpa(drive);
 481         } else {
 482                 /* drive speaks boring old 28-bit CHS */
 483                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
 484         }
 485 }
 486
 487 static sector_t idedisk_capacity (ide_drive_t *drive)
 488 {
 489         return drive->capacity64 - drive->sect0;
 490 }
 491
 492 #ifdef CONFIG_IDE_PROC_FS
 493 static int smart_enable(ide_drive_t *drive)
 494 {
 495         ide_task_t args;
 496         struct ide_taskfile *tf = &args.tf;
 497
 498         memset(&args, 0, sizeof(ide_task_t));
 499         tf->feature = SMART_ENABLE;
 500         tf->lbam    = SMART_LCYL_PASS;
 501         tf->lbah    = SMART_HCYL_PASS;
 502         tf->command = WIN_SMART;
 503         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 504         args.handler                            = &task_no_data_intr;
 505         return ide_raw_taskfile(drive, &args, NULL);
 506 }
 507
 508 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 509 {
 510         ide_task_t args;
 511         struct ide_taskfile *tf = &args.tf;
 512
 513         memset(&args, 0, sizeof(ide_task_t));
 514         tf->feature = sub_cmd;
 515         tf->nsect   = 0x01;
 516         tf->lbam    = SMART_LCYL_PASS;
 517         tf->lbah    = SMART_HCYL_PASS;
 518         tf->command = WIN_SMART;
 519         args.command_type                       = IDE_DRIVE_TASK_IN;
 520         args.data_phase                         = TASKFILE_IN;
 521         args.handler                            = &task_in_intr;
 522         (void) smart_enable(drive);
 523         return ide_raw_taskfile(drive, &args, buf);
 524 }
 525
 526 static int proc_idedisk_read_cache
 527         (char *page, char **start, off_t off, int count, int *eof, void *data)
 528 {
 529         ide_drive_t     *drive = (ide_drive_t *) data;
 530         char            *out = page;
 531         int             len;
 532
 533         if (drive->id_read)
 534                 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
 535         else
 536                 len = sprintf(out,"(none)\n");
 537         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 538 }
 539
 540 static int proc_idedisk_read_capacity
 541         (char *page, char **start, off_t off, int count, int *eof, void *data)
 542 {
 543         ide_drive_t*drive = (ide_drive_t *)data;
 544         int len;
 545
 546         len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
 547         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 548 }
 549
 550 static int proc_idedisk_read_smart_thresholds
 551         (char *page, char **start, off_t off, int count, int *eof, void *data)
 552 {
 553         ide_drive_t     *drive = (ide_drive_t *)data;
 554         int             len = 0, i = 0;
 555
 556         if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
 557                 unsigned short *val = (unsigned short *) page;
 558                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 559                 page = out;
 560                 do {
 561                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 562                         val += 1;
 563                 } while (i < (SECTOR_WORDS * 2));
 564                 len = out - page;
 565         }
 566         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 567 }
 568
 569 static int proc_idedisk_read_smart_values
 570         (char *page, char **start, off_t off, int count, int *eof, void *data)
 571 {
 572         ide_drive_t     *drive = (ide_drive_t *)data;
 573         int             len = 0, i = 0;
 574
 575         if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
 576                 unsigned short *val = (unsigned short *) page;
 577                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
 578                 page = out;
 579                 do {
 580                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 581                         val += 1;
 582                 } while (i < (SECTOR_WORDS * 2));
 583                 len = out - page;
 584         }
 585         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 586 }
 587
 588 static ide_proc_entry_t idedisk_proc[] = {
 589         { "cache",              S_IFREG|S_IRUGO,        proc_idedisk_read_cache,                NULL },
 590         { "capacity",           S_IFREG|S_IRUGO,        proc_idedisk_read_capacity,             NULL },
 591         { "geometry",           S_IFREG|S_IRUGO,        proc_ide_read_geometry,                 NULL },
 592         { "smart_values",       S_IFREG|S_IRUSR,        proc_idedisk_read_smart_values,         NULL },
 593         { "smart_thresholds",   S_IFREG|S_IRUSR,        proc_idedisk_read_smart_thresholds,     NULL },
 594         { NULL, 0, NULL, NULL }
 595 };
 596 #endif  /* CONFIG_IDE_PROC_FS */
 597
 598 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 599 {
 600         ide_drive_t *drive = q->queuedata;
 601
 602         memset(rq->cmd, 0, sizeof(rq->cmd));
 603
 604         if (ide_id_has_flush_cache_ext(drive->id) &&
 605             (drive->capacity64 >= (1UL << 28)))
 606                 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
 607         else
 608                 rq->cmd[0] = WIN_FLUSH_CACHE;
 609
 610
 611         rq->cmd_type = REQ_TYPE_ATA_TASK;
 612         rq->cmd_flags |= REQ_SOFTBARRIER;
 613         rq->buffer = rq->cmd;
 614 }
 615
 616 /*
 617  * This is tightly woven into the driver->do_special can not touch.
 618  * DON'T do it again until a total personality rewrite is committed.
 619  */
 620 static int set_multcount(ide_drive_t *drive, int arg)
 621 {
 622         struct request rq;
 623
 624         if (arg < 0 || arg > drive->id->max_multsect)
 625                 return -EINVAL;
 626
 627         if (drive->special.b.set_multmode)
 628                 return -EBUSY;
 629         ide_init_drive_cmd (&rq);
 630         rq.cmd_type = REQ_TYPE_ATA_CMD;
 631         drive->mult_req = arg;
 632         drive->special.b.set_multmode = 1;
 633         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
 634         return (drive->mult_count == arg) ? 0 : -EIO;
 635 }
 636
 637 static int set_nowerr(ide_drive_t *drive, int arg)
 638 {
 639         if (arg < 0 || arg > 1)
 640                 return -EINVAL;
 641
 642         if (ide_spin_wait_hwgroup(drive))
 643                 return -EBUSY;
 644         drive->nowerr = arg;
 645         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
 646         spin_unlock_irq(&ide_lock);
 647         return 0;
 648 }
 649
 650 static void update_ordered(ide_drive_t *drive)
 651 {
 652         struct hd_driveid *id = drive->id;
 653         unsigned ordered = QUEUE_ORDERED_NONE;
 654         prepare_flush_fn *prep_fn = NULL;
 655
 656         if (drive->wcache) {
 657                 unsigned long long capacity;
 658                 int barrier;
 659                 /*
 660                  * We must avoid issuing commands a drive does not
 661                  * understand or we may crash it. We check flush cache
 662                  * is supported. We also check we have the LBA48 flush
 663                  * cache if the drive capacity is too large. By this
 664                  * time we have trimmed the drive capacity if LBA48 is
 665                  * not available so we don't need to recheck that.
 666                  */
 667                 capacity = idedisk_capacity(drive);
 668                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
 669                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
 670                          ide_id_has_flush_cache_ext(id));
 671
 672                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
 673                        drive->name, barrier ? "" : "not ");
 674
 675                 if (barrier) {
 676                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
 677                         prep_fn = idedisk_prepare_flush;
 678                 }
 679         } else
 680                 ordered = QUEUE_ORDERED_DRAIN;
 681
 682         blk_queue_ordered(drive->queue, ordered, prep_fn);
 683 }
 684
 685 static int write_cache(ide_drive_t *drive, int arg)
 686 {
 687         ide_task_t args;
 688         int err = 1;
 689
 690         if (arg < 0 || arg > 1)
 691                 return -EINVAL;
 692
 693         if (ide_id_has_flush_cache(drive->id)) {
 694                 memset(&args, 0, sizeof(ide_task_t));
 695                 args.tf.feature = arg ?
 696                         SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
 697                 args.tf.command = WIN_SETFEATURES;
 698                 args.command_type               = IDE_DRIVE_TASK_NO_DATA;
 699                 args.handler                    = &task_no_data_intr;
 700                 err = ide_raw_taskfile(drive, &args, NULL);
 701                 if (err == 0)
 702                         drive->wcache = arg;
 703         }
 704
 705         update_ordered(drive);
 706
 707         return err;
 708 }
 709
 710 static int do_idedisk_flushcache (ide_drive_t *drive)
 711 {
 712         ide_task_t args;
 713
 714         memset(&args, 0, sizeof(ide_task_t));
 715         if (ide_id_has_flush_cache_ext(drive->id))
 716                 args.tf.command = WIN_FLUSH_CACHE_EXT;
 717         else
 718                 args.tf.command = WIN_FLUSH_CACHE;
 719         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
 720         args.handler                            = &task_no_data_intr;
 721         return ide_raw_taskfile(drive, &args, NULL);
 722 }
 723
 724 static int set_acoustic (ide_drive_t *drive, int arg)
 725 {
 726         ide_task_t args;
 727
 728         if (arg < 0 || arg > 254)
 729                 return -EINVAL;
 730
 731         memset(&args, 0, sizeof(ide_task_t));
 732         args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
 733         args.tf.nsect   = arg;
 734         args.tf.command = WIN_SETFEATURES;
 735         args.command_type = IDE_DRIVE_TASK_NO_DATA;
 736         args.handler      = &task_no_data_intr;
 737         ide_raw_taskfile(drive, &args, NULL);
 738         drive->acoustic = arg;
 739         return 0;
 740 }
 741
 742 /*
 743  * drive->addressing:
 744  *      0: 28-bit
 745  *      1: 48-bit
 746  *      2: 48-bit capable doing 28-bit
 747  */
 748 static int set_lba_addressing(ide_drive_t *drive, int arg)
 749 {
 750         if (arg < 0 || arg > 2)
 751                 return -EINVAL;
 752
 753         drive->addressing =  0;
 754
 755         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
 756                 return 0;
 757
 758         if (!idedisk_supports_lba48(drive->id))
 759                 return -EIO;
 760         drive->addressing = arg;
 761         return 0;
 762 }
 763
 764 #ifdef CONFIG_IDE_PROC_FS
 765 static void idedisk_add_settings(ide_drive_t *drive)
 766 {
 767         struct hd_driveid *id = drive->id;
 768
 769         ide_add_setting(drive,  "bios_cyl",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->bios_cyl,       NULL);
 770         ide_add_setting(drive,  "bios_head",    SETTING_RW,     TYPE_BYTE,      0,      255,                    1,      1,      &drive->bios_head,      NULL);
 771         ide_add_setting(drive,  "bios_sect",    SETTING_RW,     TYPE_BYTE,      0,      63,                     1,      1,      &drive->bios_sect,      NULL);
 772         ide_add_setting(drive,  "address",      SETTING_RW,     TYPE_BYTE,      0,      2,                      1,      1,      &drive->addressing,     set_lba_addressing);
 773         ide_add_setting(drive,  "bswap",        SETTING_READ,   TYPE_BYTE,      0,      1,                      1,      1,      &drive->bswap,          NULL);
 774         ide_add_setting(drive,  "multcount",    SETTING_RW,     TYPE_BYTE,      0,      id->max_multsect,       1,      1,      &drive->mult_count,     set_multcount);
 775         ide_add_setting(drive,  "nowerr",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->nowerr,         set_nowerr);
 776         ide_add_setting(drive,  "lun",          SETTING_RW,     TYPE_INT,       0,      7,                      1,      1,      &drive->lun,            NULL);
 777         ide_add_setting(drive,  "wcache",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->wcache,         write_cache);
 778         ide_add_setting(drive,  "acoustic",     SETTING_RW,     TYPE_BYTE,      0,      254,                    1,      1,      &drive->acoustic,       set_acoustic);
 779         ide_add_setting(drive,  "failures",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->failures,       NULL);
 780         ide_add_setting(drive,  "max_failures", SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->max_failures,   NULL);
 781 }
 782 #else
 783 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
 784 #endif
 785
 786 static void idedisk_setup (ide_drive_t *drive)
 787 {
 788         ide_hwif_t *hwif = drive->hwif;
 789         struct hd_driveid *id = drive->id;
 790         unsigned long long capacity;
 791
 792         idedisk_add_settings(drive);
 793
 794         if (drive->id_read == 0)
 795                 return;
 796
 797         if (drive->removable) {
 798                 /*
 799                  * Removable disks (eg. SYQUEST); ignore 'WD' drives
 800                  */
 801                 if (id->model[0] != 'W' || id->model[1] != 'D') {
 802                         drive->doorlocking = 1;
 803                 }
 804         }
 805
 806         (void)set_lba_addressing(drive, 1);
 807
 808         if (drive->addressing == 1) {
 809                 int max_s = 2048;
 810
 811                 if (max_s > hwif->rqsize)
 812                         max_s = hwif->rqsize;
 813
 814                 blk_queue_max_sectors(drive->queue, max_s);
 815         }
 816
 817         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
 818
 819         /* calculate drive capacity, and select LBA if possible */
 820         init_idedisk_capacity (drive);
 821
 822         /* limit drive capacity to 137GB if LBA48 cannot be used */
 823         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
 824                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
 825                        "%llu sectors (%llu MB)\n",
 826                        drive->name, (unsigned long long)drive->capacity64,
 827                        sectors_to_MB(drive->capacity64));
 828                 drive->capacity64 = 1ULL << 28;
 829         }
 830
 831         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
 832                 if (drive->capacity64 > 1ULL << 28) {
 833                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
 834                                          " be used for accessing sectors > %u\n",
 835                                          drive->name, 1 << 28);
 836                 } else
 837                         drive->addressing = 0;
 838         }
 839
 840         /*
 841          * if possible, give fdisk access to more of the drive,
 842          * by correcting bios_cyls:
 843          */
 844         capacity = idedisk_capacity (drive);
 845         if (!drive->forced_geom) {
 846
 847                 if (idedisk_supports_lba48(drive->id)) {
 848                         /* compatibility */
 849                         drive->bios_sect = 63;
 850                         drive->bios_head = 255;
 851                 }
 852
 853                 if (drive->bios_sect && drive->bios_head) {
 854                         unsigned int cap0 = capacity; /* truncate to 32 bits */
 855                         unsigned int cylsz, cyl;
 856
 857                         if (cap0 != capacity)
 858                                 drive->bios_cyl = 65535;
 859                         else {
 860                                 cylsz = drive->bios_sect * drive->bios_head;
 861                                 cyl = cap0 / cylsz;
 862                                 if (cyl > 65535)
 863                                         cyl = 65535;
 864                                 if (cyl > drive->bios_cyl)
 865                                         drive->bios_cyl = cyl;
 866                         }
 867                 }
 868         }
 869         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
 870                          drive->name, capacity, sectors_to_MB(capacity));
 871
 872         /* Only print cache size when it was specified */
 873         if (id->buf_size)
 874                 printk (" w/%dKiB Cache", id->buf_size/2);
 875
 876         printk(KERN_CONT ", CHS=%d/%d/%d\n",
 877                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
 878
 879         /* write cache enabled? */
 880         if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
 881                 drive->wcache = 1;
 882
 883         write_cache(drive, 1);
 884 }
 885
 886 static void ide_cacheflush_p(ide_drive_t *drive)
 887 {
 888         if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
 889                 return;
 890
 891         if (do_idedisk_flushcache(drive))
 892                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 893 }
 894
 895 static void ide_disk_remove(ide_drive_t *drive)
 896 {
 897         struct ide_disk_obj *idkp = drive->driver_data;
 898         struct gendisk *g = idkp->disk;
 899
 900         ide_proc_unregister_driver(drive, idkp->driver);
 901
 902         del_gendisk(g);
 903
 904         ide_cacheflush_p(drive);
 905
 906         ide_disk_put(idkp);
 907 }
 908
 909 static void ide_disk_release(struct kref *kref)
 910 {
 911         struct ide_disk_obj *idkp = to_ide_disk(kref);
 912         ide_drive_t *drive = idkp->drive;
 913         struct gendisk *g = idkp->disk;
 914
 915         drive->driver_data = NULL;
 916         g->private_data = NULL;
 917         put_disk(g);
 918         kfree(idkp);
 919 }
 920
 921 static int ide_disk_probe(ide_drive_t *drive);
 922
 923 /*
 924  * On HPA drives the capacity needs to be
 925  * reinitilized on resume otherwise the disk
 926  * can not be used and a hard reset is required
 927  */
 928 static void ide_disk_resume(ide_drive_t *drive)
 929 {
 930         if (idedisk_supports_hpa(drive->id))
 931                 init_idedisk_capacity(drive);
 932 }
 933
 934 static void ide_device_shutdown(ide_drive_t *drive)
 935 {
 936 #ifdef  CONFIG_ALPHA
 937         /* On Alpha, halt(8) doesn't actually turn the machine off,
 938            it puts you into the sort of firmware monitor. Typically,
 939            it's used to boot another kernel image, so it's not much
 940            different from reboot(8). Therefore, we don't need to
 941            spin down the disk in this case, especially since Alpha
 942            firmware doesn't handle disks in standby mode properly.
 943            On the other hand, it's reasonably safe to turn the power
 944            off when the shutdown process reaches the firmware prompt,
 945            as the firmware initialization takes rather long time -
 946            at least 10 seconds, which should be sufficient for
 947            the disk to expire its write cache. */
 948         if (system_state != SYSTEM_POWER_OFF) {
 949 #else
 950         if (system_state == SYSTEM_RESTART) {
 951 #endif
 952                 ide_cacheflush_p(drive);
 953                 return;
 954         }
 955
 956         printk("Shutdown: %s\n", drive->name);
 957         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
 958 }
 959
 960 static ide_driver_t idedisk_driver = {
 961         .gen_driver = {
 962                 .owner          = THIS_MODULE,
 963                 .name           = "ide-disk",
 964                 .bus            = &ide_bus_type,
 965         },
 966         .probe                  = ide_disk_probe,
 967         .remove                 = ide_disk_remove,
 968         .resume                 = ide_disk_resume,
 969         .shutdown               = ide_device_shutdown,
 970         .version                = IDEDISK_VERSION,
 971         .media                  = ide_disk,
 972         .supports_dsc_overlap   = 0,
 973         .do_request             = ide_do_rw_disk,
 974         .end_request            = ide_end_request,
 975         .error                  = __ide_error,
 976         .abort                  = __ide_abort,
 977 #ifdef CONFIG_IDE_PROC_FS
 978         .proc                   = idedisk_proc,
 979 #endif
 980 };
 981
 982 static int idedisk_open(struct inode *inode, struct file *filp)
 983 {
 984         struct gendisk *disk = inode->i_bdev->bd_disk;
 985         struct ide_disk_obj *idkp;
 986         ide_drive_t *drive;
 987
 988         if (!(idkp = ide_disk_get(disk)))
 989                 return -ENXIO;
 990
 991         drive = idkp->drive;
 992
 993         idkp->openers++;
 994
 995         if (drive->removable && idkp->openers == 1) {
 996                 ide_task_t args;
 997                 memset(&args, 0, sizeof(ide_task_t));
 998                 args.tf.command = WIN_DOORLOCK;
 999                 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1000                 args.handler      = &task_no_data_intr;
1001                 check_disk_change(inode->i_bdev);
1002                 /*
1003                  * Ignore the return code from door_lock,
1004                  * since the open() has already succeeded,
1005                  * and the door_lock is irrelevant at this point.
1006                  */
1007                 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1008                         drive->doorlocking = 0;
1009         }
1010         return 0;
1011 }
1012
1013 static int idedisk_release(struct inode *inode, struct file *filp)
1014 {
1015         struct gendisk *disk = inode->i_bdev->bd_disk;
1016         struct ide_disk_obj *idkp = ide_disk_g(disk);
1017         ide_drive_t *drive = idkp->drive;
1018
1019         if (idkp->openers == 1)
1020                 ide_cacheflush_p(drive);
1021
1022         if (drive->removable && idkp->openers == 1) {
1023                 ide_task_t args;
1024                 memset(&args, 0, sizeof(ide_task_t));
1025                 args.tf.command = WIN_DOORUNLOCK;
1026                 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1027                 args.handler      = &task_no_data_intr;
1028                 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
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(1 << PARTN_BITS,
1149                         hwif_to_node(drive->hwif));
1150         if (!g)
1151                 goto out_free_idkp;
1152
1153         ide_init_disk(g, drive);
1154
1155         ide_proc_register_driver(drive, &idedisk_driver);
1156
1157         kref_init(&idkp->kref);
1158
1159         idkp->drive = drive;
1160         idkp->driver = &idedisk_driver;
1161         idkp->disk = g;
1162
1163         g->private_data = &idkp->driver;
1164
1165         drive->driver_data = idkp;
1166
1167         idedisk_setup(drive);
1168         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1169                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1170                         drive->name, drive->head);
1171                 drive->attach = 0;
1172         } else
1173                 drive->attach = 1;
1174
1175         g->minors = 1 << PARTN_BITS;
1176         g->driverfs_dev = &drive->gendev;
1177         g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1178         set_capacity(g, idedisk_capacity(drive));
1179         g->fops = &idedisk_ops;
1180         add_disk(g);
1181         return 0;
1182
1183 out_free_idkp:
1184         kfree(idkp);
1185 failed:
1186         return -ENODEV;
1187 }
1188
1189 static void __exit idedisk_exit (void)
1190 {
1191         driver_unregister(&idedisk_driver.gen_driver);
1192 }
1193
1194 static int __init idedisk_init(void)
1195 {
1196         return driver_register(&idedisk_driver.gen_driver);
1197 }
1198
1199 MODULE_ALIAS("ide:*m-disk*");
1200 module_init(idedisk_init);
1201 module_exit(idedisk_exit);
1202 MODULE_LICENSE("GPL");