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