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