2 * linux/drivers/ide/ide-disk.c Version 1.18 Mar 05, 2003
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>
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>
15 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
17 * Version 1.00 move disk only code from ide.c to ide-disk.c
18 * support optional byte-swapping of all data
19 * Version 1.01 fix previous byte-swapping code
20 * Version 1.02 remove ", LBA" from drive identification msgs
21 * Version 1.03 fix display of id->buf_size for big-endian
22 * Version 1.04 add /proc configurable settings and S.M.A.R.T support
23 * Version 1.05 add capacity support for ATA3 >= 8GB
24 * Version 1.06 get boot-up messages to show full cyl count
25 * Version 1.07 disable door-locking if it fails
26 * Version 1.08 fixed CHS/LBA translations for ATA4 > 8GB,
27 * process of adding new ATA4 compliance.
28 * fixed problems in allowing fdisk to see
30 * Version 1.09 added increment of rq->sector in ide_multwrite
31 * added UDMA 3/4 reporting
32 * Version 1.10 request queue changes, Ultra DMA 100
33 * Version 1.11 added 48-bit lba
34 * Version 1.12 adding taskfile io access method
35 * Version 1.13 added standby and flush-cache for notifier
36 * Version 1.14 added acoustic-wcache
37 * Version 1.15 convert all calls to ide_raw_taskfile
38 * since args will return register content.
39 * Version 1.16 added suspend-resume-checkpower
40 * Version 1.17 do flush on standy, do flush on ATA < ATA6
44 #define IDEDISK_VERSION "1.18"
46 #undef REALLY_SLOW_IO /* most systems can safely undef this */
48 #include <linux/config.h>
49 #include <linux/module.h>
50 #include <linux/types.h>
51 #include <linux/string.h>
52 #include <linux/kernel.h>
53 #include <linux/timer.h>
55 #include <linux/interrupt.h>
56 #include <linux/major.h>
57 #include <linux/errno.h>
58 #include <linux/genhd.h>
59 #include <linux/slab.h>
60 #include <linux/delay.h>
64 #include <linux/ide.h>
66 #include <asm/byteorder.h>
68 #include <asm/uaccess.h>
70 #include <asm/div64.h>
72 /* FIXME: some day we shouldn't need to look in here! */
74 #include "legacy/pdc4030.h"
77 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
78 * value for this drive (from its reported identification information).
80 * Returns: 1 if lba_capacity looks sensible
83 * It is called only once for each drive.
85 static int lba_capacity_is_ok (struct hd_driveid *id)
87 unsigned long lba_sects, chs_sects, head, tail;
90 * The ATA spec tells large drives to return
91 * C/H/S = 16383/16/63 independent of their size.
92 * Some drives can be jumpered to use 15 heads instead of 16.
93 * Some drives can be jumpered to use 4092 cyls instead of 16383.
95 if ((id->cyls == 16383
96 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
98 (id->heads == 15 || id->heads == 16) &&
99 (id->lba_capacity >= 16383*63*id->heads))
102 lba_sects = id->lba_capacity;
103 chs_sects = id->cyls * id->heads * id->sectors;
105 /* perform a rough sanity check on lba_sects: within 10% is OK */
106 if ((lba_sects - chs_sects) < chs_sects/10)
109 /* some drives have the word order reversed */
110 head = ((lba_sects >> 16) & 0xffff);
111 tail = (lba_sects & 0xffff);
112 lba_sects = (head | (tail << 16));
113 if ((lba_sects - chs_sects) < chs_sects/10) {
114 id->lba_capacity = lba_sects;
115 return 1; /* lba_capacity is (now) good */
118 return 0; /* lba_capacity value may be bad */
121 static int idedisk_start_tag(ide_drive_t *drive, struct request *rq)
126 spin_lock_irqsave(&ide_lock, flags);
128 if (ata_pending_commands(drive) < drive->queue_depth)
129 ret = blk_queue_start_tag(drive->queue, rq);
131 spin_unlock_irqrestore(&ide_lock, flags);
135 #ifndef CONFIG_IDE_TASKFILE_IO
138 * read_intr() is the handler for disk read/multread interrupts
140 static ide_startstop_t read_intr (ide_drive_t *drive)
142 ide_hwif_t *hwif = HWIF(drive);
143 u32 i = 0, nsect = 0, msect = drive->mult_count;
149 /* new way for dealing with premature shared PCI interrupts */
150 if (!OK_STAT(stat=hwif->INB(IDE_STATUS_REG),DATA_READY,BAD_R_STAT)) {
151 if (stat & (ERR_STAT|DRQ_STAT)) {
152 return DRIVER(drive)->error(drive, "read_intr", stat);
154 /* no data yet, so wait for another interrupt */
155 ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);
160 rq = HWGROUP(drive)->rq;
162 if ((nsect = rq->current_nr_sectors) > msect)
167 to = ide_map_buffer(rq, &flags);
168 taskfile_input_data(drive, to, nsect * SECTOR_WORDS);
170 printk("%s: read: sectors(%ld-%ld), buffer=0x%08lx, remaining=%ld\n",
171 drive->name, rq->sector, rq->sector+nsect-1,
172 (unsigned long) rq->buffer+(nsect<<9), rq->nr_sectors-nsect);
174 ide_unmap_buffer(rq, to, &flags);
177 i = (rq->nr_sectors -= nsect);
178 if (((long)(rq->current_nr_sectors -= nsect)) <= 0)
179 ide_end_request(drive, 1, rq->hard_cur_sectors);
181 * Another BH Page walker and DATA INTEGRITY Questioned on ERROR.
182 * If passed back up on multimode read, BAD DATA could be ACKED
183 * to FILE SYSTEMS above ...
188 ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);
195 * write_intr() is the handler for disk write interrupts
197 static ide_startstop_t write_intr (ide_drive_t *drive)
199 ide_hwgroup_t *hwgroup = HWGROUP(drive);
200 ide_hwif_t *hwif = HWIF(drive);
201 struct request *rq = hwgroup->rq;
205 if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG),
206 DRIVE_READY, drive->bad_wstat)) {
207 printk("%s: write_intr error1: nr_sectors=%ld, stat=0x%02x\n",
208 drive->name, rq->nr_sectors, stat);
211 printk("%s: write: sector %ld, buffer=0x%08lx, remaining=%ld\n",
212 drive->name, rq->sector, (unsigned long) rq->buffer,
215 if ((rq->nr_sectors == 1) ^ ((stat & DRQ_STAT) != 0)) {
218 i = --rq->nr_sectors;
219 --rq->current_nr_sectors;
220 if (((long)rq->current_nr_sectors) <= 0)
221 ide_end_request(drive, 1, rq->hard_cur_sectors);
224 char *to = ide_map_buffer(rq, &flags);
225 taskfile_output_data(drive, to, SECTOR_WORDS);
226 ide_unmap_buffer(rq, to, &flags);
227 ide_set_handler(drive, &write_intr, WAIT_CMD, NULL);
232 /* the original code did this here (?) */
235 return DRIVER(drive)->error(drive, "write_intr", stat);
239 * ide_multwrite() transfers a block of up to mcount sectors of data
240 * to a drive as part of a disk multiple-sector write operation.
242 * Note that we may be called from two contexts - __ide_do_rw_disk() context
243 * and IRQ context. The IRQ can happen any time after we've output the
244 * full "mcount" number of sectors, so we must make sure we update the
245 * state _before_ we output the final part of the data!
247 * The update and return to BH is a BLOCK Layer Fakey to get more data
248 * to satisfy the hardware atomic segment. If the hardware atomic segment
249 * is shorter or smaller than the BH segment then we should be OKAY.
250 * This is only valid if we can rewind the rq->current_nr_sectors counter.
252 static void ide_multwrite(ide_drive_t *drive, unsigned int mcount)
254 ide_hwgroup_t *hwgroup = HWGROUP(drive);
255 struct request *rq = &hwgroup->wrq;
259 int nsect = rq->current_nr_sectors;
265 buffer = ide_map_buffer(rq, &flags);
268 rq->nr_sectors -= nsect;
269 rq->current_nr_sectors -= nsect;
271 /* Do we move to the next bh after this? */
272 if (!rq->current_nr_sectors) {
273 struct bio *bio = rq->bio;
276 * only move to next bio, when we have processed
277 * all bvecs in this one.
279 if (++bio->bi_idx >= bio->bi_vcnt) {
280 bio->bi_idx = bio->bi_vcnt - rq->nr_cbio_segments;
284 /* end early early we ran out of requests */
289 rq->nr_cbio_segments = bio_segments(bio);
290 rq->current_nr_sectors = bio_cur_sectors(bio);
291 rq->hard_cur_sectors = rq->current_nr_sectors;
296 * Ok, we're all setup for the interrupt
297 * re-entering us on the last transfer.
299 taskfile_output_data(drive, buffer, nsect<<7);
300 ide_unmap_buffer(rq, buffer, &flags);
305 * multwrite_intr() is the handler for disk multwrite interrupts
307 static ide_startstop_t multwrite_intr (ide_drive_t *drive)
309 ide_hwgroup_t *hwgroup = HWGROUP(drive);
310 ide_hwif_t *hwif = HWIF(drive);
311 struct request *rq = &hwgroup->wrq;
312 struct bio *bio = rq->bio;
315 stat = hwif->INB(IDE_STATUS_REG);
316 if (OK_STAT(stat, DRIVE_READY, drive->bad_wstat)) {
317 if (stat & DRQ_STAT) {
319 * The drive wants data. Remember rq is the copy
322 if (rq->nr_sectors) {
323 ide_multwrite(drive, drive->mult_count);
324 ide_set_handler(drive, &multwrite_intr, WAIT_CMD, NULL);
329 * If the copy has all the blocks completed then
330 * we can end the original request.
332 if (!rq->nr_sectors) { /* all done? */
333 bio->bi_idx = bio->bi_vcnt - rq->nr_cbio_segments;
335 ide_end_request(drive, 1, rq->nr_sectors);
339 bio->bi_idx = bio->bi_vcnt - rq->nr_cbio_segments;
340 /* the original code did this here (?) */
343 bio->bi_idx = bio->bi_vcnt - rq->nr_cbio_segments;
344 return DRIVER(drive)->error(drive, "multwrite_intr", stat);
348 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
349 * using LBA if supported, or CHS otherwise, to address sectors.
350 * It also takes care of issuing special DRIVE_CMDs.
352 ide_startstop_t __ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
354 ide_hwif_t *hwif = HWIF(drive);
355 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
356 task_ioreg_t command = WIN_NOP;
357 ata_nsector_t nsectors;
359 nsectors.all = (u16) rq->nr_sectors;
362 hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
364 if (drive->select.b.lba) {
365 if (drive->addressing == 1) {
366 task_ioreg_t tasklets[10];
368 if (blk_rq_tagged(rq)) {
369 tasklets[0] = nsectors.b.low;
370 tasklets[1] = nsectors.b.high;
371 tasklets[2] = rq->tag << 3;
376 tasklets[2] = nsectors.b.low;
377 tasklets[3] = nsectors.b.high;
380 tasklets[4] = (task_ioreg_t) block;
381 tasklets[5] = (task_ioreg_t) (block>>8);
382 tasklets[6] = (task_ioreg_t) (block>>16);
383 tasklets[7] = (task_ioreg_t) (block>>24);
384 if (sizeof(block) == 4) {
385 tasklets[8] = (task_ioreg_t) 0;
386 tasklets[9] = (task_ioreg_t) 0;
388 tasklets[8] = (task_ioreg_t)((u64)block >> 32);
389 tasklets[9] = (task_ioreg_t)((u64)block >> 40);
392 printk("%s: %sing: LBAsect=%lu, sectors=%ld, "
393 "buffer=0x%08lx, LBAsect=0x%012lx\n",
395 rq_data_dir(rq)==READ?"read":"writ",
398 (unsigned long) rq->buffer,
400 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
401 drive->name, tasklets[3], tasklets[2],
402 tasklets[9], tasklets[8], tasklets[7],
403 tasklets[6], tasklets[5], tasklets[4]);
405 hwif->OUTB(tasklets[1], IDE_FEATURE_REG);
406 hwif->OUTB(tasklets[3], IDE_NSECTOR_REG);
407 hwif->OUTB(tasklets[7], IDE_SECTOR_REG);
408 hwif->OUTB(tasklets[8], IDE_LCYL_REG);
409 hwif->OUTB(tasklets[9], IDE_HCYL_REG);
411 hwif->OUTB(tasklets[0], IDE_FEATURE_REG);
412 hwif->OUTB(tasklets[2], IDE_NSECTOR_REG);
413 hwif->OUTB(tasklets[4], IDE_SECTOR_REG);
414 hwif->OUTB(tasklets[5], IDE_LCYL_REG);
415 hwif->OUTB(tasklets[6], IDE_HCYL_REG);
416 hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);
419 printk("%s: %sing: LBAsect=%llu, sectors=%ld, "
422 rq_data_dir(rq)==READ?"read":"writ",
423 (unsigned long long)block, rq->nr_sectors,
424 (unsigned long) rq->buffer);
426 if (blk_rq_tagged(rq)) {
427 hwif->OUTB(nsectors.b.low, IDE_FEATURE_REG);
428 hwif->OUTB(rq->tag << 3, IDE_NSECTOR_REG);
430 hwif->OUTB(0x00, IDE_FEATURE_REG);
431 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
434 hwif->OUTB(block, IDE_SECTOR_REG);
435 hwif->OUTB(block>>=8, IDE_LCYL_REG);
436 hwif->OUTB(block>>=8, IDE_HCYL_REG);
437 hwif->OUTB(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
440 unsigned int sect,head,cyl,track;
441 track = (int)block / drive->sect;
442 sect = (int)block % drive->sect + 1;
443 hwif->OUTB(sect, IDE_SECTOR_REG);
444 head = track % drive->head;
445 cyl = track / drive->head;
447 if (blk_rq_tagged(rq)) {
448 hwif->OUTB(nsectors.b.low, IDE_FEATURE_REG);
449 hwif->OUTB(rq->tag << 3, IDE_NSECTOR_REG);
451 hwif->OUTB(0x00, IDE_FEATURE_REG);
452 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
455 hwif->OUTB(cyl, IDE_LCYL_REG);
456 hwif->OUTB(cyl>>8, IDE_HCYL_REG);
457 hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);
459 printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",
460 drive->name, rq_data_dir(rq)==READ?"read":"writ", cyl,
461 head, sect, rq->nr_sectors, (unsigned long) rq->buffer);
465 if (rq_data_dir(rq) == READ) {
466 #ifdef CONFIG_BLK_DEV_IDE_TCQ
467 if (blk_rq_tagged(rq))
468 return __ide_dma_queued_read(drive);
470 if (drive->using_dma && !hwif->ide_dma_read(drive))
473 command = ((drive->mult_count) ?
474 ((lba48) ? WIN_MULTREAD_EXT : WIN_MULTREAD) :
475 ((lba48) ? WIN_READ_EXT : WIN_READ));
476 ide_execute_command(drive, command, &read_intr, WAIT_CMD, NULL);
479 ide_startstop_t startstop;
480 #ifdef CONFIG_BLK_DEV_IDE_TCQ
481 if (blk_rq_tagged(rq))
482 return __ide_dma_queued_write(drive);
484 if (drive->using_dma && !(HWIF(drive)->ide_dma_write(drive)))
487 command = ((drive->mult_count) ?
488 ((lba48) ? WIN_MULTWRITE_EXT : WIN_MULTWRITE) :
489 ((lba48) ? WIN_WRITE_EXT : WIN_WRITE));
490 hwif->OUTB(command, IDE_COMMAND_REG);
492 if (ide_wait_stat(&startstop, drive, DATA_READY,
493 drive->bad_wstat, WAIT_DRQ)) {
494 printk(KERN_ERR "%s: no DRQ after issuing %s\n",
496 drive->mult_count ? "MULTWRITE" : "WRITE");
501 if (drive->mult_count) {
502 ide_hwgroup_t *hwgroup = HWGROUP(drive);
504 hwgroup->wrq = *rq; /* scratchpad */
505 ide_set_handler(drive, &multwrite_intr, WAIT_CMD, NULL);
506 ide_multwrite(drive, drive->mult_count);
509 char *to = ide_map_buffer(rq, &flags);
510 ide_set_handler(drive, &write_intr, WAIT_CMD, NULL);
511 taskfile_output_data(drive, to, SECTOR_WORDS);
512 ide_unmap_buffer(rq, to, &flags);
517 EXPORT_SYMBOL_GPL(__ide_do_rw_disk);
519 #else /* CONFIG_IDE_TASKFILE_IO */
521 static ide_startstop_t chs_rw_disk(ide_drive_t *, struct request *, unsigned long);
522 static ide_startstop_t lba_28_rw_disk(ide_drive_t *, struct request *, unsigned long);
523 static ide_startstop_t lba_48_rw_disk(ide_drive_t *, struct request *, unsigned long long);
526 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
527 * using LBA if supported, or CHS otherwise, to address sectors.
528 * It also takes care of issuing special DRIVE_CMDs.
530 ide_startstop_t __ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
533 * 268435455 == 137439 MB or 28bit limit
535 * need to add split taskfile operations based on 28bit threshold.
537 if (drive->addressing == 1) /* 48-bit LBA */
538 return lba_48_rw_disk(drive, rq, (unsigned long long) block);
539 if (drive->select.b.lba) /* 28-bit LBA */
540 return lba_28_rw_disk(drive, rq, (unsigned long) block);
542 /* 28-bit CHS : DIE DIE DIE piece of legacy crap!!! */
543 return chs_rw_disk(drive, rq, (unsigned long) block);
545 EXPORT_SYMBOL_GPL(__ide_do_rw_disk);
547 static u8 get_command(ide_drive_t *drive, int cmd, ide_task_t *task)
549 unsigned int lba48 = (drive->addressing == 1) ? 1 : 0;
552 task->command_type = IDE_DRIVE_TASK_IN;
553 if (drive->using_tcq)
554 return lba48 ? WIN_READDMA_QUEUED_EXT : WIN_READDMA_QUEUED;
555 if (drive->using_dma)
556 return lba48 ? WIN_READDMA_EXT : WIN_READDMA;
557 if (drive->mult_count) {
558 task->handler = &task_mulin_intr;
559 return lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
561 task->handler = &task_in_intr;
562 return lba48 ? WIN_READ_EXT : WIN_READ;
564 task->command_type = IDE_DRIVE_TASK_RAW_WRITE;
565 if (drive->using_tcq)
566 return lba48 ? WIN_WRITEDMA_QUEUED_EXT : WIN_WRITEDMA_QUEUED;
567 if (drive->using_dma)
568 return lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
569 if (drive->mult_count) {
570 task->prehandler = &pre_task_mulout_intr;
571 task->handler = &task_mulout_intr;
572 return lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
574 task->prehandler = &pre_task_out_intr;
575 task->handler = &task_out_intr;
576 return lba48 ? WIN_WRITE_EXT : WIN_WRITE;
580 static ide_startstop_t chs_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
584 ata_nsector_t nsectors;
585 unsigned int track = (block / drive->sect);
586 unsigned int sect = (block % drive->sect) + 1;
587 unsigned int head = (track % drive->head);
588 unsigned int cyl = (track / drive->head);
590 nsectors.all = (u16) rq->nr_sectors;
593 printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
594 printk("CHS=%d/%d/%d, ", cyl, head, sect);
595 printk("sectors=%ld, ", rq->nr_sectors);
596 printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
599 memset(&args, 0, sizeof(ide_task_t));
601 sectors = (rq->nr_sectors == 256) ? 0x00 : rq->nr_sectors;
603 if (blk_rq_tagged(rq)) {
604 args.tfRegister[IDE_FEATURE_OFFSET] = sectors;
605 args.tfRegister[IDE_NSECTOR_OFFSET] = rq->tag << 3;
607 args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
609 args.tfRegister[IDE_SECTOR_OFFSET] = sect;
610 args.tfRegister[IDE_LCYL_OFFSET] = cyl;
611 args.tfRegister[IDE_HCYL_OFFSET] = (cyl>>8);
612 args.tfRegister[IDE_SELECT_OFFSET] = head;
613 args.tfRegister[IDE_SELECT_OFFSET] |= drive->select.all;
614 args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq_data_dir(rq), &args);
615 args.rq = (struct request *) rq;
616 rq->special = (ide_task_t *)&args;
617 return do_rw_taskfile(drive, &args);
620 static ide_startstop_t lba_28_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
624 ata_nsector_t nsectors;
626 nsectors.all = (u16) rq->nr_sectors;
629 printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
630 printk("LBAsect=%lld, ", block);
631 printk("sectors=%ld, ", rq->nr_sectors);
632 printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
635 memset(&args, 0, sizeof(ide_task_t));
637 sectors = (rq->nr_sectors == 256) ? 0x00 : rq->nr_sectors;
639 if (blk_rq_tagged(rq)) {
640 args.tfRegister[IDE_FEATURE_OFFSET] = sectors;
641 args.tfRegister[IDE_NSECTOR_OFFSET] = rq->tag << 3;
643 args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
645 args.tfRegister[IDE_SECTOR_OFFSET] = block;
646 args.tfRegister[IDE_LCYL_OFFSET] = (block>>=8);
647 args.tfRegister[IDE_HCYL_OFFSET] = (block>>=8);
648 args.tfRegister[IDE_SELECT_OFFSET] = ((block>>8)&0x0f);
649 args.tfRegister[IDE_SELECT_OFFSET] |= drive->select.all;
650 args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq_data_dir(rq), &args);
651 args.rq = (struct request *) rq;
652 rq->special = (ide_task_t *)&args;
653 return do_rw_taskfile(drive, &args);
657 * 268435455 == 137439 MB or 28bit limit
658 * 320173056 == 163929 MB or 48bit addressing
659 * 1073741822 == 549756 MB or 48bit addressing fake drive
662 static ide_startstop_t lba_48_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long long block)
666 ata_nsector_t nsectors;
668 nsectors.all = (u16) rq->nr_sectors;
671 printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
672 printk("LBAsect=%lld, ", block);
673 printk("sectors=%ld, ", rq->nr_sectors);
674 printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
677 memset(&args, 0, sizeof(ide_task_t));
679 sectors = (rq->nr_sectors == 65536) ? 0 : rq->nr_sectors;
681 if (blk_rq_tagged(rq)) {
682 args.tfRegister[IDE_FEATURE_OFFSET] = sectors;
683 args.tfRegister[IDE_NSECTOR_OFFSET] = rq->tag << 3;
684 args.hobRegister[IDE_FEATURE_OFFSET] = sectors >> 8;
685 args.hobRegister[IDE_NSECTOR_OFFSET] = 0;
687 args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
688 args.hobRegister[IDE_NSECTOR_OFFSET] = sectors >> 8;
691 args.tfRegister[IDE_SECTOR_OFFSET] = block; /* low lba */
692 args.tfRegister[IDE_LCYL_OFFSET] = (block>>=8); /* mid lba */
693 args.tfRegister[IDE_HCYL_OFFSET] = (block>>=8); /* hi lba */
694 args.tfRegister[IDE_SELECT_OFFSET] = drive->select.all;
695 args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq_data_dir(rq), &args);
696 args.hobRegister[IDE_SECTOR_OFFSET] = (block>>=8); /* low lba */
697 args.hobRegister[IDE_LCYL_OFFSET] = (block>>=8); /* mid lba */
698 args.hobRegister[IDE_HCYL_OFFSET] = (block>>=8); /* hi lba */
699 args.hobRegister[IDE_SELECT_OFFSET] = drive->select.all;
700 args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
701 args.rq = (struct request *) rq;
702 rq->special = (ide_task_t *)&args;
703 return do_rw_taskfile(drive, &args);
706 #endif /* CONFIG_IDE_TASKFILE_IO */
708 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
710 ide_hwif_t *hwif = HWIF(drive);
712 BUG_ON(drive->blocked);
714 if (!blk_fs_request(rq)) {
715 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
716 ide_end_request(drive, 0, 0);
720 if (drive->using_tcq && idedisk_start_tag(drive, rq)) {
721 if (!ata_pending_commands(drive))
728 return hwif->rw_disk(drive, rq, block);
730 return __ide_do_rw_disk(drive, rq, block);
733 static u8 idedisk_dump_status (ide_drive_t *drive, const char *msg, u8 stat)
735 ide_hwif_t *hwif = HWIF(drive);
739 local_irq_set(flags);
740 printk("%s: %s: status=0x%02x", drive->name, msg, stat);
741 #if FANCY_STATUS_DUMPS
743 if (stat & BUSY_STAT)
746 if (stat & READY_STAT) printk("DriveReady ");
747 if (stat & WRERR_STAT) printk("DeviceFault ");
748 if (stat & SEEK_STAT) printk("SeekComplete ");
749 if (stat & DRQ_STAT) printk("DataRequest ");
750 if (stat & ECC_STAT) printk("CorrectedError ");
751 if (stat & INDEX_STAT) printk("Index ");
752 if (stat & ERR_STAT) printk("Error ");
755 #endif /* FANCY_STATUS_DUMPS */
757 if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
758 err = hwif->INB(IDE_ERROR_REG);
759 printk("%s: %s: error=0x%02x", drive->name, msg, err);
760 #if FANCY_STATUS_DUMPS
762 if (err & ABRT_ERR) printk("DriveStatusError ");
764 printk("Bad%s ", (err & ABRT_ERR) ? "CRC" : "Sector");
765 if (err & ECC_ERR) printk("UncorrectableError ");
766 if (err & ID_ERR) printk("SectorIdNotFound ");
767 if (err & TRK0_ERR) printk("TrackZeroNotFound ");
768 if (err & MARK_ERR) printk("AddrMarkNotFound ");
770 if ((err & (BBD_ERR | ABRT_ERR)) == BBD_ERR ||
771 (err & (ECC_ERR|ID_ERR|MARK_ERR))) {
772 if (drive->addressing == 1) {
774 u32 low = 0, high = 0;
775 low = ide_read_24(drive);
776 hwif->OUTB(drive->ctl|0x80, IDE_CONTROL_REG);
777 high = ide_read_24(drive);
778 sectors = ((__u64)high << 24) | low;
779 printk(", LBAsect=%llu, high=%d, low=%d",
780 (unsigned long long) sectors,
783 u8 cur = hwif->INB(IDE_SELECT_REG);
784 if (cur & 0x40) { /* using LBA? */
785 printk(", LBAsect=%ld", (unsigned long)
787 |(hwif->INB(IDE_HCYL_REG)<<16)
788 |(hwif->INB(IDE_LCYL_REG)<<8)
789 | hwif->INB(IDE_SECTOR_REG));
791 printk(", CHS=%d/%d/%d",
792 (hwif->INB(IDE_HCYL_REG)<<8) +
793 hwif->INB(IDE_LCYL_REG),
795 hwif->INB(IDE_SECTOR_REG));
798 if (HWGROUP(drive) && HWGROUP(drive)->rq)
799 printk(", sector=%llu",
800 (unsigned long long)HWGROUP(drive)->rq->sector);
803 #endif /* FANCY_STATUS_DUMPS */
805 local_irq_restore(flags);
809 ide_startstop_t idedisk_error (ide_drive_t *drive, const char *msg, u8 stat)
814 int i = (drive->mult_count ? drive->mult_count : 1) * SECTOR_WORDS;
816 err = idedisk_dump_status(drive, msg, stat);
818 if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
822 /* retry only "normal" I/O: */
823 if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK | REQ_DRIVE_TASKFILE)) {
825 ide_end_drive_cmd(drive, stat, err);
828 #ifdef CONFIG_IDE_TASKFILE_IO
829 /* make rq completion pointers new submission pointers */
830 blk_rq_prep_restart(rq);
833 if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) {
834 /* other bits are useless when BUSY */
835 rq->errors |= ERROR_RESET;
836 } else if (stat & ERR_STAT) {
837 /* err has different meaning on cdrom and tape */
838 if (err == ABRT_ERR) {
839 if (drive->select.b.lba &&
840 /* some newer drives don't support WIN_SPECIFY */
841 hwif->INB(IDE_COMMAND_REG) == WIN_SPECIFY)
843 } else if ((err & BAD_CRC) == BAD_CRC) {
844 /* UDMA crc error, just retry the operation */
846 } else if (err & (BBD_ERR | ECC_ERR)) {
847 /* retries won't help these */
848 rq->errors = ERROR_MAX;
849 } else if (err & TRK0_ERR) {
850 /* help it find track zero */
851 rq->errors |= ERROR_RECAL;
854 if ((stat & DRQ_STAT) && rq_data_dir(rq) == READ) {
856 * try_to_flush_leftover_data() is invoked in response to
857 * a drive unexpectedly having its DRQ_STAT bit set. As
858 * an alternative to resetting the drive, this routine
859 * tries to clear the condition by read a sector's worth
860 * of data from the drive. Of course, this may not help
861 * if the drive is *waiting* for data from *us*.
865 unsigned int wcount = (i > 16) ? 16 : i;
867 taskfile_input_data(drive, buffer, wcount);
870 if (hwif->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT)) {
872 hwif->OUTB(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG);
874 if (rq->errors >= ERROR_MAX || blk_noretry_request(rq))
875 DRIVER(drive)->end_request(drive, 0, 0);
877 if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
879 return ide_do_reset(drive);
881 if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
882 drive->special.b.recalibrate = 1;
888 ide_startstop_t idedisk_abort(ide_drive_t *drive, const char *msg)
893 if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
898 if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK | REQ_DRIVE_TASKFILE)) {
900 ide_end_drive_cmd(drive, BUSY_STAT, 0);
904 DRIVER(drive)->end_request(drive, 0, 0);
909 * Queries for true maximum capacity of the drive.
910 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
912 static unsigned long idedisk_read_native_max_address(ide_drive_t *drive)
915 unsigned long addr = 0;
917 /* Create IDE/ATA command request structure */
918 memset(&args, 0, sizeof(ide_task_t));
919 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
920 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX;
921 args.command_type = IDE_DRIVE_TASK_NO_DATA;
922 args.handler = &task_no_data_intr;
923 /* submit command request */
924 ide_raw_taskfile(drive, &args, NULL);
926 /* if OK, compute maximum address value */
927 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
928 addr = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
929 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
930 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
931 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
932 addr++; /* since the return value is (maxlba - 1), we add 1 */
937 static unsigned long long idedisk_read_native_max_address_ext(ide_drive_t *drive)
940 unsigned long long addr = 0;
942 /* Create IDE/ATA command request structure */
943 memset(&args, 0, sizeof(ide_task_t));
945 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
946 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX_EXT;
947 args.command_type = IDE_DRIVE_TASK_NO_DATA;
948 args.handler = &task_no_data_intr;
949 /* submit command request */
950 ide_raw_taskfile(drive, &args, NULL);
952 /* if OK, compute maximum address value */
953 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
954 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
955 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
956 args.hobRegister[IDE_SECTOR_OFFSET];
957 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
958 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
959 (args.tfRegister[IDE_SECTOR_OFFSET]);
960 addr = ((__u64)high << 24) | low;
961 addr++; /* since the return value is (maxlba - 1), we add 1 */
966 #ifdef CONFIG_IDEDISK_STROKE
968 * Sets maximum virtual LBA address of the drive.
969 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
971 static unsigned long idedisk_set_max_address(ide_drive_t *drive, unsigned long addr_req)
974 unsigned long addr_set = 0;
977 /* Create IDE/ATA command request structure */
978 memset(&args, 0, sizeof(ide_task_t));
979 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
980 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >> 8) & 0xff);
981 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >> 16) & 0xff);
982 args.tfRegister[IDE_SELECT_OFFSET] = ((addr_req >> 24) & 0x0f) | 0x40;
983 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX;
984 args.command_type = IDE_DRIVE_TASK_NO_DATA;
985 args.handler = &task_no_data_intr;
986 /* submit command request */
987 ide_raw_taskfile(drive, &args, NULL);
988 /* if OK, read new maximum address value */
989 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
990 addr_set = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
991 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
992 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
993 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
999 static unsigned long long idedisk_set_max_address_ext(ide_drive_t *drive, unsigned long long addr_req)
1002 unsigned long long addr_set = 0;
1005 /* Create IDE/ATA command request structure */
1006 memset(&args, 0, sizeof(ide_task_t));
1007 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
1008 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
1009 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
1010 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
1011 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX_EXT;
1012 args.hobRegister[IDE_SECTOR_OFFSET] = (addr_req >>= 8) & 0xff;
1013 args.hobRegister[IDE_LCYL_OFFSET] = (addr_req >>= 8) & 0xff;
1014 args.hobRegister[IDE_HCYL_OFFSET] = (addr_req >>= 8) & 0xff;
1015 args.hobRegister[IDE_SELECT_OFFSET] = 0x40;
1016 args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
1017 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1018 args.handler = &task_no_data_intr;
1019 /* submit command request */
1020 ide_raw_taskfile(drive, &args, NULL);
1021 /* if OK, compute maximum address value */
1022 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
1023 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
1024 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
1025 args.hobRegister[IDE_SECTOR_OFFSET];
1026 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
1027 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
1028 (args.tfRegister[IDE_SECTOR_OFFSET]);
1029 addr_set = ((__u64)high << 24) | low;
1035 #endif /* CONFIG_IDEDISK_STROKE */
1037 static unsigned long long sectors_to_MB(unsigned long long n)
1039 n <<= 9; /* make it bytes */
1040 do_div(n, 1000000); /* make it MB */
1045 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
1046 * so on non-buggy drives we need test only one.
1047 * However, we should also check whether these fields are valid.
1049 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
1051 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
1057 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
1059 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
1060 && id->lba_capacity_2;
1063 static inline void idedisk_check_hpa(ide_drive_t *drive)
1065 unsigned long long capacity, set_max;
1066 int lba48 = idedisk_supports_lba48(drive->id);
1068 capacity = drive->capacity64;
1070 set_max = idedisk_read_native_max_address_ext(drive);
1072 set_max = idedisk_read_native_max_address(drive);
1074 if (set_max <= capacity)
1077 printk(KERN_INFO "%s: Host Protected Area detected.\n"
1078 "\tcurrent capacity is %llu sectors (%llu MB)\n"
1079 "\tnative capacity is %llu sectors (%llu MB)\n",
1081 capacity, sectors_to_MB(capacity),
1082 set_max, sectors_to_MB(set_max));
1083 #ifdef CONFIG_IDEDISK_STROKE
1085 set_max = idedisk_set_max_address_ext(drive, set_max);
1087 set_max = idedisk_set_max_address(drive, set_max);
1089 drive->capacity64 = set_max;
1090 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
1097 * Compute drive->capacity, the full capacity of the drive
1098 * Called with drive->id != NULL.
1100 * To compute capacity, this uses either of
1102 * 1. CHS value set by user (whatever user sets will be trusted)
1103 * 2. LBA value from target drive (require new ATA feature)
1104 * 3. LBA value from system BIOS (new one is OK, old one may break)
1105 * 4. CHS value from system BIOS (traditional style)
1107 * in above order (i.e., if value of higher priority is available,
1108 * reset will be ignored).
1110 static void init_idedisk_capacity (ide_drive_t *drive)
1112 struct hd_driveid *id = drive->id;
1114 * If this drive supports the Host Protected Area feature set,
1115 * then we may need to change our opinion about the drive's capacity.
1117 int hpa = idedisk_supports_hpa(id);
1119 if (idedisk_supports_lba48(id)) {
1120 /* drive speaks 48-bit LBA */
1121 drive->select.b.lba = 1;
1122 drive->capacity64 = id->lba_capacity_2;
1124 idedisk_check_hpa(drive);
1125 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
1126 /* drive speaks 28-bit LBA */
1127 drive->select.b.lba = 1;
1128 drive->capacity64 = id->lba_capacity;
1130 idedisk_check_hpa(drive);
1132 /* drive speaks boring old 28-bit CHS */
1133 drive->capacity64 = drive->cyl * drive->head * drive->sect;
1137 static sector_t idedisk_capacity (ide_drive_t *drive)
1139 return drive->capacity64 - drive->sect0;
1142 static ide_startstop_t idedisk_special (ide_drive_t *drive)
1144 special_t *s = &drive->special;
1146 if (s->b.set_geometry) {
1147 s->b.set_geometry = 0;
1148 if (!IS_PDC4030_DRIVE) {
1150 memset(&args, 0, sizeof(ide_task_t));
1151 args.tfRegister[IDE_NSECTOR_OFFSET] = drive->sect;
1152 args.tfRegister[IDE_SECTOR_OFFSET] = drive->sect;
1153 args.tfRegister[IDE_LCYL_OFFSET] = drive->cyl;
1154 args.tfRegister[IDE_HCYL_OFFSET] = drive->cyl>>8;
1155 args.tfRegister[IDE_SELECT_OFFSET] = ((drive->head-1)|drive->select.all)&0xBF;
1156 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SPECIFY;
1157 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1158 args.handler = &set_geometry_intr;
1159 do_rw_taskfile(drive, &args);
1161 } else if (s->b.recalibrate) {
1162 s->b.recalibrate = 0;
1163 if (!IS_PDC4030_DRIVE) {
1165 memset(&args, 0, sizeof(ide_task_t));
1166 args.tfRegister[IDE_NSECTOR_OFFSET] = drive->sect;
1167 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_RESTORE;
1168 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1169 args.handler = &recal_intr;
1170 do_rw_taskfile(drive, &args);
1172 } else if (s->b.set_multmode) {
1173 s->b.set_multmode = 0;
1174 if (drive->mult_req > drive->id->max_multsect)
1175 drive->mult_req = drive->id->max_multsect;
1176 if (!IS_PDC4030_DRIVE) {
1178 memset(&args, 0, sizeof(ide_task_t));
1179 args.tfRegister[IDE_NSECTOR_OFFSET] = drive->mult_req;
1180 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETMULT;
1181 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1182 args.handler = &set_multmode_intr;
1183 do_rw_taskfile(drive, &args);
1185 } else if (s->all) {
1186 int special = s->all;
1188 printk(KERN_ERR "%s: bad special flag: 0x%02x\n", drive->name, special);
1191 return IS_PDC4030_DRIVE ? ide_stopped : ide_started;
1194 static void idedisk_pre_reset (ide_drive_t *drive)
1196 int legacy = (drive->id->cfs_enable_2 & 0x0400) ? 0 : 1;
1198 drive->special.all = 0;
1199 drive->special.b.set_geometry = legacy;
1200 drive->special.b.recalibrate = legacy;
1201 if (OK_TO_RESET_CONTROLLER)
1202 drive->mult_count = 0;
1203 if (!drive->keep_settings && !drive->using_dma)
1204 drive->mult_req = 0;
1205 if (drive->mult_req != drive->mult_count)
1206 drive->special.b.set_multmode = 1;
1209 #ifdef CONFIG_PROC_FS
1211 static int smart_enable(ide_drive_t *drive)
1215 memset(&args, 0, sizeof(ide_task_t));
1216 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_ENABLE;
1217 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
1218 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
1219 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
1220 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1221 args.handler = &task_no_data_intr;
1222 return ide_raw_taskfile(drive, &args, NULL);
1225 static int get_smart_values(ide_drive_t *drive, u8 *buf)
1229 memset(&args, 0, sizeof(ide_task_t));
1230 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_VALUES;
1231 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
1232 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
1233 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
1234 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
1235 args.command_type = IDE_DRIVE_TASK_IN;
1236 args.handler = &task_in_intr;
1237 (void) smart_enable(drive);
1238 return ide_raw_taskfile(drive, &args, buf);
1241 static int get_smart_thresholds(ide_drive_t *drive, u8 *buf)
1244 memset(&args, 0, sizeof(ide_task_t));
1245 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_THRESHOLDS;
1246 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
1247 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
1248 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
1249 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
1250 args.command_type = IDE_DRIVE_TASK_IN;
1251 args.handler = &task_in_intr;
1252 (void) smart_enable(drive);
1253 return ide_raw_taskfile(drive, &args, buf);
1256 static int proc_idedisk_read_cache
1257 (char *page, char **start, off_t off, int count, int *eof, void *data)
1259 ide_drive_t *drive = (ide_drive_t *) data;
1264 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
1266 len = sprintf(out,"(none)\n");
1267 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
1270 static int proc_idedisk_read_smart_thresholds
1271 (char *page, char **start, off_t off, int count, int *eof, void *data)
1273 ide_drive_t *drive = (ide_drive_t *)data;
1276 if (!get_smart_thresholds(drive, page)) {
1277 unsigned short *val = (unsigned short *) page;
1278 char *out = ((char *)val) + (SECTOR_WORDS * 4);
1281 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
1283 } while (i < (SECTOR_WORDS * 2));
1286 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
1289 static int proc_idedisk_read_smart_values
1290 (char *page, char **start, off_t off, int count, int *eof, void *data)
1292 ide_drive_t *drive = (ide_drive_t *)data;
1295 if (!get_smart_values(drive, page)) {
1296 unsigned short *val = (unsigned short *) page;
1297 char *out = ((char *)val) + (SECTOR_WORDS * 4);
1300 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
1302 } while (i < (SECTOR_WORDS * 2));
1305 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
1308 static ide_proc_entry_t idedisk_proc[] = {
1309 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
1310 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
1311 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
1312 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
1313 { NULL, 0, NULL, NULL }
1318 #define idedisk_proc NULL
1320 #endif /* CONFIG_PROC_FS */
1323 * This is tightly woven into the driver->do_special can not touch.
1324 * DON'T do it again until a total personality rewrite is committed.
1326 static int set_multcount(ide_drive_t *drive, int arg)
1330 if (drive->special.b.set_multmode)
1332 ide_init_drive_cmd (&rq);
1333 rq.flags = REQ_DRIVE_CMD;
1334 drive->mult_req = arg;
1335 drive->special.b.set_multmode = 1;
1336 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
1337 return (drive->mult_count == arg) ? 0 : -EIO;
1340 static int set_nowerr(ide_drive_t *drive, int arg)
1342 if (ide_spin_wait_hwgroup(drive))
1344 drive->nowerr = arg;
1345 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
1346 spin_unlock_irq(&ide_lock);
1350 /* check if CACHE FLUSH (EXT) command is supported (bits defined in ATA-6) */
1351 #define ide_id_has_flush_cache(id) ((id)->cfs_enable_2 & 0x3000)
1353 /* some Maxtor disks have bit 13 defined incorrectly so check bit 10 too */
1354 #define ide_id_has_flush_cache_ext(id) \
1355 (((id)->cfs_enable_2 & 0x2400) == 0x2400)
1357 static int write_cache (ide_drive_t *drive, int arg)
1361 if (!ide_id_has_flush_cache(drive->id))
1364 memset(&args, 0, sizeof(ide_task_t));
1365 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ?
1366 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
1367 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
1368 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1369 args.handler = &task_no_data_intr;
1370 (void) ide_raw_taskfile(drive, &args, NULL);
1372 drive->wcache = arg;
1376 static int do_idedisk_flushcache (ide_drive_t *drive)
1380 memset(&args, 0, sizeof(ide_task_t));
1381 if (ide_id_has_flush_cache_ext(drive->id))
1382 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
1384 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
1385 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1386 args.handler = &task_no_data_intr;
1387 return ide_raw_taskfile(drive, &args, NULL);
1390 static int set_acoustic (ide_drive_t *drive, int arg)
1394 memset(&args, 0, sizeof(ide_task_t));
1395 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ? SETFEATURES_EN_AAM :
1396 SETFEATURES_DIS_AAM;
1397 args.tfRegister[IDE_NSECTOR_OFFSET] = arg;
1398 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
1399 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1400 args.handler = &task_no_data_intr;
1401 ide_raw_taskfile(drive, &args, NULL);
1402 drive->acoustic = arg;
1406 #ifdef CONFIG_BLK_DEV_IDE_TCQ
1407 static int set_using_tcq(ide_drive_t *drive, int arg)
1413 if (arg == drive->queue_depth && drive->using_tcq)
1417 * set depth, but check also id for max supported depth
1419 drive->queue_depth = arg ? arg : 1;
1421 if (drive->queue_depth > drive->id->queue_depth + 1)
1422 drive->queue_depth = drive->id->queue_depth + 1;
1426 ret = __ide_dma_queued_on(drive);
1428 ret = __ide_dma_queued_off(drive);
1430 return ret ? -EIO : 0;
1435 * drive->addressing:
1438 * 2: 48-bit capable doing 28-bit
1440 static int set_lba_addressing(ide_drive_t *drive, int arg)
1442 drive->addressing = 0;
1444 if (HWIF(drive)->no_lba48)
1447 if (!idedisk_supports_lba48(drive->id))
1449 drive->addressing = arg;
1453 static void idedisk_add_settings(ide_drive_t *drive)
1455 struct hd_driveid *id = drive->id;
1457 ide_add_setting(drive, "bios_cyl", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
1458 ide_add_setting(drive, "bios_head", SETTING_RW, -1, -1, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
1459 ide_add_setting(drive, "bios_sect", SETTING_RW, -1, -1, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
1460 ide_add_setting(drive, "address", SETTING_RW, HDIO_GET_ADDRESS, HDIO_SET_ADDRESS, TYPE_INTA, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
1461 ide_add_setting(drive, "bswap", SETTING_READ, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
1462 ide_add_setting(drive, "multcount", id ? SETTING_RW : SETTING_READ, HDIO_GET_MULTCOUNT, HDIO_SET_MULTCOUNT, TYPE_BYTE, 0, id ? id->max_multsect : 0, 1, 1, &drive->mult_count, set_multcount);
1463 ide_add_setting(drive, "nowerr", SETTING_RW, HDIO_GET_NOWERR, HDIO_SET_NOWERR, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
1464 ide_add_setting(drive, "lun", SETTING_RW, -1, -1, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
1465 ide_add_setting(drive, "wcache", SETTING_RW, HDIO_GET_WCACHE, HDIO_SET_WCACHE, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
1466 ide_add_setting(drive, "acoustic", SETTING_RW, HDIO_GET_ACOUSTIC, HDIO_SET_ACOUSTIC, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
1467 ide_add_setting(drive, "failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
1468 ide_add_setting(drive, "max_failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
1469 #ifdef CONFIG_BLK_DEV_IDE_TCQ
1470 ide_add_setting(drive, "using_tcq", SETTING_RW, HDIO_GET_QDMA, HDIO_SET_QDMA, TYPE_BYTE, 0, IDE_MAX_TAG, 1, 1, &drive->using_tcq, set_using_tcq);
1475 * Power Management state machine. This one is rather trivial for now,
1476 * we should probably add more, like switching back to PIO on suspend
1477 * to help some BIOSes, re-do the door locking on resume, etc...
1481 idedisk_pm_flush_cache = ide_pm_state_start_suspend,
1484 idedisk_pm_restore_dma = ide_pm_state_start_resume,
1487 static void idedisk_complete_power_step (ide_drive_t *drive, struct request *rq, u8 stat, u8 error)
1489 switch (rq->pm->pm_step) {
1490 case idedisk_pm_flush_cache: /* Suspend step 1 (flush cache) complete */
1491 if (rq->pm->pm_state == 4)
1492 rq->pm->pm_step = ide_pm_state_completed;
1494 rq->pm->pm_step = idedisk_pm_standby;
1496 case idedisk_pm_standby: /* Suspend step 2 (standby) complete */
1497 rq->pm->pm_step = ide_pm_state_completed;
1502 static ide_startstop_t idedisk_start_power_step (ide_drive_t *drive, struct request *rq)
1504 ide_task_t *args = rq->special;
1506 memset(args, 0, sizeof(*args));
1508 switch (rq->pm->pm_step) {
1509 case idedisk_pm_flush_cache: /* Suspend step 1 (flush cache) */
1510 /* Not supported? Switch to next step now. */
1511 if (!drive->wcache || !ide_id_has_flush_cache(drive->id)) {
1512 idedisk_complete_power_step(drive, rq, 0, 0);
1515 if (ide_id_has_flush_cache_ext(drive->id))
1516 args->tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
1518 args->tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
1519 args->command_type = IDE_DRIVE_TASK_NO_DATA;
1520 args->handler = &task_no_data_intr;
1521 return do_rw_taskfile(drive, args);
1522 case idedisk_pm_standby: /* Suspend step 2 (standby) */
1523 args->tfRegister[IDE_COMMAND_OFFSET] = WIN_STANDBYNOW1;
1524 args->command_type = IDE_DRIVE_TASK_NO_DATA;
1525 args->handler = &task_no_data_intr;
1526 return do_rw_taskfile(drive, args);
1528 case idedisk_pm_restore_dma: /* Resume step 1 (restore DMA) */
1530 * Right now, all we do is call hwif->ide_dma_check(drive),
1531 * we could be smarter and check for current xfer_speed
1532 * in struct drive etc...
1533 * Also, this step could be implemented as a generic helper
1534 * as most subdrivers will use it
1536 if ((drive->id->capability & 1) == 0)
1538 if (HWIF(drive)->ide_dma_check == NULL)
1540 HWIF(drive)->ide_dma_check(drive);
1543 rq->pm->pm_step = ide_pm_state_completed;
1547 static void idedisk_setup (ide_drive_t *drive)
1549 struct hd_driveid *id = drive->id;
1550 unsigned long long capacity;
1552 idedisk_add_settings(drive);
1554 if (drive->id_read == 0)
1558 * CompactFlash cards and their brethern look just like hard drives
1559 * to us, but they are removable and don't have a doorlock mechanism.
1561 if (drive->removable && !(drive->is_flash)) {
1563 * Removable disks (eg. SYQUEST); ignore 'WD' drives
1565 if (id->model[0] != 'W' || id->model[1] != 'D') {
1566 drive->doorlocking = 1;
1570 (void)set_lba_addressing(drive, 1);
1572 if (drive->addressing == 1) {
1573 ide_hwif_t *hwif = HWIF(drive);
1576 if (max_s > hwif->rqsize)
1577 max_s = hwif->rqsize;
1579 blk_queue_max_sectors(drive->queue, max_s);
1582 printk("%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
1584 /* Extract geometry if we did not already have one for the drive */
1585 if (!drive->cyl || !drive->head || !drive->sect) {
1586 drive->cyl = drive->bios_cyl = id->cyls;
1587 drive->head = drive->bios_head = id->heads;
1588 drive->sect = drive->bios_sect = id->sectors;
1591 /* Handle logical geometry translation by the drive */
1592 if ((id->field_valid & 1) && id->cur_cyls &&
1593 id->cur_heads && (id->cur_heads <= 16) && id->cur_sectors) {
1594 drive->cyl = id->cur_cyls;
1595 drive->head = id->cur_heads;
1596 drive->sect = id->cur_sectors;
1599 /* Use physical geometry if what we have still makes no sense */
1600 if (drive->head > 16 && id->heads && id->heads <= 16) {
1601 drive->cyl = id->cyls;
1602 drive->head = id->heads;
1603 drive->sect = id->sectors;
1606 /* calculate drive capacity, and select LBA if possible */
1607 init_idedisk_capacity (drive);
1609 /* limit drive capacity to 137GB if LBA48 cannot be used */
1610 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
1611 printk("%s: cannot use LBA48 - full capacity "
1612 "%llu sectors (%llu MB)\n",
1613 drive->name, (unsigned long long)drive->capacity64,
1614 sectors_to_MB(drive->capacity64));
1615 drive->capacity64 = 1ULL << 28;
1619 * if possible, give fdisk access to more of the drive,
1620 * by correcting bios_cyls:
1622 capacity = idedisk_capacity (drive);
1623 if (!drive->forced_geom) {
1625 if (idedisk_supports_lba48(drive->id)) {
1627 drive->bios_sect = 63;
1628 drive->bios_head = 255;
1631 if (drive->bios_sect && drive->bios_head) {
1632 unsigned int cap0 = capacity; /* truncate to 32 bits */
1633 unsigned int cylsz, cyl;
1635 if (cap0 != capacity)
1636 drive->bios_cyl = 65535;
1638 cylsz = drive->bios_sect * drive->bios_head;
1642 if (cyl > drive->bios_cyl)
1643 drive->bios_cyl = cyl;
1647 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
1648 drive->name, capacity, sectors_to_MB(capacity));
1650 /* Only print cache size when it was specified */
1652 printk (" w/%dKiB Cache", id->buf_size/2);
1654 printk(", CHS=%d/%d/%d",
1655 drive->bios_cyl, drive->bios_head, drive->bios_sect);
1656 if (drive->using_dma)
1657 (void) HWIF(drive)->ide_dma_verbose(drive);
1660 drive->mult_count = 0;
1661 if (id->max_multsect) {
1662 #ifdef CONFIG_IDEDISK_MULTI_MODE
1663 id->multsect = ((id->max_multsect/2) > 1) ? id->max_multsect : 0;
1664 id->multsect_valid = id->multsect ? 1 : 0;
1665 drive->mult_req = id->multsect_valid ? id->max_multsect : INITIAL_MULT_COUNT;
1666 drive->special.b.set_multmode = drive->mult_req ? 1 : 0;
1667 #else /* original, pre IDE-NFG, per request of AC */
1668 drive->mult_req = INITIAL_MULT_COUNT;
1669 if (drive->mult_req > id->max_multsect)
1670 drive->mult_req = id->max_multsect;
1671 if (drive->mult_req || ((id->multsect_valid & 1) && id->multsect))
1672 drive->special.b.set_multmode = 1;
1673 #endif /* CONFIG_IDEDISK_MULTI_MODE */
1675 drive->no_io_32bit = id->dword_io ? 1 : 0;
1677 /* write cache enabled? */
1678 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
1681 write_cache(drive, 1);
1683 #ifdef CONFIG_BLK_DEV_IDE_TCQ_DEFAULT
1684 if (drive->using_dma)
1685 __ide_dma_queued_on(drive);
1689 static void ide_cacheflush_p(ide_drive_t *drive)
1691 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
1694 if (do_idedisk_flushcache(drive))
1695 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
1698 static int idedisk_cleanup (ide_drive_t *drive)
1700 struct gendisk *g = drive->disk;
1701 ide_cacheflush_p(drive);
1702 if (ide_unregister_subdriver(drive))
1705 drive->devfs_name[0] = '\0';
1710 static int idedisk_attach(ide_drive_t *drive);
1712 static void ide_device_shutdown(struct device *dev)
1714 ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);
1716 if (system_state == SYSTEM_RESTART) {
1717 ide_cacheflush_p(drive);
1721 printk("Shutdown: %s\n", drive->name);
1722 dev->bus->suspend(dev, PM_SUSPEND_STANDBY);
1726 * IDE subdriver functions, registered with ide.c
1728 static ide_driver_t idedisk_driver = {
1729 .owner = THIS_MODULE,
1731 .shutdown = ide_device_shutdown,
1734 .version = IDEDISK_VERSION,
1737 .supports_dsc_overlap = 0,
1738 .cleanup = idedisk_cleanup,
1739 .do_request = ide_do_rw_disk,
1740 .sense = idedisk_dump_status,
1741 .error = idedisk_error,
1742 .abort = idedisk_abort,
1743 .pre_reset = idedisk_pre_reset,
1744 .capacity = idedisk_capacity,
1745 .special = idedisk_special,
1746 .proc = idedisk_proc,
1747 .attach = idedisk_attach,
1748 .drives = LIST_HEAD_INIT(idedisk_driver.drives),
1749 .start_power_step = idedisk_start_power_step,
1750 .complete_power_step = idedisk_complete_power_step,
1753 static int idedisk_open(struct inode *inode, struct file *filp)
1755 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
1757 if (drive->removable && drive->usage == 1) {
1759 memset(&args, 0, sizeof(ide_task_t));
1760 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK;
1761 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1762 args.handler = &task_no_data_intr;
1763 check_disk_change(inode->i_bdev);
1765 * Ignore the return code from door_lock,
1766 * since the open() has already succeeded,
1767 * and the door_lock is irrelevant at this point.
1769 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1770 drive->doorlocking = 0;
1775 static int idedisk_release(struct inode *inode, struct file *filp)
1777 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
1778 if (drive->usage == 1)
1779 ide_cacheflush_p(drive);
1780 if (drive->removable && drive->usage == 1) {
1782 memset(&args, 0, sizeof(ide_task_t));
1783 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK;
1784 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1785 args.handler = &task_no_data_intr;
1786 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1787 drive->doorlocking = 0;
1793 static int idedisk_ioctl(struct inode *inode, struct file *file,
1794 unsigned int cmd, unsigned long arg)
1796 struct block_device *bdev = inode->i_bdev;
1797 return generic_ide_ioctl(bdev, cmd, arg);
1800 static int idedisk_media_changed(struct gendisk *disk)
1802 ide_drive_t *drive = disk->private_data;
1804 /* do not scan partitions twice if this is a removable device */
1805 if (drive->attach) {
1809 /* if removable, always assume it was changed */
1810 return drive->removable;
1813 static int idedisk_revalidate_disk(struct gendisk *disk)
1815 ide_drive_t *drive = disk->private_data;
1816 set_capacity(disk, current_capacity(drive));
1820 static struct block_device_operations idedisk_ops = {
1821 .owner = THIS_MODULE,
1822 .open = idedisk_open,
1823 .release = idedisk_release,
1824 .ioctl = idedisk_ioctl,
1825 .media_changed = idedisk_media_changed,
1826 .revalidate_disk= idedisk_revalidate_disk
1829 MODULE_DESCRIPTION("ATA DISK Driver");
1831 static int idedisk_attach(ide_drive_t *drive)
1833 struct gendisk *g = drive->disk;
1835 /* strstr("foo", "") is non-NULL */
1836 if (!strstr("ide-disk", drive->driver_req))
1838 if (!drive->present)
1840 if (drive->media != ide_disk)
1843 if (ide_register_subdriver(drive, &idedisk_driver)) {
1844 printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.c\n", drive->name);
1847 DRIVER(drive)->busy++;
1848 idedisk_setup(drive);
1849 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1850 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1851 drive->name, drive->head);
1852 ide_cacheflush_p(drive);
1853 ide_unregister_subdriver(drive);
1854 DRIVER(drive)->busy--;
1857 DRIVER(drive)->busy--;
1858 g->minors = 1 << PARTN_BITS;
1859 strcpy(g->devfs_name, drive->devfs_name);
1860 g->driverfs_dev = &drive->gendev;
1861 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1862 set_capacity(g, current_capacity(drive));
1863 g->fops = &idedisk_ops;
1871 static void __exit idedisk_exit (void)
1873 ide_unregister_driver(&idedisk_driver);
1876 static int idedisk_init (void)
1878 return ide_register_driver(&idedisk_driver);
1881 module_init(idedisk_init);
1882 module_exit(idedisk_exit);
1883 MODULE_LICENSE("GPL");