drivers/ide/ide-disk.c

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