patch-2.4.21 linux-2.4.21/drivers/ide/ide-disk.c
Next file: linux-2.4.21/drivers/ide/ide-dma.c
Previous file: linux-2.4.21/drivers/ide/ide-default.c
Back to the patch index
Back to the overall index
- Lines: 2092
- Date:
2003-06-13 07:51:33.000000000 -0700
- Orig file:
linux-2.4.20/drivers/ide/ide-disk.c
- Orig date:
2002-11-28 15:53:13.000000000 -0800
diff -urN linux-2.4.20/drivers/ide/ide-disk.c linux-2.4.21/drivers/ide/ide-disk.c
@@ -1,7 +1,12 @@
/*
- * linux/drivers/ide/ide-disk.c Version 1.10 June 9, 2000
+ * linux/drivers/ide/ide-disk.c Version 1.18 Mar 05, 2003
*
* Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
+ * Copyright (C) 1998-2002 Linux ATA Developemt
+ * Andre Hedrick <andre@linux-ide.org>
+ * Copyright (C) 2003 Red Hat <alan@redhat.com>
+ *
+ *
*/
/*
@@ -29,10 +34,16 @@
* Version 1.10 request queue changes, Ultra DMA 100
* Version 1.11 added 48-bit lba
* Version 1.12 adding taskfile io access method
- * Highmem I/O support, Jens Axboe <axboe@suse.de>
+ * Version 1.13 added standby and flush-cache for notifier
+ * Version 1.14 added acoustic-wcache
+ * Version 1.15 convert all calls to ide_raw_taskfile
+ * since args will return register content.
+ * Version 1.16 added suspend-resume-checkpower
+ * Version 1.17 do flush on standy, do flush on ATA < ATA6
+ * fix wcache setup.
*/
-#define IDEDISK_VERSION "1.12"
+#define IDEDISK_VERSION "1.17"
#undef REALLY_SLOW_IO /* most systems can safely undef this */
@@ -49,6 +60,9 @@
#include <linux/genhd.h>
#include <linux/slab.h>
#include <linux/delay.h>
+
+#define _IDE_DISK
+
#include <linux/ide.h>
#include <asm/byteorder.h>
@@ -56,48 +70,27 @@
#include <asm/uaccess.h>
#include <asm/io.h>
-#ifdef CONFIG_BLK_DEV_PDC4030
-#define IS_PDC4030_DRIVE (HWIF(drive)->chipset == ide_pdc4030)
-#else
-#define IS_PDC4030_DRIVE (0) /* auto-NULLs out pdc4030 code */
-#endif
+/* FIXME: some day we shouldnt need to look in here! */
-#ifdef CONFIG_IDE_TASKFILE_IO
-# undef __TASKFILE__IO /* define __TASKFILE__IO */
-#else /* CONFIG_IDE_TASKFILE_IO */
-# undef __TASKFILE__IO
-#endif /* CONFIG_IDE_TASKFILE_IO */
+#include "legacy/pdc4030.h"
-#ifndef __TASKFILE__IO
+static int driver_blocked;
-static void idedisk_bswap_data (void *buffer, int wcount)
+static inline u32 idedisk_read_24 (ide_drive_t *drive)
{
- u16 *p = buffer;
-
- while (wcount--) {
- *p = *p << 8 | *p >> 8; p++;
- *p = *p << 8 | *p >> 8; p++;
- }
-}
-
-static inline void idedisk_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
-{
- ide_input_data(drive, buffer, wcount);
- if (drive->bswap)
- idedisk_bswap_data(buffer, wcount);
-}
-
-static inline void idedisk_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
-{
- if (drive->bswap) {
- idedisk_bswap_data(buffer, wcount);
- ide_output_data(drive, buffer, wcount);
- idedisk_bswap_data(buffer, wcount);
- } else
- ide_output_data(drive, buffer, wcount);
+#if 0
+ return (HWIF(drive)->INB(IDE_HCYL_REG)<<16) |
+ (HWIF(drive)->INB(IDE_LCYL_REG)<<8) |
+ HWIF(drive)->INB(IDE_SECTOR_REG);
+#else
+ u8 hcyl = HWIF(drive)->INB(IDE_HCYL_REG);
+ u8 lcyl = HWIF(drive)->INB(IDE_LCYL_REG);
+ u8 sect = HWIF(drive)->INB(IDE_SECTOR_REG);
+ return (hcyl<<16)|(lcyl<<8)|sect;
+#endif
}
-#endif /* __TASKFILE__IO */
+static int idedisk_end_request(ide_drive_t *drive, int uptodate);
/*
* lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
@@ -127,7 +120,7 @@
|| (id->cyls == 4092 && id->cur_cyls == 16383)) &&
id->sectors == 63 &&
(id->heads == 15 || id->heads == 16) &&
- id->lba_capacity >= 16383*63*id->heads)
+ (id->lba_capacity >= 16383*63*id->heads))
return 1;
lba_sects = id->lba_capacity;
@@ -149,31 +142,30 @@
return 0; /* lba_capacity value may be bad */
}
-#ifndef __TASKFILE__IO
+#ifndef CONFIG_IDE_TASKFILE_IO
/*
* read_intr() is the handler for disk read/multread interrupts
*/
static ide_startstop_t read_intr (ide_drive_t *drive)
{
- byte stat;
- int i;
- unsigned int msect, nsect;
- unsigned long flags;
+ ide_hwif_t *hwif = HWIF(drive);
+ u32 i = 0, nsect = 0, msect = drive->mult_count;
struct request *rq;
+ unsigned long flags;
+ u8 stat;
char *to;
/* new way for dealing with premature shared PCI interrupts */
- if (!OK_STAT(stat=GET_STAT(),DATA_READY,BAD_R_STAT)) {
+ if (!OK_STAT(stat=hwif->INB(IDE_STATUS_REG),DATA_READY,BAD_R_STAT)) {
if (stat & (ERR_STAT|DRQ_STAT)) {
- return ide_error(drive, "read_intr", stat);
+ return DRIVER(drive)->error(drive, "read_intr", stat);
}
/* no data yet, so wait for another interrupt */
ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);
return ide_started;
}
-
- msect = drive->mult_count;
+
read_next:
rq = HWGROUP(drive)->rq;
if (msect) {
@@ -183,22 +175,29 @@
} else
nsect = 1;
to = ide_map_buffer(rq, &flags);
- idedisk_input_data(drive, to, nsect * SECTOR_WORDS);
+ taskfile_input_data(drive, to, nsect * SECTOR_WORDS);
+
#ifdef DEBUG
printk("%s: read: sectors(%ld-%ld), buffer=0x%08lx, remaining=%ld\n",
drive->name, rq->sector, rq->sector+nsect-1,
(unsigned long) rq->buffer+(nsect<<9), rq->nr_sectors-nsect);
#endif
+
ide_unmap_buffer(to, &flags);
rq->sector += nsect;
rq->errors = 0;
i = (rq->nr_sectors -= nsect);
if (((long)(rq->current_nr_sectors -= nsect)) <= 0)
- ide_end_request(1, HWGROUP(drive));
+ idedisk_end_request(drive, 1);
+ /*
+ * Another BH Page walker and DATA INTERGRITY Questioned on ERROR.
+ * If passed back up on multimode read, BAD DATA could be ACKED
+ * to FILE SYSTEMS above ...
+ */
if (i > 0) {
if (msect)
goto read_next;
- ide_set_handler (drive, &read_intr, WAIT_CMD, NULL);
+ ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);
return ide_started;
}
return ide_stopped;
@@ -209,13 +208,16 @@
*/
static ide_startstop_t write_intr (ide_drive_t *drive)
{
- byte stat;
- int i;
- ide_hwgroup_t *hwgroup = HWGROUP(drive);
- struct request *rq = hwgroup->rq;
-
- if (!OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
- printk("%s: write_intr error1: nr_sectors=%ld, stat=0x%02x\n", drive->name, rq->nr_sectors, stat);
+ ide_hwgroup_t *hwgroup = HWGROUP(drive);
+ ide_hwif_t *hwif = HWIF(drive);
+ struct request *rq = hwgroup->rq;
+ u32 i = 0;
+ u8 stat;
+
+ if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG),
+ DRIVE_READY, drive->bad_wstat)) {
+ printk("%s: write_intr error1: nr_sectors=%ld, stat=0x%02x\n",
+ drive->name, rq->nr_sectors, stat);
} else {
#ifdef DEBUG
printk("%s: write: sector %ld, buffer=0x%08lx, remaining=%ld\n",
@@ -228,20 +230,21 @@
i = --rq->nr_sectors;
--rq->current_nr_sectors;
if (((long)rq->current_nr_sectors) <= 0)
- ide_end_request(1, hwgroup);
+ idedisk_end_request(drive, 1);
if (i > 0) {
unsigned long flags;
char *to = ide_map_buffer(rq, &flags);
- idedisk_output_data (drive, to, SECTOR_WORDS);
+ taskfile_output_data(drive, to, SECTOR_WORDS);
ide_unmap_buffer(to, &flags);
- ide_set_handler (drive, &write_intr, WAIT_CMD, NULL);
+ ide_set_handler(drive, &write_intr, WAIT_CMD, NULL);
return ide_started;
}
return ide_stopped;
}
- return ide_stopped; /* the original code did this here (?) */
+ /* the original code did this here (?) */
+ return ide_stopped;
}
- return ide_error(drive, "write_intr", stat);
+ return DRIVER(drive)->error(drive, "write_intr", stat);
}
/*
@@ -254,22 +257,27 @@
* and IRQ context. The IRQ can happen any time after we've output the
* full "mcount" number of sectors, so we must make sure we update the
* state _before_ we output the final part of the data!
+ *
+ * The update and return to BH is a BLOCK Layer Fakey to get more data
+ * to satisfy the hardware atomic segment. If the hardware atomic segment
+ * is shorter or smaller than the BH segment then we should be OKAY.
+ * This is only valid if we can rewind the rq->current_nr_sectors counter.
*/
int ide_multwrite (ide_drive_t *drive, unsigned int mcount)
{
- ide_hwgroup_t *hwgroup= HWGROUP(drive);
- struct request *rq = &hwgroup->wrq;
+ ide_hwgroup_t *hwgroup = HWGROUP(drive);
+ struct request *rq = &hwgroup->wrq;
do {
char *buffer;
int nsect = rq->current_nr_sectors;
unsigned long flags;
-
+
if (nsect > mcount)
nsect = mcount;
mcount -= nsect;
-
buffer = ide_map_buffer(rq, &flags);
+
rq->sector += nsect;
rq->nr_sectors -= nsect;
rq->current_nr_sectors -= nsect;
@@ -285,6 +293,7 @@
rq->bh = bh;
rq->current_nr_sectors = bh->b_size >> 9;
rq->hard_cur_sectors = rq->current_nr_sectors;
+ rq->buffer = bh->b_data;
}
}
@@ -292,7 +301,7 @@
* Ok, we're all setup for the interrupt
* re-entering us on the last transfer.
*/
- idedisk_output_data(drive, buffer, nsect<<7);
+ taskfile_output_data(drive, buffer, nsect<<7);
ide_unmap_buffer(buffer, &flags);
} while (mcount);
@@ -304,12 +313,14 @@
*/
static ide_startstop_t multwrite_intr (ide_drive_t *drive)
{
- byte stat;
- int i;
- ide_hwgroup_t *hwgroup = HWGROUP(drive);
- struct request *rq = &hwgroup->wrq;
+ ide_hwgroup_t *hwgroup = HWGROUP(drive);
+ ide_hwif_t *hwif = HWIF(drive);
+ struct request *rq = &hwgroup->wrq;
+ u32 i = 0;
+ u8 stat;
- if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
+ if (OK_STAT(stat = hwif->INB(IDE_STATUS_REG),
+ DRIVE_READY, drive->bad_wstat)) {
if (stat & DRQ_STAT) {
/*
* The drive wants data. Remember rq is the copy
@@ -318,7 +329,7 @@
if (rq->nr_sectors) {
if (ide_multwrite(drive, drive->mult_count))
return ide_stopped;
- ide_set_handler (drive, &multwrite_intr, WAIT_CMD, NULL);
+ ide_set_handler(drive, &multwrite_intr, WAIT_CMD, NULL);
return ide_started;
}
} else {
@@ -328,256 +339,49 @@
*/
if (!rq->nr_sectors) { /* all done? */
rq = hwgroup->rq;
- for (i = rq->nr_sectors; i > 0;){
+ for (i = rq->nr_sectors; i > 0;) {
i -= rq->current_nr_sectors;
- ide_end_request(1, hwgroup);
+ idedisk_end_request(drive, 1);
}
return ide_stopped;
}
}
- return ide_stopped; /* the original code did this here (?) */
+ /* the original code did this here (?) */
+ return ide_stopped;
}
- return ide_error(drive, "multwrite_intr", stat);
+ return DRIVER(drive)->error(drive, "multwrite_intr", stat);
}
-#endif /* __TASKFILE__IO */
-#ifdef __TASKFILE__IO
-
-static ide_startstop_t chs_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block);
-static ide_startstop_t lba_28_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block);
-static ide_startstop_t lba_48_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long long block);
/*
- * do_rw_disk() issues READ and WRITE commands to a disk,
+ * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
* using LBA if supported, or CHS otherwise, to address sectors.
* It also takes care of issuing special DRIVE_CMDs.
*/
-static ide_startstop_t do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
-{
- if (rq->cmd == READ)
- goto good_command;
- if (rq->cmd == WRITE)
- goto good_command;
-
- printk(KERN_ERR "%s: bad command: %d\n", drive->name, rq->cmd);
- ide_end_request(0, HWGROUP(drive));
- return ide_stopped;
-
-good_command:
-
-#ifdef CONFIG_BLK_DEV_PDC4030
- if (IS_PDC4030_DRIVE) {
- extern ide_startstop_t promise_rw_disk(ide_drive_t *, struct request *, unsigned long);
- return promise_rw_disk(drive, rq, block);
- }
-#endif /* CONFIG_BLK_DEV_PDC4030 */
-
- if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) /* 48-bit LBA */
- return lba_48_rw_disk(drive, rq, (unsigned long long) block);
- if (drive->select.b.lba) /* 28-bit LBA */
- return lba_28_rw_disk(drive, rq, (unsigned long) block);
-
- /* 28-bit CHS : DIE DIE DIE piece of legacy crap!!! */
- return chs_rw_disk(drive, rq, (unsigned long) block);
-}
-
-static task_ioreg_t get_command (ide_drive_t *drive, int cmd)
-{
- int lba48bit = (drive->id->cfs_enable_2 & 0x0400) ? 1 : 0;
-
-#if 1
- lba48bit = drive->addressing;
-#endif
-
- if ((cmd == READ) && (drive->using_dma))
- return (lba48bit) ? WIN_READDMA_EXT : WIN_READDMA;
- else if ((cmd == READ) && (drive->mult_count))
- return (lba48bit) ? WIN_MULTREAD_EXT : WIN_MULTREAD;
- else if (cmd == READ)
- return (lba48bit) ? WIN_READ_EXT : WIN_READ;
- else if ((cmd == WRITE) && (drive->using_dma))
- return (lba48bit) ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
- else if ((cmd == WRITE) && (drive->mult_count))
- return (lba48bit) ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
- else if (cmd == WRITE)
- return (lba48bit) ? WIN_WRITE_EXT : WIN_WRITE;
- else
- return WIN_NOP;
-}
-
-static ide_startstop_t chs_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
-{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- ide_task_t args;
-
- task_ioreg_t command = get_command(drive, rq->cmd);
- unsigned int track = (block / drive->sect);
- unsigned int sect = (block % drive->sect) + 1;
- unsigned int head = (track % drive->head);
- unsigned int cyl = (track / drive->head);
-
- memset(&taskfile, 0, sizeof(task_struct_t));
- memset(&hobfile, 0, sizeof(hob_struct_t));
-
- taskfile.sector_count = (rq->nr_sectors==256)?0x00:rq->nr_sectors;
- taskfile.sector_number = sect;
- taskfile.low_cylinder = cyl;
- taskfile.high_cylinder = (cyl>>8);
- taskfile.device_head = head;
- taskfile.device_head |= drive->select.all;
- taskfile.command = command;
-
-#ifdef DEBUG
- printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
- if (lba) printk("LBAsect=%lld, ", block);
- else printk("CHS=%d/%d/%d, ", cyl, head, sect);
- printk("sectors=%ld, ", rq->nr_sectors);
- printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
-#endif
-
- memcpy(args.tfRegister, &taskfile, sizeof(struct hd_drive_task_hdr));
- memcpy(args.hobRegister, &hobfile, sizeof(struct hd_drive_hob_hdr));
- args.command_type = ide_cmd_type_parser(&args);
- args.prehandler = ide_pre_handler_parser(&taskfile, &hobfile);
- args.handler = ide_handler_parser(&taskfile, &hobfile);
- args.posthandler = NULL;
- args.rq = (struct request *) rq;
- args.block = block;
- rq->special = NULL;
- rq->special = (ide_task_t *)&args;
-
- return do_rw_taskfile(drive, &args);
-}
-
-static ide_startstop_t lba_28_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
-{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- ide_task_t args;
-
- task_ioreg_t command = get_command(drive, rq->cmd);
-
- memset(&taskfile, 0, sizeof(task_struct_t));
- memset(&hobfile, 0, sizeof(hob_struct_t));
-
- taskfile.sector_count = (rq->nr_sectors==256)?0x00:rq->nr_sectors;
- taskfile.sector_number = block;
- taskfile.low_cylinder = (block>>=8);
- taskfile.high_cylinder = (block>>=8);
- taskfile.device_head = ((block>>8)&0x0f);
- taskfile.device_head |= drive->select.all;
- taskfile.command = command;
-
-
-#ifdef DEBUG
- printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
- if (lba) printk("LBAsect=%lld, ", block);
- else printk("CHS=%d/%d/%d, ", cyl, head, sect);
- printk("sectors=%ld, ", rq->nr_sectors);
- printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
-#endif
-
- memcpy(args.tfRegister, &taskfile, sizeof(struct hd_drive_task_hdr));
- memcpy(args.hobRegister, &hobfile, sizeof(struct hd_drive_hob_hdr));
- args.command_type = ide_cmd_type_parser(&args);
- args.prehandler = ide_pre_handler_parser(&taskfile, &hobfile);
- args.handler = ide_handler_parser(&taskfile, &hobfile);
- args.posthandler = NULL;
- args.rq = (struct request *) rq;
- args.block = block;
- rq->special = NULL;
- rq->special = (ide_task_t *)&args;
-
- return do_rw_taskfile(drive, &args);
-}
-
-/*
- * 268435455 == 137439 MB or 28bit limit
- * 320173056 == 163929 MB or 48bit addressing
- * 1073741822 == 549756 MB or 48bit addressing fake drive
- */
-static ide_startstop_t lba_48_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long long block)
+ide_startstop_t __ide_do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- ide_task_t args;
-
- task_ioreg_t command = get_command(drive, rq->cmd);
-
- memset(&taskfile, 0, sizeof(task_struct_t));
- memset(&hobfile, 0, sizeof(hob_struct_t));
-
- taskfile.sector_count = rq->nr_sectors;
- hobfile.sector_count = (rq->nr_sectors>>8);
-
- if (rq->nr_sectors == 65536) {
- taskfile.sector_count = 0x00;
- hobfile.sector_count = 0x00;
- }
-
- taskfile.sector_number = block; /* low lba */
- taskfile.low_cylinder = (block>>=8); /* mid lba */
- taskfile.high_cylinder = (block>>=8); /* hi lba */
- hobfile.sector_number = (block>>=8); /* low lba */
- hobfile.low_cylinder = (block>>=8); /* mid lba */
- hobfile.high_cylinder = (block>>=8); /* hi lba */
- taskfile.device_head = drive->select.all;
- hobfile.device_head = taskfile.device_head;
- hobfile.control = (drive->ctl|0x80);
- taskfile.command = command;
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 lba48 = (drive->addressing == 1) ? 1 : 0;
+ task_ioreg_t command = WIN_NOP;
+ ata_nsector_t nsectors;
-#ifdef DEBUG
- printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
- if (lba) printk("LBAsect=%lld, ", block);
- else printk("CHS=%d/%d/%d, ", cyl, head, sect);
- printk("sectors=%ld, ", rq->nr_sectors);
- printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
-#endif
+ nsectors.all = (u16) rq->nr_sectors;
- memcpy(args.tfRegister, &taskfile, sizeof(struct hd_drive_task_hdr));
- memcpy(args.hobRegister, &hobfile, sizeof(struct hd_drive_hob_hdr));
- args.command_type = ide_cmd_type_parser(&args);
- args.prehandler = ide_pre_handler_parser(&taskfile, &hobfile);
- args.handler = ide_handler_parser(&taskfile, &hobfile);
- args.posthandler = NULL;
- args.rq = (struct request *) rq;
- args.block = block;
- rq->special = NULL;
- rq->special = (ide_task_t *)&args;
+ if (driver_blocked)
+ panic("Request while ide driver is blocked?");
- return do_rw_taskfile(drive, &args);
-}
-
-#else /* !__TASKFILE__IO */
-/*
- * do_rw_disk() issues READ and WRITE commands to a disk,
- * using LBA if supported, or CHS otherwise, to address sectors.
- * It also takes care of issuing special DRIVE_CMDs.
- */
-static ide_startstop_t do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
-{
if (IDE_CONTROL_REG)
- OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
+ hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
-#ifdef CONFIG_BLK_DEV_PDC4030
- if (drive->select.b.lba || IS_PDC4030_DRIVE) {
-#else /* !CONFIG_BLK_DEV_PDC4030 */
if (drive->select.b.lba) {
-#endif /* CONFIG_BLK_DEV_PDC4030 */
-
- if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
+ if (drive->addressing == 1) {
task_ioreg_t tasklets[10];
tasklets[0] = 0;
tasklets[1] = 0;
- tasklets[2] = rq->nr_sectors;
- tasklets[3] = (rq->nr_sectors>>8);
- if (rq->nr_sectors == 65536) {
- tasklets[2] = 0x00;
- tasklets[3] = 0x00;
- }
+ tasklets[2] = nsectors.b.low;
+ tasklets[3] = nsectors.b.high;
tasklets[4] = (task_ioreg_t) block;
tasklets[5] = (task_ioreg_t) (block>>8);
tasklets[6] = (task_ioreg_t) (block>>16);
@@ -587,7 +391,8 @@
// tasklets[8] = (task_ioreg_t) (block>>32);
// tasklets[9] = (task_ioreg_t) (block>>40);
#ifdef DEBUG
- printk("%s: %sing: LBAsect=%lu, sectors=%ld, buffer=0x%08lx, LBAsect=0x%012lx\n",
+ printk("%s: %sing: LBAsect=%lu, sectors=%ld, "
+ "buffer=0x%08lx, LBAsect=0x%012lx\n",
drive->name,
(rq->cmd==READ)?"read":"writ",
block,
@@ -599,87 +404,88 @@
tasklets[9], tasklets[8], tasklets[7],
tasklets[6], tasklets[5], tasklets[4]);
#endif
- OUT_BYTE(tasklets[1], IDE_FEATURE_REG);
- OUT_BYTE(tasklets[3], IDE_NSECTOR_REG);
- OUT_BYTE(tasklets[7], IDE_SECTOR_REG);
- OUT_BYTE(tasklets[8], IDE_LCYL_REG);
- OUT_BYTE(tasklets[9], IDE_HCYL_REG);
-
- OUT_BYTE(tasklets[0], IDE_FEATURE_REG);
- OUT_BYTE(tasklets[2], IDE_NSECTOR_REG);
- OUT_BYTE(tasklets[4], IDE_SECTOR_REG);
- OUT_BYTE(tasklets[5], IDE_LCYL_REG);
- OUT_BYTE(tasklets[6], IDE_HCYL_REG);
- OUT_BYTE(0x00|drive->select.all,IDE_SELECT_REG);
+ hwif->OUTB(tasklets[1], IDE_FEATURE_REG);
+ hwif->OUTB(tasklets[3], IDE_NSECTOR_REG);
+ hwif->OUTB(tasklets[7], IDE_SECTOR_REG);
+ hwif->OUTB(tasklets[8], IDE_LCYL_REG);
+ hwif->OUTB(tasklets[9], IDE_HCYL_REG);
+
+ hwif->OUTB(tasklets[0], IDE_FEATURE_REG);
+ hwif->OUTB(tasklets[2], IDE_NSECTOR_REG);
+ hwif->OUTB(tasklets[4], IDE_SECTOR_REG);
+ hwif->OUTB(tasklets[5], IDE_LCYL_REG);
+ hwif->OUTB(tasklets[6], IDE_HCYL_REG);
+ hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);
} else {
#ifdef DEBUG
- printk("%s: %sing: LBAsect=%ld, sectors=%ld, buffer=0x%08lx\n",
+ printk("%s: %sing: LBAsect=%ld, sectors=%ld, "
+ "buffer=0x%08lx\n",
drive->name, (rq->cmd==READ)?"read":"writ",
- block, rq->nr_sectors, (unsigned long) rq->buffer);
+ block, rq->nr_sectors,
+ (unsigned long) rq->buffer);
#endif
- OUT_BYTE(0x00, IDE_FEATURE_REG);
- OUT_BYTE((rq->nr_sectors==256)?0x00:rq->nr_sectors,IDE_NSECTOR_REG);
- OUT_BYTE(block,IDE_SECTOR_REG);
- OUT_BYTE(block>>=8,IDE_LCYL_REG);
- OUT_BYTE(block>>=8,IDE_HCYL_REG);
- OUT_BYTE(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
+ hwif->OUTB(0x00, IDE_FEATURE_REG);
+ hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
+ hwif->OUTB(block, IDE_SECTOR_REG);
+ hwif->OUTB(block>>=8, IDE_LCYL_REG);
+ hwif->OUTB(block>>=8, IDE_HCYL_REG);
+ hwif->OUTB(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
}
} else {
unsigned int sect,head,cyl,track;
track = block / drive->sect;
sect = block % drive->sect + 1;
- OUT_BYTE(sect,IDE_SECTOR_REG);
+ hwif->OUTB(sect, IDE_SECTOR_REG);
head = track % drive->head;
cyl = track / drive->head;
- OUT_BYTE(0x00, IDE_FEATURE_REG);
- OUT_BYTE((rq->nr_sectors==256)?0x00:rq->nr_sectors,IDE_NSECTOR_REG);
- OUT_BYTE(cyl,IDE_LCYL_REG);
- OUT_BYTE(cyl>>8,IDE_HCYL_REG);
- OUT_BYTE(head|drive->select.all,IDE_SELECT_REG);
+ hwif->OUTB(0x00, IDE_FEATURE_REG);
+ hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
+ hwif->OUTB(cyl, IDE_LCYL_REG);
+ hwif->OUTB(cyl>>8, IDE_HCYL_REG);
+ hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);
#ifdef DEBUG
printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",
drive->name, (rq->cmd==READ)?"read":"writ", cyl,
head, sect, rq->nr_sectors, (unsigned long) rq->buffer);
#endif
}
-#ifdef CONFIG_BLK_DEV_PDC4030
- if (IS_PDC4030_DRIVE) {
- extern ide_startstop_t do_pdc4030_io(ide_drive_t *, struct request *);
- return do_pdc4030_io (drive, rq);
- }
-#endif /* CONFIG_BLK_DEV_PDC4030 */
- if (rq->cmd == READ) {
+
+ if (rq_data_dir(rq) == READ) {
#ifdef CONFIG_BLK_DEV_IDEDMA
- if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_read, drive)))
+ if (drive->using_dma && !hwif->ide_dma_read(drive))
return ide_started;
#endif /* CONFIG_BLK_DEV_IDEDMA */
- ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);
- if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
- OUT_BYTE(drive->mult_count ? WIN_MULTREAD_EXT : WIN_READ_EXT, IDE_COMMAND_REG);
- } else {
- OUT_BYTE(drive->mult_count ? WIN_MULTREAD : WIN_READ, IDE_COMMAND_REG);
- }
+ if (HWGROUP(drive)->handler != NULL)
+ BUG();
+
+ command = ((drive->mult_count) ?
+ ((lba48) ? WIN_MULTREAD_EXT : WIN_MULTREAD) :
+ ((lba48) ? WIN_READ_EXT : WIN_READ));
+
+ ide_execute_command(drive, command, &read_intr, WAIT_CMD, NULL);
return ide_started;
- }
- if (rq->cmd == WRITE) {
+ } else if (rq_data_dir(rq) == WRITE) {
ide_startstop_t startstop;
#ifdef CONFIG_BLK_DEV_IDEDMA
- if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_write, drive)))
+ if (drive->using_dma && !(HWIF(drive)->ide_dma_write(drive)))
return ide_started;
#endif /* CONFIG_BLK_DEV_IDEDMA */
- if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
- OUT_BYTE(drive->mult_count ? WIN_MULTWRITE_EXT : WIN_WRITE_EXT, IDE_COMMAND_REG);
- } else {
- OUT_BYTE(drive->mult_count ? WIN_MULTWRITE : WIN_WRITE, IDE_COMMAND_REG);
- }
- if (ide_wait_stat(&startstop, drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
- printk(KERN_ERR "%s: no DRQ after issuing %s\n", drive->name,
+
+ command = ((drive->mult_count) ?
+ ((lba48) ? WIN_MULTWRITE_EXT : WIN_MULTWRITE) :
+ ((lba48) ? WIN_WRITE_EXT : WIN_WRITE));
+ hwif->OUTB(command, IDE_COMMAND_REG);
+
+ if (ide_wait_stat(&startstop, drive, DATA_READY,
+ drive->bad_wstat, WAIT_DRQ)) {
+ printk(KERN_ERR "%s: no DRQ after issuing %s\n",
+ drive->name,
drive->mult_count ? "MULTWRITE" : "WRITE");
return startstop;
}
if (!drive->unmask)
- __cli(); /* local CPU only */
+ local_irq_disable();
if (drive->mult_count) {
ide_hwgroup_t *hwgroup = HWGROUP(drive);
/*
@@ -690,6 +496,8 @@
* before returning. Fortunately, this NEVER happens (right?).
*
* Except when you get an error it seems...
+ *
+ * MAJOR DATA INTEGRITY BUG !!! only if we error
*/
hwgroup->wrq = *rq; /* scratchpad */
ide_set_handler(drive, &multwrite_intr, WAIT_CMD, NULL);
@@ -703,65 +511,268 @@
}
} else {
unsigned long flags;
- char *buffer = ide_map_buffer(rq, &flags);
- ide_set_handler (drive, &write_intr, WAIT_CMD, NULL);
- idedisk_output_data(drive, buffer, SECTOR_WORDS);
- ide_unmap_buffer(buffer, &flags);
+ char *to = ide_map_buffer(rq, &flags);
+ ide_set_handler(drive, &write_intr, WAIT_CMD, NULL);
+ taskfile_output_data(drive, to, SECTOR_WORDS);
+ ide_unmap_buffer(to, &flags);
}
return ide_started;
}
printk(KERN_ERR "%s: bad command: %d\n", drive->name, rq->cmd);
- ide_end_request(0, HWGROUP(drive));
+ idedisk_end_request(drive, 0);
return ide_stopped;
}
-#endif /* __TASKFILE__IO */
+
+#else /* CONFIG_IDE_TASKFILE_IO */
+
+static ide_startstop_t chs_rw_disk(ide_drive_t *, struct request *, unsigned long);
+static ide_startstop_t lba_28_rw_disk(ide_drive_t *, struct request *, unsigned long);
+static ide_startstop_t lba_48_rw_disk(ide_drive_t *, struct request *, unsigned long long);
+
+/*
+ * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
+ * using LBA if supported, or CHS otherwise, to address sectors.
+ * It also takes care of issuing special DRIVE_CMDs.
+ */
+ide_startstop_t __ide_do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
+{
+ if (!blk_fs_request(rq)) {
+ printk(KERN_ERR "%s: bad command: %d\n", drive->name, rq->cmd);
+ idedisk_end_request(drive, 0);
+ return ide_stopped;
+ }
+
+ /*
+ * 268435455 == 137439 MB or 28bit limit
+ *
+ * need to add split taskfile operations based on 28bit threshold.
+ */
+
+ if (drive->addressing == 1) /* 48-bit LBA */
+ return lba_48_rw_disk(drive, rq, (unsigned long long) block);
+ if (drive->select.b.lba) /* 28-bit LBA */
+ return lba_28_rw_disk(drive, rq, (unsigned long) block);
+
+ /* 28-bit CHS : DIE DIE DIE piece of legacy crap!!! */
+ return chs_rw_disk(drive, rq, (unsigned long) block);
+}
+
+static task_ioreg_t get_command (ide_drive_t *drive, int cmd)
+{
+ int lba48bit = (drive->id->cfs_enable_2 & 0x0400) ? 1 : 0;
+
+#if 1
+ lba48bit = (drive->addressing == 1) ? 1 : 0;
+#endif
+
+ if ((cmd == READ) && (drive->using_dma))
+ return (lba48bit) ? WIN_READDMA_EXT : WIN_READDMA;
+ else if ((cmd == READ) && (drive->mult_count))
+ return (lba48bit) ? WIN_MULTREAD_EXT : WIN_MULTREAD;
+ else if (cmd == READ)
+ return (lba48bit) ? WIN_READ_EXT : WIN_READ;
+ else if ((cmd == WRITE) && (drive->using_dma))
+ return (lba48bit) ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
+ else if ((cmd == WRITE) && (drive->mult_count))
+ return (lba48bit) ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
+ else if (cmd == WRITE)
+ return (lba48bit) ? WIN_WRITE_EXT : WIN_WRITE;
+ else
+ return WIN_NOP;
+}
+
+static ide_startstop_t chs_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
+{
+ ide_task_t args;
+ int sectors;
+ ata_nsector_t nsectors;
+ task_ioreg_t command = get_command(drive, rq_data_dir(rq));
+ unsigned int track = (block / drive->sect);
+ unsigned int sect = (block % drive->sect) + 1;
+ unsigned int head = (track % drive->head);
+ unsigned int cyl = (track / drive->head);
+
+ nsectors.all = (u16) rq->nr_sectors;
+#ifdef DEBUG
+ printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
+ printk("CHS=%d/%d/%d, ", cyl, head, sect);
+ printk("sectors=%ld, ", rq->nr_sectors);
+ printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
+#endif
+
+ memset(&args, 0, sizeof(ide_task_t));
+
+ sectors = (rq->nr_sectors == 256) ? 0x00 : rq->nr_sectors;
+ args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
+ args.tfRegister[IDE_SECTOR_OFFSET] = sect;
+ args.tfRegister[IDE_LCYL_OFFSET] = cyl;
+ args.tfRegister[IDE_HCYL_OFFSET] = (cyl>>8);
+ args.tfRegister[IDE_SELECT_OFFSET] = head;
+ args.tfRegister[IDE_SELECT_OFFSET] |= drive->select.all;
+ args.tfRegister[IDE_COMMAND_OFFSET] = command;
+ args.command_type = ide_cmd_type_parser(&args);
+ args.rq = (struct request *) rq;
+ rq->special = (ide_task_t *)&args;
+ return do_rw_taskfile(drive, &args);
+}
+
+static ide_startstop_t lba_28_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
+{
+ ide_task_t args;
+ int sectors;
+ ata_nsector_t nsectors;
+ task_ioreg_t command = get_command(drive, rq_data_dir(rq));
+
+ nsectors.all = (u16) rq->nr_sectors;
+
+#ifdef DEBUG
+ printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
+ printk("LBAsect=%lld, ", block);
+ printk("sectors=%ld, ", rq->nr_sectors);
+ printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
+#endif
+
+ memset(&args, 0, sizeof(ide_task_t));
+
+ sectors = (rq->nr_sectors == 256) ? 0x00 : rq->nr_sectors;
+ args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
+ args.tfRegister[IDE_SECTOR_OFFSET] = block;
+ args.tfRegister[IDE_LCYL_OFFSET] = (block>>=8);
+ args.tfRegister[IDE_HCYL_OFFSET] = (block>>=8);
+ args.tfRegister[IDE_SELECT_OFFSET] = ((block>>8)&0x0f);
+ args.tfRegister[IDE_SELECT_OFFSET] |= drive->select.all;
+ args.tfRegister[IDE_COMMAND_OFFSET] = command;
+ args.command_type = ide_cmd_type_parser(&args);
+ args.rq = (struct request *) rq;
+ rq->special = (ide_task_t *)&args;
+ return do_rw_taskfile(drive, &args);
+}
+
+/*
+ * 268435455 == 137439 MB or 28bit limit
+ * 320173056 == 163929 MB or 48bit addressing
+ * 1073741822 == 549756 MB or 48bit addressing fake drive
+ */
+
+static ide_startstop_t lba_48_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long long block)
+{
+ ide_task_t args;
+ int sectors;
+ ata_nsector_t nsectors;
+ task_ioreg_t command = get_command(drive, rq_data_dir(rq));
+
+ nsectors.all = (u16) rq->nr_sectors;
+
+#ifdef DEBUG
+ printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
+ printk("LBAsect=%lld, ", block);
+ printk("sectors=%ld, ", rq->nr_sectors);
+ printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
+#endif
+
+ memset(&args, 0, sizeof(ide_task_t));
+
+ sectors = (rq->nr_sectors == 65536) ? 0 : rq->nr_sectors;
+ args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
+ args.tfRegister[IDE_SECTOR_OFFSET] = block; /* low lba */
+ args.tfRegister[IDE_LCYL_OFFSET] = (block>>=8); /* mid lba */
+ args.tfRegister[IDE_HCYL_OFFSET] = (block>>=8); /* hi lba */
+ args.tfRegister[IDE_SELECT_OFFSET] = drive->select.all;
+ args.tfRegister[IDE_COMMAND_OFFSET] = command;
+ args.hobRegister[IDE_NSECTOR_OFFSET_HOB]= sectors >> 8;
+ args.hobRegister[IDE_SECTOR_OFFSET_HOB] = (block>>=8); /* low lba */
+ args.hobRegister[IDE_LCYL_OFFSET_HOB] = (block>>=8); /* mid lba */
+ args.hobRegister[IDE_HCYL_OFFSET_HOB] = (block>>=8); /* hi lba */
+ args.hobRegister[IDE_SELECT_OFFSET_HOB] = drive->select.all;
+ args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
+ args.command_type = ide_cmd_type_parser(&args);
+ args.rq = (struct request *) rq;
+ rq->special = (ide_task_t *)&args;
+ return do_rw_taskfile(drive, &args);
+}
+
+#endif /* CONFIG_IDE_TASKFILE_IO */
+
+static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ if (hwif->rw_disk)
+ return hwif->rw_disk(drive, rq, block);
+ else
+ return __ide_do_rw_disk(drive, rq, block);
+}
+
+EXPORT_SYMBOL_GPL(__ide_do_rw_disk);
static int idedisk_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
{
MOD_INC_USE_COUNT;
if (drive->removable && drive->usage == 1) {
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.command = WIN_DOORLOCK;
+ ide_task_t args;
+ int cf;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK;
+ args.command_type = ide_cmd_type_parser(&args);
check_disk_change(inode->i_rdev);
/*
* Ignore the return code from door_lock,
* since the open() has already succeeded,
* and the door_lock is irrelevant at this point.
*/
- if (drive->doorlocking && ide_wait_taskfile(drive, &taskfile, &hobfile, NULL))
+ if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
drive->doorlocking = 0;
+ drive->wcache = 0;
+ /* Cache enabled ? */
+ if (drive->id->csfo & 1)
+ drive->wcache = 1;
+ /* Cache command set available ? */
+ if (drive->id->cfs_enable_1 & (1<<5))
+ drive->wcache = 1;
+ /* ATA6 cache extended commands */
+ cf = drive->id->command_set_2 >> 24;
+ if((cf & 0xC0) == 0x40 && (cf & 0x30) != 0)
+ drive->wcache = 1;
}
return 0;
}
static int do_idedisk_flushcache(ide_drive_t *drive);
+static int ide_cacheflush_p(ide_drive_t *drive)
+{
+ if(drive->wcache)
+ {
+ if (do_idedisk_flushcache(drive))
+ {
+ printk (KERN_INFO "%s: Write Cache FAILED Flushing!\n",
+ drive->name);
+ return -EIO;
+ }
+ return 1;
+ }
+ return 0;
+}
+
static void idedisk_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
{
if (drive->removable && !drive->usage) {
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.command = WIN_DOORUNLOCK;
+ ide_task_t args;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK;
+ args.command_type = ide_cmd_type_parser(&args);
invalidate_bdev(inode->i_bdev, 0);
- if (drive->doorlocking && ide_wait_taskfile(drive, &taskfile, &hobfile, NULL))
+ if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
drive->doorlocking = 0;
}
- if ((drive->id->cfs_enable_2 & 0x3000) && drive->wcache)
- if (do_idedisk_flushcache(drive))
- printk (KERN_INFO "%s: Write Cache FAILED Flushing!\n",
- drive->name);
+ ide_cacheflush_p(drive);
MOD_DEC_USE_COUNT;
}
static int idedisk_media_change (ide_drive_t *drive)
{
- return drive->removable; /* if removable, always assume it was changed */
+ /* if removable, always assume it was changed */
+ return drive->removable;
}
static void idedisk_revalidate (ide_drive_t *drive)
@@ -771,6 +782,230 @@
current_capacity(drive));
}
+static int idedisk_end_request (ide_drive_t *drive, int uptodate)
+{
+ struct request *rq;
+ unsigned long flags;
+ int ret = 1;
+
+ spin_lock_irqsave(&io_request_lock, flags);
+ rq = HWGROUP(drive)->rq;
+
+ /*
+ * decide whether to reenable DMA -- 3 is a random magic for now,
+ * if we DMA timeout more than 3 times, just stay in PIO
+ */
+ if (drive->state == DMA_PIO_RETRY && drive->retry_pio <= 3) {
+ drive->state = 0;
+ HWGROUP(drive)->hwif->ide_dma_on(drive);
+ }
+
+ if (!end_that_request_first(rq, uptodate, drive->name)) {
+ add_blkdev_randomness(MAJOR(rq->rq_dev));
+ blkdev_dequeue_request(rq);
+ HWGROUP(drive)->rq = NULL;
+ end_that_request_last(rq);
+ ret = 0;
+ }
+
+ spin_unlock_irqrestore(&io_request_lock, flags);
+ return ret;
+}
+
+static u8 idedisk_dump_status (ide_drive_t *drive, const char *msg, u8 stat)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ unsigned long flags;
+ u8 err = 0;
+
+ local_irq_set(flags);
+ printk("%s: %s: status=0x%02x", drive->name, msg, stat);
+#if FANCY_STATUS_DUMPS
+ printk(" { ");
+ if (stat & BUSY_STAT)
+ printk("Busy ");
+ else {
+ if (stat & READY_STAT) printk("DriveReady ");
+ if (stat & WRERR_STAT) printk("DeviceFault ");
+ if (stat & SEEK_STAT) printk("SeekComplete ");
+ if (stat & DRQ_STAT) printk("DataRequest ");
+ if (stat & ECC_STAT) printk("CorrectedError ");
+ if (stat & INDEX_STAT) printk("Index ");
+ if (stat & ERR_STAT) printk("Error ");
+ }
+ printk("}");
+#endif /* FANCY_STATUS_DUMPS */
+ printk("\n");
+ if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
+ err = hwif->INB(IDE_ERROR_REG);
+ printk("%s: %s: error=0x%02x", drive->name, msg, err);
+#if FANCY_STATUS_DUMPS
+ printk(" { ");
+ if (err & ABRT_ERR) printk("DriveStatusError ");
+ if (err & ICRC_ERR)
+ printk("Bad%s ", (err & ABRT_ERR) ? "CRC" : "Sector");
+ if (err & ECC_ERR) printk("UncorrectableError ");
+ if (err & ID_ERR) printk("SectorIdNotFound ");
+ if (err & TRK0_ERR) printk("TrackZeroNotFound ");
+ if (err & MARK_ERR) printk("AddrMarkNotFound ");
+ printk("}");
+ if ((err & (BBD_ERR | ABRT_ERR)) == BBD_ERR ||
+ (err & (ECC_ERR|ID_ERR|MARK_ERR))) {
+ if (drive->addressing == 1) {
+ __u64 sectors = 0;
+ u32 low = 0, high = 0;
+ low = idedisk_read_24(drive);
+ hwif->OUTB(drive->ctl|0x80, IDE_CONTROL_REG);
+ high = idedisk_read_24(drive);
+ sectors = ((__u64)high << 24) | low;
+ printk(", LBAsect=%llu, high=%d, low=%d",
+ (unsigned long long) sectors,
+ high, low);
+ } else {
+ u8 cur = hwif->INB(IDE_SELECT_REG);
+ if (cur & 0x40) { /* using LBA? */
+ printk(", LBAsect=%ld", (unsigned long)
+ ((cur&0xf)<<24)
+ |(hwif->INB(IDE_HCYL_REG)<<16)
+ |(hwif->INB(IDE_LCYL_REG)<<8)
+ | hwif->INB(IDE_SECTOR_REG));
+ } else {
+ printk(", CHS=%d/%d/%d",
+ (hwif->INB(IDE_HCYL_REG)<<8) +
+ hwif->INB(IDE_LCYL_REG),
+ cur & 0xf,
+ hwif->INB(IDE_SECTOR_REG));
+ }
+ }
+ if (HWGROUP(drive) && HWGROUP(drive)->rq)
+ printk(", sector=%ld",
+ HWGROUP(drive)->rq->sector);
+ }
+ }
+#endif /* FANCY_STATUS_DUMPS */
+ printk("\n");
+ local_irq_restore(flags);
+ return err;
+}
+
+ide_startstop_t idedisk_error (ide_drive_t *drive, const char *msg, u8 stat)
+{
+ ide_hwif_t *hwif;
+ struct request *rq;
+ u8 err;
+ int i = (drive->mult_count ? drive->mult_count : 1) * SECTOR_WORDS;
+
+ err = idedisk_dump_status(drive, msg, stat);
+
+ if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
+ return ide_stopped;
+
+ hwif = HWIF(drive);
+ /* retry only "normal" I/O: */
+ switch (rq->cmd) {
+ case IDE_DRIVE_CMD:
+ case IDE_DRIVE_TASK:
+ case IDE_DRIVE_TASKFILE:
+ rq->errors = 1;
+ ide_end_drive_cmd(drive, stat, err);
+ return ide_stopped;
+#if 0
+ case IDE_DRIVE_TASKFILE:
+ rq->errors = 1;
+ ide_end_taskfile(drive, stat, err);
+ return ide_stopped;
+#endif
+ default:
+ break;
+ }
+
+ if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) {
+ /* other bits are useless when BUSY */
+ rq->errors |= ERROR_RESET;
+ } else if (stat & ERR_STAT) {
+ /* err has different meaning on cdrom and tape */
+ if (err == ABRT_ERR) {
+ if (drive->select.b.lba &&
+ /* some newer drives don't support WIN_SPECIFY */
+ hwif->INB(IDE_COMMAND_REG) == WIN_SPECIFY)
+ return ide_stopped;
+ } else if ((err & BAD_CRC) == BAD_CRC) {
+ /* UDMA crc error, just retry the operation */
+ drive->crc_count++;
+ } else if (err & (BBD_ERR | ECC_ERR)) {
+ /* retries won't help these */
+ rq->errors = ERROR_MAX;
+ } else if (err & TRK0_ERR) {
+ /* help it find track zero */
+ rq->errors |= ERROR_RECAL;
+ }
+ }
+ if ((stat & DRQ_STAT) && rq_data_dir(rq) == READ) {
+ /*
+ * try_to_flush_leftover_data() is invoked in response to
+ * a drive unexpectedly having its DRQ_STAT bit set. As
+ * an alternative to resetting the drive, this routine
+ * tries to clear the condition by read a sector's worth
+ * of data from the drive. Of course, this may not help
+ * if the drive is *waiting* for data from *us*.
+ */
+ while (i > 0) {
+ u32 buffer[16];
+ unsigned int wcount = (i > 16) ? 16 : i;
+ i -= wcount;
+ taskfile_input_data(drive, buffer, wcount);
+ }
+ }
+ if (hwif->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT)) {
+ /* force an abort */
+ hwif->OUTB(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG);
+ }
+ if (rq->errors >= ERROR_MAX)
+ DRIVER(drive)->end_request(drive, 0);
+ else {
+ if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
+ ++rq->errors;
+ return ide_do_reset(drive);
+ }
+ if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
+ drive->special.b.recalibrate = 1;
+ ++rq->errors;
+ }
+ return ide_stopped;
+}
+
+ide_startstop_t idedisk_abort(ide_drive_t *drive, const char *msg)
+{
+ ide_hwif_t *hwif;
+ struct request *rq;
+
+ if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
+ return ide_stopped;
+
+ hwif = HWIF(drive);
+ /* retry only "normal" I/O: */
+ switch (rq->cmd) {
+ case IDE_DRIVE_CMD:
+ case IDE_DRIVE_TASK:
+ case IDE_DRIVE_TASKFILE:
+ rq->errors = 1;
+ ide_end_drive_cmd(drive, BUSY_STAT, 0);
+ return ide_stopped;
+#if 0
+ case IDE_DRIVE_TASKFILE:
+ rq->errors = 1;
+ ide_end_taskfile(drive, BUSY_STAT, 0);
+ return ide_stopped;
+#endif
+ default:
+ break;
+ }
+
+ rq->errors |= ERROR_RESET;
+ DRIVER(drive)->end_request(drive, 0);
+ return ide_stopped;
+}
+
/*
* Queries for true maximum capacity of the drive.
* Returns maximum LBA address (> 0) of the drive, 0 if failed.
@@ -780,16 +1015,11 @@
ide_task_t args;
unsigned long addr = 0;
- if (!(drive->id->command_set_1 & 0x0400) &&
- !(drive->id->cfs_enable_2 & 0x0100))
- return addr;
-
/* Create IDE/ATA command request structure */
memset(&args, 0, sizeof(ide_task_t));
args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX;
- args.handler = task_no_data_intr;
-
+ args.command_type = ide_cmd_type_parser(&args);
/* submit command request */
ide_raw_taskfile(drive, &args, NULL);
@@ -814,8 +1044,7 @@
args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX_EXT;
- args.handler = task_no_data_intr;
-
+ args.command_type = ide_cmd_type_parser(&args);
/* submit command request */
ide_raw_taskfile(drive, &args, NULL);
@@ -851,7 +1080,7 @@
args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >> 16) & 0xff);
args.tfRegister[IDE_SELECT_OFFSET] = ((addr_req >> 24) & 0x0f) | 0x40;
args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX;
- args.handler = task_no_data_intr;
+ args.command_type = ide_cmd_type_parser(&args);
/* submit command request */
ide_raw_taskfile(drive, &args, NULL);
/* if OK, read new maximum address value */
@@ -883,7 +1112,7 @@
args.hobRegister[IDE_HCYL_OFFSET_HOB] = ((addr_req >>= 8) & 0xff);
args.hobRegister[IDE_SELECT_OFFSET_HOB] = 0x40;
args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
- args.handler = task_no_data_intr;
+ args.command_type = ide_cmd_type_parser(&args);
/* submit command request */
ide_raw_taskfile(drive, &args, NULL);
/* if OK, compute maximum address value */
@@ -899,6 +1128,8 @@
return addr_set;
}
+#endif /* CONFIG_IDEDISK_STROKE */
+
/*
* Tests if the drive supports Host Protected Area feature.
* Returns true if supported, false otherwise.
@@ -906,12 +1137,11 @@
static inline int idedisk_supports_host_protected_area(ide_drive_t *drive)
{
int flag = (drive->id->cfs_enable_1 & 0x0400) ? 1 : 0;
- printk("%s: host protected area => %d\n", drive->name, flag);
+ if (flag)
+ printk("%s: host protected area => %d\n", drive->name, flag);
return flag;
}
-#endif /* CONFIG_IDEDISK_STROKE */
-
/*
* Compute drive->capacity, the full capacity of the drive
* Called with drive->id != NULL.
@@ -926,6 +1156,7 @@
* in above order (i.e., if value of higher priority is available,
* reset will be ignored).
*/
+#define IDE_STROKE_LIMIT (32000*1024*2)
static void init_idedisk_capacity (ide_drive_t *drive)
{
struct hd_driveid *id = drive->id;
@@ -937,6 +1168,8 @@
drive->capacity48 = 0;
drive->select.b.lba = 0;
+ (void) idedisk_supports_host_protected_area(drive);
+
if (id->cfs_enable_2 & 0x0400) {
capacity_2 = id->lba_capacity_2;
drive->head = drive->bios_head = 255;
@@ -944,7 +1177,7 @@
drive->cyl = (unsigned int) capacity_2 / (drive->head * drive->sect);
drive->select.b.lba = 1;
set_max_ext = idedisk_read_native_max_address_ext(drive);
- if (set_max_ext > capacity_2) {
+ if (set_max_ext > capacity_2 && capacity_2 > IDE_STROKE_LIMIT) {
#ifdef CONFIG_IDEDISK_STROKE
set_max_ext = idedisk_read_native_max_address_ext(drive);
set_max_ext = idedisk_set_max_address_ext(drive, set_max_ext);
@@ -955,10 +1188,11 @@
drive->id->lba_capacity_2 = capacity_2;
}
#else /* !CONFIG_IDEDISK_STROKE */
- printk("%s: setmax_ext LBA %llu, native %llu\n",
+ printk(KERN_INFO "%s: setmax_ext LBA %llu, native %llu\n",
drive->name, set_max_ext, capacity_2);
#endif /* CONFIG_IDEDISK_STROKE */
}
+ drive->cyl = (unsigned int) capacity_2 / (drive->head * drive->sect);
drive->bios_cyl = drive->cyl;
drive->capacity48 = capacity_2;
drive->capacity = (unsigned long) capacity_2;
@@ -970,7 +1204,7 @@
drive->select.b.lba = 1;
}
- if (set_max > capacity) {
+ if (set_max > capacity && capacity > IDE_STROKE_LIMIT) {
#ifdef CONFIG_IDEDISK_STROKE
set_max = idedisk_read_native_max_address(drive);
set_max = idedisk_set_max_address(drive, set_max);
@@ -981,7 +1215,7 @@
drive->id->lba_capacity = capacity;
}
#else /* !CONFIG_IDEDISK_STROKE */
- printk("%s: setmax LBA %lu, native %lu\n",
+ printk(KERN_INFO "%s: setmax LBA %lu, native %lu\n",
drive->name, set_max, capacity);
#endif /* CONFIG_IDEDISK_STROKE */
}
@@ -989,7 +1223,7 @@
drive->capacity = capacity;
if ((id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)) {
- drive->capacity48 = id->lba_capacity_2;
+ drive->capacity48 = id->lba_capacity_2;
drive->head = 255;
drive->sect = 63;
drive->cyl = (unsigned long)(drive->capacity48) / (drive->head * drive->sect);
@@ -1008,47 +1242,40 @@
special_t *s = &drive->special;
if (s->b.set_geometry) {
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- ide_handler_t *handler = NULL;
-
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
-
s->b.set_geometry = 0;
- taskfile.sector_number = drive->sect;
- taskfile.low_cylinder = drive->cyl;
- taskfile.high_cylinder = drive->cyl>>8;
- taskfile.device_head = ((drive->head-1)|drive->select.all)&0xBF;
if (!IS_PDC4030_DRIVE) {
- taskfile.sector_count = drive->sect;
- taskfile.command = WIN_SPECIFY;
- handler = ide_handler_parser(&taskfile, &hobfile);
+ ide_task_t args;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_NSECTOR_OFFSET] = drive->sect;
+ args.tfRegister[IDE_SECTOR_OFFSET] = drive->sect;
+ args.tfRegister[IDE_LCYL_OFFSET] = drive->cyl;
+ args.tfRegister[IDE_HCYL_OFFSET] = drive->cyl>>8;
+ args.tfRegister[IDE_SELECT_OFFSET] = ((drive->head-1)|drive->select.all)&0xBF;
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SPECIFY;
+ args.command_type = ide_cmd_type_parser(&args);
+ do_rw_taskfile(drive, &args);
}
- do_taskfile(drive, &taskfile, &hobfile, handler);
} else if (s->b.recalibrate) {
s->b.recalibrate = 0;
if (!IS_PDC4030_DRIVE) {
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.sector_count = drive->sect;
- taskfile.command = WIN_RESTORE;
- do_taskfile(drive, &taskfile, &hobfile, ide_handler_parser(&taskfile, &hobfile));
+ ide_task_t args;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_NSECTOR_OFFSET] = drive->sect;
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_RESTORE;
+ args.command_type = ide_cmd_type_parser(&args);
+ do_rw_taskfile(drive, &args);
}
} else if (s->b.set_multmode) {
s->b.set_multmode = 0;
- if (drive->id && drive->mult_req > drive->id->max_multsect)
+ if (drive->mult_req > drive->id->max_multsect)
drive->mult_req = drive->id->max_multsect;
if (!IS_PDC4030_DRIVE) {
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.sector_count = drive->mult_req;
- taskfile.command = WIN_SETMULT;
- do_taskfile(drive, &taskfile, &hobfile, ide_handler_parser(&taskfile, &hobfile));
+ ide_task_t args;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_NSECTOR_OFFSET] = drive->mult_req;
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETMULT;
+ args.command_type = ide_cmd_type_parser(&args);
+ do_rw_taskfile(drive, &args);
}
} else if (s->all) {
int special = s->all;
@@ -1078,45 +1305,44 @@
static int smart_enable(ide_drive_t *drive)
{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.feature = SMART_ENABLE;
- taskfile.low_cylinder = SMART_LCYL_PASS;
- taskfile.high_cylinder = SMART_HCYL_PASS;
- taskfile.command = WIN_SMART;
- return ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
-}
-
-static int get_smart_values(ide_drive_t *drive, byte *buf)
-{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.feature = SMART_READ_VALUES;
- taskfile.sector_count = 0x01;
- taskfile.low_cylinder = SMART_LCYL_PASS;
- taskfile.high_cylinder = SMART_HCYL_PASS;
- taskfile.command = WIN_SMART;
+ ide_task_t args;
+
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_FEATURE_OFFSET] = SMART_ENABLE;
+ args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
+ args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
+ args.command_type = ide_cmd_type_parser(&args);
+ return ide_raw_taskfile(drive, &args, NULL);
+}
+
+static int get_smart_values(ide_drive_t *drive, u8 *buf)
+{
+ ide_task_t args;
+
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_VALUES;
+ args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
+ args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
+ args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
+ args.command_type = ide_cmd_type_parser(&args);
(void) smart_enable(drive);
- return ide_wait_taskfile(drive, &taskfile, &hobfile, buf);
+ return ide_raw_taskfile(drive, &args, buf);
}
-static int get_smart_thresholds(ide_drive_t *drive, byte *buf)
+static int get_smart_thresholds(ide_drive_t *drive, u8 *buf)
{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.feature = SMART_READ_THRESHOLDS;
- taskfile.sector_count = 0x01;
- taskfile.low_cylinder = SMART_LCYL_PASS;
- taskfile.high_cylinder = SMART_HCYL_PASS;
- taskfile.command = WIN_SMART;
+ ide_task_t args;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_THRESHOLDS;
+ args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
+ args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
+ args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
+ args.command_type = ide_cmd_type_parser(&args);
(void) smart_enable(drive);
- return ide_wait_taskfile(drive, &taskfile, &hobfile, buf);
+ return ide_raw_taskfile(drive, &args, buf);
}
static int proc_idedisk_read_cache
@@ -1126,7 +1352,7 @@
char *out = page;
int len;
- if (drive->id)
+ if (drive->id_read)
len = sprintf(out,"%i\n", drive->id->buf_size / 2);
else
len = sprintf(out,"(none)\n");
@@ -1185,23 +1411,12 @@
#endif /* CONFIG_PROC_FS */
+/*
+ * This is tightly woven into the driver->do_special can not touch.
+ * DON'T do it again until a total personality rewrite is committed.
+ */
static int set_multcount(ide_drive_t *drive, int arg)
{
-#ifdef __TASKFILE__IO
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
-
- if (drive->special.b.set_multmode)
- return -EBUSY;
-
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.sector_count = drive->mult_req;
- taskfile.command = WIN_SETMULT;
- drive->mult_req = arg;
- drive->special.b.set_multmode = 1;
- ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
-#else /* !__TASKFILE__IO */
struct request rq;
if (drive->special.b.set_multmode)
@@ -1211,7 +1426,6 @@
drive->mult_req = arg;
drive->special.b.set_multmode = 1;
(void) ide_do_drive_cmd (drive, &rq, ide_wait);
-#endif /* __TASKFILE__IO */
return (drive->mult_count == arg) ? 0 : -EIO;
}
@@ -1227,57 +1441,112 @@
static int write_cache (ide_drive_t *drive, int arg)
{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.feature = (arg) ? SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
- taskfile.command = WIN_SETFEATURES;
+ ide_task_t args;
if (!(drive->id->cfs_enable_2 & 0x3000))
return 1;
- (void) ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ?
+ SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
+ args.command_type = ide_cmd_type_parser(&args);
+ (void) ide_raw_taskfile(drive, &args, NULL);
+
drive->wcache = arg;
return 0;
}
+static int call_idedisk_standby (ide_drive_t *drive, int arg)
+{
+ ide_task_t args;
+ u8 standby = (arg) ? WIN_STANDBYNOW2 : WIN_STANDBYNOW1;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_COMMAND_OFFSET] = standby;
+ args.command_type = ide_cmd_type_parser(&args);
+ return ide_raw_taskfile(drive, &args, NULL);
+}
+
static int do_idedisk_standby (ide_drive_t *drive)
{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- taskfile.command = WIN_STANDBYNOW1;
- return ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
+ return call_idedisk_standby(drive, 0);
+}
+
+static int call_idedisk_suspend (ide_drive_t *drive, int arg)
+{
+ ide_task_t args;
+ u8 suspend = (arg) ? WIN_SLEEPNOW2 : WIN_SLEEPNOW1;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_COMMAND_OFFSET] = suspend;
+ args.command_type = ide_cmd_type_parser(&args);
+ return ide_raw_taskfile(drive, &args, NULL);
+}
+
+static int do_idedisk_suspend (ide_drive_t *drive)
+{
+ if (drive->suspend_reset)
+ return 1;
+ ide_cacheflush_p(drive);
+ return call_idedisk_suspend(drive, 0);
+}
+
+#if 0
+static int call_idedisk_checkpower (ide_drive_t *drive, int arg)
+{
+ ide_task_t args;
+ u8 ckpw = (arg) ? WIN_CHECKPOWERMODE2 : WIN_CHECKPOWERMODE1;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_COMMAND_OFFSET] = ckpw;
+ args.command_type = ide_cmd_type_parser(&args);
+ ide_raw_taskfile(drive, &args, NULL);
+#if 0
+if (errno != EIO || args[0] != 0 || args[1] != 0)
+ state = "unknown";
+else
+ state = "sleeping";
+} else {
+ state = (args[2] == 255) ? "active/idle" : "standby";
+#endif
+ return 0;
+}
+
+static int do_idedisk_checkpower (ide_drive_t *drive)
+{
+ return call_idedisk_checkpower(drive, 0);
+}
+#endif
+
+static int do_idedisk_resume (ide_drive_t *drive)
+{
+ if (!drive->suspend_reset)
+ return 1;
+ return 0;
}
static int do_idedisk_flushcache (ide_drive_t *drive)
{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
- if (drive->id->cfs_enable_2 & 0x2400) {
- taskfile.command = WIN_FLUSH_CACHE_EXT;
- } else {
- taskfile.command = WIN_FLUSH_CACHE;
- }
- return ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
+ ide_task_t args;
+
+ memset(&args, 0, sizeof(ide_task_t));
+ if (drive->id->cfs_enable_2 & 0x2400)
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
+ else
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
+ args.command_type = ide_cmd_type_parser(&args);
+ return ide_raw_taskfile(drive, &args, NULL);
}
static int set_acoustic (ide_drive_t *drive, int arg)
{
- struct hd_drive_task_hdr taskfile;
- struct hd_drive_hob_hdr hobfile;
- memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
- memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
-
- taskfile.feature = (arg)?SETFEATURES_EN_AAM:SETFEATURES_DIS_AAM;
- taskfile.sector_count = arg;
+ ide_task_t args;
- taskfile.command = WIN_SETFEATURES;
- (void) ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ? SETFEATURES_EN_AAM :
+ SETFEATURES_DIS_AAM;
+ args.tfRegister[IDE_NSECTOR_OFFSET] = arg;
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
+ args.command_type = ide_cmd_type_parser(&args);
+ ide_raw_taskfile(drive, &args, NULL);
drive->acoustic = arg;
return 0;
}
@@ -1286,9 +1555,11 @@
{
drive->addressing = 0;
+ if (HWIF(drive)->addressing)
+ return 0;
+
if (!(drive->id->cfs_enable_2 & 0x0400))
return -EIO;
-
drive->addressing = arg;
return 0;
}
@@ -1321,23 +1592,41 @@
ide_add_setting(drive, "max_failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
}
+static int idedisk_ioctl (ide_drive_t *drive, struct inode *inode,
+ struct file *file, unsigned int cmd, unsigned long arg)
+{
+#if 0
+HDIO_GET_ADDRESS
+HDIO_SET_ADDRESS
+HDIO_GET_WCACHE
+HDIO_SET_WCACHE
+HDIO_GET_ACOUSTIC
+HDIO_SET_ACOUSTIC
+HDIO_GET_MULTCOUNT
+HDIO_SET_MULTCOUNT
+HDIO_GET_NOWERR
+HDIO_SET_NOWERR
+#endif
+ return -EINVAL;
+}
+
static void idedisk_setup (ide_drive_t *drive)
{
int i;
struct hd_driveid *id = drive->id;
unsigned long capacity;
-
+
idedisk_add_settings(drive);
- if (id == NULL)
+ if (drive->id_read == 0)
return;
/*
* CompactFlash cards and their brethern look just like hard drives
* to us, but they are removable and don't have a doorlock mechanism.
*/
- if (drive->removable && !drive_is_flashcard(drive)) {
+ if (drive->removable && !(drive->is_flash)) {
/*
* Removable disks (eg. SYQUEST); ignore 'WD' drives
*/
@@ -1355,6 +1644,14 @@
break;
}
+#if 1
+ (void) probe_lba_addressing(drive, 1);
+#else
+ /* if using 48-bit addressing bump the request size up */
+ if (probe_lba_addressing(drive, 1))
+ blk_queue_max_sectors(&drive->queue, 2048);
+#endif
+
/* Extract geometry if we did not already have one for the drive */
if (!drive->cyl || !drive->head || !drive->sect) {
drive->cyl = drive->bios_cyl = id->cyls;
@@ -1402,41 +1699,30 @@
drive->bios_cyl, drive->bios_head, drive->bios_sect);
#ifdef CONFIG_BLK_DEV_IDEDMA
if (drive->using_dma)
- (void) HWIF(drive)->dmaproc(ide_dma_verbose, drive);
+ (void) HWIF(drive)->ide_dma_verbose(drive);
#endif /* CONFIG_BLK_DEV_IDEDMA */
printk("\n");
drive->mult_count = 0;
if (id->max_multsect) {
-#ifdef CONFIG_IDEDISK_MULTI_MODE
id->multsect = ((id->max_multsect/2) > 1) ? id->max_multsect : 0;
id->multsect_valid = id->multsect ? 1 : 0;
drive->mult_req = id->multsect_valid ? id->max_multsect : INITIAL_MULT_COUNT;
drive->special.b.set_multmode = drive->mult_req ? 1 : 0;
-#else /* original, pre IDE-NFG, per request of AC */
- drive->mult_req = INITIAL_MULT_COUNT;
- if (drive->mult_req > id->max_multsect)
- drive->mult_req = id->max_multsect;
- if (drive->mult_req || ((id->multsect_valid & 1) && id->multsect))
- drive->special.b.set_multmode = 1;
-#endif /* CONFIG_IDEDISK_MULTI_MODE */
}
drive->no_io_32bit = id->dword_io ? 1 : 0;
if (drive->id->cfs_enable_2 & 0x3000)
write_cache(drive, (id->cfs_enable_2 & 0x3000));
- (void) probe_lba_addressing(drive, 1);
}
-static int idedisk_cleanup (ide_drive_t *drive)
+static int idedisk_cleanup(ide_drive_t *drive)
{
- if ((drive->id->cfs_enable_2 & 0x3000) && drive->wcache)
- if (do_idedisk_flushcache(drive))
- printk (KERN_INFO "%s: Write Cache FAILED Flushing!\n",
- drive->name);
+ ide_cacheflush_p(drive);
return ide_unregister_subdriver(drive);
}
-int idedisk_reinit(ide_drive_t *drive);
+int idedisk_init (void);
+int idedisk_attach(ide_drive_t *drive);
/*
* IDE subdriver functions, registered with ide.c
@@ -1450,10 +1736,15 @@
supports_dsc_overlap: 0,
cleanup: idedisk_cleanup,
standby: do_idedisk_standby,
+ suspend: do_idedisk_suspend,
+ resume: do_idedisk_resume,
flushcache: do_idedisk_flushcache,
- do_request: do_rw_disk,
- end_request: NULL,
- ioctl: NULL,
+ do_request: ide_do_rw_disk,
+ end_request: idedisk_end_request,
+ sense: idedisk_dump_status,
+ error: idedisk_error,
+ abort: idedisk_abort,
+ ioctl: idedisk_ioctl,
open: idedisk_open,
release: idedisk_release,
media_change: idedisk_media_change,
@@ -1462,12 +1753,12 @@
capacity: idedisk_capacity,
special: idedisk_special,
proc: idedisk_proc,
- reinit: idedisk_reinit,
+ init: idedisk_init,
+ attach: idedisk_attach,
ata_prebuilder: NULL,
atapi_prebuilder: NULL,
};
-int idedisk_init (void);
static ide_module_t idedisk_module = {
IDE_DRIVER_MODULE,
idedisk_init,
@@ -1477,30 +1768,30 @@
MODULE_DESCRIPTION("ATA DISK Driver");
-int idedisk_reinit (ide_drive_t *drive)
+int idedisk_attach (ide_drive_t *drive)
{
- int failed = 0;
+ int ret = 0;
MOD_INC_USE_COUNT;
-
- if (ide_register_subdriver (drive, &idedisk_driver, IDE_SUBDRIVER_VERSION)) {
- printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.c\n", drive->name);
- return 1;
+ if (ide_register_subdriver(drive,
+ &idedisk_driver, IDE_SUBDRIVER_VERSION)) {
+ printk(KERN_ERR "ide-disk: %s: Failed to register the "
+ "driver with ide.c\n", drive->name);
+ ret= 1;
+ goto bye_game_over;
}
DRIVER(drive)->busy++;
idedisk_setup(drive);
if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
- printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", drive->name, drive->head);
+ printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
+ drive->name, drive->head);
(void) idedisk_cleanup(drive);
- DRIVER(drive)->busy--;
- return 1;
+ ret= 1;
}
DRIVER(drive)->busy--;
- failed--;
-
- ide_register_module(&idedisk_module);
+bye_game_over:
MOD_DEC_USE_COUNT;
- return 0;
+ return ret;
}
static void __exit idedisk_exit (void)
@@ -1508,14 +1799,17 @@
ide_drive_t *drive;
int failed = 0;
- while ((drive = ide_scan_devices (ide_disk, idedisk_driver.name, &idedisk_driver, failed)) != NULL) {
+ while ((drive = ide_scan_devices(ide_disk, idedisk_driver.name,
+ &idedisk_driver, failed)) != NULL) {
if (idedisk_cleanup (drive)) {
- printk (KERN_ERR "%s: cleanup_module() called while still busy\n", drive->name);
+ printk(KERN_ERR "%s: cleanup_module() called while "
+ "still busy\n", drive->name);
failed++;
}
- /* We must remove proc entries defined in this module.
- Otherwise we oops while accessing these entries */
#ifdef CONFIG_PROC_FS
+ /* We must remove proc entries defined in this module.
+ * Otherwise we oops while accessing these entries
+ */
if (drive->proc)
ide_remove_proc_entries(drive->proc, idedisk_proc);
#endif
@@ -1525,19 +1819,28 @@
int idedisk_init (void)
{
+#ifdef CLASSIC_BUILTINS_METHOD
ide_drive_t *drive;
int failed = 0;
-
+#endif /* CLASSIC_BUILTINS_METHOD */
+
MOD_INC_USE_COUNT;
- while ((drive = ide_scan_devices (ide_disk, idedisk_driver.name, NULL, failed++)) != NULL) {
- if (ide_register_subdriver (drive, &idedisk_driver, IDE_SUBDRIVER_VERSION)) {
- printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.c\n", drive->name);
+
+#ifdef CLASSIC_BUILTINS_METHOD
+ while ((drive = ide_scan_devices(ide_disk,
+ idedisk_driver.name, NULL, failed++)) != NULL) {
+ if (ide_register_subdriver(drive,
+ &idedisk_driver, IDE_SUBDRIVER_VERSION)) {
+ printk(KERN_ERR "ide-disk: %s: Failed to register "
+ "the driver with ide.c\n", drive->name);
continue;
}
DRIVER(drive)->busy++;
idedisk_setup(drive);
- if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
- printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", drive->name, drive->head);
+ if ((!drive->head || drive->head > 16) &&
+ (!drive->select.b.lba)) {
+ printk(KERN_ERR "%s: INVALID GEOMETRY: %d "
+ "PHYSICAL HEADS?\n", drive->name, drive->head);
(void) idedisk_cleanup(drive);
DRIVER(drive)->busy--;
continue;
@@ -1545,11 +1848,85 @@
DRIVER(drive)->busy--;
failed--;
}
+#endif /* CLASSIC_BUILTINS_METHOD */
+
ide_register_module(&idedisk_module);
MOD_DEC_USE_COUNT;
return 0;
}
+ide_startstop_t panic_box(ide_drive_t *drive)
+{
+#if 0
+ panic("%s: Attempted to corrupt something: ide operation "
+#else
+ printk(KERN_ERR "%s: Attempted to corrupt something: ide operation "
+#endif
+ "was pending accross suspend/resume.\n", drive->name);
+ return ide_stopped;
+}
+
+int ide_disks_busy(void)
+{
+ int i;
+ for (i=0; i<MAX_HWIFS; i++) {
+ struct hwgroup_s *hwgroup = ide_hwifs[i].hwgroup;
+ if (!hwgroup) continue;
+ if ((hwgroup->handler) && (hwgroup->handler != panic_box))
+ return 1;
+ }
+ return 0;
+}
+
+void ide_disk_suspend(void)
+{
+ int i;
+ while (ide_disks_busy()) {
+ printk("*");
+ schedule();
+ }
+ for (i=0; i<MAX_HWIFS; i++) {
+ struct hwgroup_s *hwgroup = ide_hwifs[i].hwgroup;
+
+ if (!hwgroup) continue;
+ hwgroup->handler_save = hwgroup->handler;
+ hwgroup->handler = panic_box;
+ }
+ driver_blocked = 1;
+ if (ide_disks_busy())
+ panic("How did you get that request through?!");
+}
+
+/* unsuspend and resume should be equal in the ideal world */
+
+void ide_disk_unsuspend(void)
+{
+ int i;
+ for (i=0; i<MAX_HWIFS; i++) {
+ struct hwgroup_s *hwgroup = ide_hwifs[i].hwgroup;
+
+ if (!hwgroup) continue;
+ hwgroup->handler = NULL; /* hwgroup->handler_save; */
+ hwgroup->handler_save = NULL;
+ }
+ driver_blocked = 0;
+}
+
+void ide_disk_resume(void)
+{
+ int i;
+ for (i=0; i<MAX_HWIFS; i++) {
+ struct hwgroup_s *hwgroup = ide_hwifs[i].hwgroup;
+
+ if (!hwgroup) continue;
+ if (hwgroup->handler != panic_box)
+ panic("Handler was not set to panic?");
+ hwgroup->handler_save = NULL;
+ hwgroup->handler = NULL;
+ }
+ driver_blocked = 0;
+}
+
module_init(idedisk_init);
module_exit(idedisk_exit);
MODULE_LICENSE("GPL");
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)