Re: [PATCH 2.6.11-rc3 01/08] ide: add individual ATA_TFLAG_{OUT|IN}_* flags

From: Tejun Heo
Date: Fri Mar 04 2005 - 21:52:17 EST


01_ide_TFLAG_OUT_IN.patch

This patch replaces ide_task_t->tf_{out|in}_flags handling
with newly defined individual ATA_TFLAG_{OUT|IN}_* flags and
helper functions ide_{load|read}_taskfile(). To ease
transition of the IDE code, temporary flags
ATA_TFLAG_IDE_FLAGGED and ATA_TFLAG_IDE_LBA48 are defined.
This patch is tit-for-tat and shouldn't change any behavior.

Signed-off-by: Tejun Heo <htejun@xxxxxxxxx>

drivers/ide/ide-disk.c | 4
drivers/ide/ide-io.c | 35 +------
drivers/ide/ide-taskfile.c | 220 +++++++++++++++++++++++++++------------------
include/linux/ata.h | 66 ++++++++++++-
include/linux/ide.h | 10 +-
5 files changed, 213 insertions(+), 122 deletions(-)

Index: linux-taskfile-ng/drivers/ide/ide-disk.c
===================================================================
--- linux-taskfile-ng.orig/drivers/ide/ide-disk.c 2005-03-05 10:37:51.738348597 +0900
+++ linux-taskfile-ng/drivers/ide/ide-disk.c 2005-03-05 10:46:58.305078940 +0900
@@ -337,7 +337,7 @@ static u64 idedisk_read_native_max_addre
tf->device = 0x40;
if (lba48) {
tf->command = WIN_READ_NATIVE_MAX_EXT;
- tf->flags |= ATA_TFLAG_LBA48;
+ tf->flags |= ATA_TFLAG_IDE_LBA48;
} else
tf->command = WIN_READ_NATIVE_MAX;

@@ -379,7 +379,7 @@ static u64 idedisk_set_max_address(ide_d
tf->device = 0x40;
tf->command = WIN_SET_MAX_EXT;

- tf->flags |= ATA_TFLAG_LBA48;
+ tf->flags |= ATA_TFLAG_IDE_LBA48;
} else {
tf->device = ((addr_req >> 24) & 0xf) | 0x40;
tf->command = WIN_SET_MAX;
Index: linux-taskfile-ng/drivers/ide/ide-io.c
===================================================================
--- linux-taskfile-ng.orig/drivers/ide/ide-io.c 2005-03-05 10:37:51.738348597 +0900
+++ linux-taskfile-ng/drivers/ide/ide-io.c 2005-03-05 10:46:58.307078627 +0900
@@ -64,7 +64,7 @@ void ide_task_init_flush(ide_drive_t *dr
if (ide_id_has_flush_cache_ext(drive->id) &&
(drive->capacity64 >= (1UL << 28))) {
tf->command = WIN_FLUSH_CACHE_EXT;
- tf->flags |= ATA_TFLAG_LBA48;
+ tf->flags |= ATA_TFLAG_IDE_LBA48;
} else
tf->command = WIN_FLUSH_CACHE;

@@ -322,7 +322,7 @@ u64 ide_tf_get_address(ide_drive_t *driv
{
u32 high, low;

- if (tf->flags & ATA_TFLAG_LBA48) {
+ if (tf->flags & ATA_TFLAG_IDE_LBA48) {
high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) | tf->hob_lbal;
low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
} else {
@@ -458,31 +458,10 @@ void ide_end_drive_cmd (ide_drive_t *dri

if (args) {
struct ata_taskfile *tf = &args->tf;
-
- if (args->tf_in_flags.b.data)
- args->data = hwif->INW(IDE_DATA_REG);
-
- tf->feature = err;
-
- /* be sure we're looking at the low order bits */
- hwif->OUTB(drive->ctl & ~0x80, IDE_CONTROL_REG);
-
- tf->nsect = hwif->INB(IDE_NSECTOR_REG);
- tf->lbal = hwif->INB(IDE_SECTOR_REG);
- tf->lbam = hwif->INB(IDE_LCYL_REG);
- tf->lbah = hwif->INB(IDE_HCYL_REG);
- tf->device = hwif->INB(IDE_SELECT_REG);
- tf->command = stat;
-
- if (tf->flags & ATA_TFLAG_LBA48) {
- hwif->OUTB(drive->ctl|0x80, IDE_CONTROL_REG);
-
- tf->hob_feature = hwif->INB(IDE_FEATURE_REG);
- tf->hob_nsect = hwif->INB(IDE_NSECTOR_REG);
- tf->hob_lbal = hwif->INB(IDE_SECTOR_REG);
- tf->hob_lbam = hwif->INB(IDE_LCYL_REG);
- tf->hob_lbah = hwif->INB(IDE_HCYL_REG);
- }
+ tf->flags |= ATA_TFLAG_IN_ADDR | ATA_TFLAG_IN_DEVICE;
+ if (tf->flags & ATA_TFLAG_IDE_LBA48)
+ tf->flags |= ATA_TFLAG_IN_LBA48;
+ ide_read_taskfile(drive, args, stat, err);
}
} else if (blk_pm_request(rq)) {
#ifdef DEBUG_PM
@@ -935,7 +914,7 @@ static ide_startstop_t execute_drive_cmd
break;
}

- if (args->tf_out_flags.all != 0)
+ if (args->tf.flags & ATA_TFLAG_IDE_FLAGGED)
return flagged_taskfile(drive, args);
return do_rw_taskfile(drive, args);
} else if (rq->flags & REQ_DRIVE_CMD) {
Index: linux-taskfile-ng/drivers/ide/ide-taskfile.c
===================================================================
--- linux-taskfile-ng.orig/drivers/ide/ide-taskfile.c 2005-03-05 10:37:51.739348441 +0900
+++ linux-taskfile-ng/drivers/ide/ide-taskfile.c 2005-03-05 10:46:58.315077377 +0900
@@ -53,6 +53,92 @@

#define DEBUG_TASKFILE 0 /* unset when fixed */

+void ide_load_taskfile(ide_drive_t *drive, ide_task_t *task)
+{
+ struct ata_taskfile *tf = &task->tf;
+ ide_hwif_t *hwif = drive->hwif;
+
+ /* The caller is responsible for supplying a valid device value. */
+ if (tf->flags & ATA_TFLAG_OUT_DEVICE)
+ hwif->OUTB(tf->device, IDE_SELECT_REG);
+
+ /* Load HOB registers. */
+ if (tf->flags & ATA_TFLAG_OUT_HOB_FEATURE)
+ hwif->OUTB(tf->hob_feature, IDE_FEATURE_REG);
+ if (tf->flags & ATA_TFLAG_OUT_HOB_NSECT)
+ hwif->OUTB(tf->hob_nsect, IDE_NSECTOR_REG);
+ if (tf->flags & ATA_TFLAG_OUT_HOB_LBAL)
+ hwif->OUTB(tf->hob_lbal, IDE_SECTOR_REG);
+ if (tf->flags & ATA_TFLAG_OUT_HOB_LBAM)
+ hwif->OUTB(tf->hob_lbam, IDE_LCYL_REG);
+ if (tf->flags & ATA_TFLAG_OUT_HOB_LBAH)
+ hwif->OUTB(tf->hob_lbah, IDE_HCYL_REG);
+
+ /* Now push HOBs upward by loading LOBs. The caller is
+ responsible for supplying matching LOB for each matching
+ HOB; otherwise, HOB won't be pushed upward. */
+ if (tf->flags & ATA_TFLAG_OUT_FEATURE)
+ hwif->OUTB(tf->feature, IDE_FEATURE_REG);
+ if (tf->flags & ATA_TFLAG_OUT_NSECT)
+ hwif->OUTB(tf->nsect, IDE_NSECTOR_REG);
+ if (tf->flags & ATA_TFLAG_OUT_LBAL)
+ hwif->OUTB(tf->lbal, IDE_SECTOR_REG);
+ if (tf->flags & ATA_TFLAG_OUT_LBAM)
+ hwif->OUTB(tf->lbam, IDE_LCYL_REG);
+ if (tf->flags & ATA_TFLAG_OUT_LBAH)
+ hwif->OUTB(tf->lbah, IDE_HCYL_REG);
+
+ /* Load data. This is for the brain-damaged TASKFILE ioctl. */
+ if (task->load_data)
+ hwif->OUTW(task->data, IDE_DATA_REG);
+}
+EXPORT_SYMBOL(ide_load_taskfile);
+
+void ide_read_taskfile(ide_drive_t *drive, ide_task_t *task, u8 stat, u8 err)
+{
+ struct ata_taskfile *tf = &task->tf;
+ ide_hwif_t *hwif = drive->hwif;
+
+ /* Read HOB registers first such that the HOB bit in the control
+ register stays cleared when we leave this function. */
+ if (tf->flags & ATA_TFLAG_IN_LBA48) {
+ hwif->OUTB(drive->ctl | ATA_HOB, IDE_CONTROL_REG);
+
+ if (tf->flags & ATA_TFLAG_IN_HOB_FEATURE)
+ tf->hob_feature = hwif->INB(IDE_FEATURE_REG);
+ if (tf->flags & ATA_TFLAG_IN_HOB_NSECT)
+ tf->hob_nsect = hwif->INB(IDE_NSECTOR_REG);
+ if (tf->flags & ATA_TFLAG_IN_HOB_LBAL)
+ tf->hob_lbal = hwif->INB(IDE_SECTOR_REG);
+ if (tf->flags & ATA_TFLAG_IN_HOB_LBAM)
+ tf->hob_lbam = hwif->INB(IDE_LCYL_REG);
+ if (tf->flags & ATA_TFLAG_IN_HOB_LBAH)
+ tf->hob_lbah = hwif->INB(IDE_HCYL_REG);
+
+ hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
+ }
+
+ if (tf->flags & ATA_TFLAG_IN_FEATURE)
+ tf->feature = err;
+ if (tf->flags & ATA_TFLAG_IN_NSECT)
+ tf->nsect = hwif->INB(IDE_NSECTOR_REG);
+ if (tf->flags & ATA_TFLAG_IN_LBAL)
+ tf->lbal = hwif->INB(IDE_SECTOR_REG);
+ if (tf->flags & ATA_TFLAG_IN_LBAM)
+ tf->lbam = hwif->INB(IDE_LCYL_REG);
+ if (tf->flags & ATA_TFLAG_IN_LBAH)
+ tf->lbah = hwif->INB(IDE_HCYL_REG);
+
+ if (tf->flags & ATA_TFLAG_IN_DEVICE)
+ tf->device = hwif->INB(IDE_SELECT_REG);
+
+ tf->command = stat;
+
+ /* And, for the braindamaged TASKFILE ioctl. */
+ if (task->read_data)
+ task->data = hwif->INW(IDE_DATA_REG);
+}
+
static void ata_bswap_data (void *buffer, int wcount)
{
u16 *p = buffer;
@@ -104,7 +190,7 @@ ide_startstop_t do_rw_taskfile (ide_driv
{
ide_hwif_t *hwif = HWIF(drive);
struct ata_taskfile *tf = &task->tf;
- u8 HIHI = (tf->flags & ATA_TFLAG_LBA48) ? 0xE0 : 0xEF;
+ u8 HIHI = (tf->flags & ATA_TFLAG_IDE_LBA48) ? 0xE0 : 0xEF;

/* ALL Command Block Executions SHALL clear nIEN, unless otherwise */
if (IDE_CONTROL_REG) {
@@ -113,21 +199,13 @@ ide_startstop_t do_rw_taskfile (ide_driv
}
SELECT_MASK(drive, 0);

- if (tf->flags & ATA_TFLAG_LBA48) {
- hwif->OUTB(tf->hob_feature, IDE_FEATURE_REG);
- hwif->OUTB(tf->hob_nsect, IDE_NSECTOR_REG);
- hwif->OUTB(tf->hob_lbal, IDE_SECTOR_REG);
- hwif->OUTB(tf->hob_lbam, IDE_LCYL_REG);
- hwif->OUTB(tf->hob_lbah, IDE_HCYL_REG);
- }
-
- hwif->OUTB(tf->feature, IDE_FEATURE_REG);
- hwif->OUTB(tf->nsect, IDE_NSECTOR_REG);
- hwif->OUTB(tf->lbal, IDE_SECTOR_REG);
- hwif->OUTB(tf->lbam, IDE_LCYL_REG);
- hwif->OUTB(tf->lbah, IDE_HCYL_REG);
+ if (tf->flags & ATA_TFLAG_IDE_LBA48)
+ tf->flags |= ATA_TFLAG_OUT_LBA48;
+ tf->flags |= ATA_TFLAG_OUT_ADDR;
+ tf->flags |= ATA_TFLAG_OUT_DEVICE;
+ tf->device = (tf->device & HIHI) | (drive->select.all & 0xBF);

- hwif->OUTB((tf->device & HIHI) | (drive->select.all & 0xBF), IDE_SELECT_REG);
+ ide_load_taskfile(drive, task);

if (task->handler != NULL) {
if (task->prehandler != NULL) {
@@ -383,7 +461,7 @@ static void task_end_request(ide_drive_t
if (rq->flags & REQ_DRIVE_TASKFILE) {
ide_task_t *task = rq->special;

- if (task->tf_out_flags.all) {
+ if (task->tf.flags & ATA_TFLAG_IDE_FLAGGED) {
u8 err = drive->hwif->INB(IDE_ERROR_REG);
ide_end_drive_cmd(drive, stat, err);
return;
@@ -596,14 +674,46 @@ int ide_taskfile_ioctl (ide_drive_t *dri
tf->device = req_task->io_ports[6];
tf->command = req_task->io_ports[7];

- args.tf_in_flags = req_task->in_flags;
- args.tf_out_flags = req_task->out_flags;
+ /* Translate out/in flags. */
+ if (req_task->out_flags.all)
+ tf->flags |= ATA_TFLAG_IDE_FLAGGED;
+
+ if (req_task->out_flags.b.error_feature_hob)
+ tf->flags |= ATA_TFLAG_OUT_HOB_FEATURE;
+ if (req_task->out_flags.b.nsector_hob)
+ tf->flags |= ATA_TFLAG_OUT_HOB_NSECT;
+ if (req_task->out_flags.b.sector_hob)
+ tf->flags |= ATA_TFLAG_OUT_HOB_LBAL;
+ if (req_task->out_flags.b.lcyl_hob)
+ tf->flags |= ATA_TFLAG_OUT_HOB_LBAM;
+ if (req_task->out_flags.b.hcyl_hob)
+ tf->flags |= ATA_TFLAG_OUT_HOB_LBAH;
+
+ if (req_task->out_flags.b.error_feature)
+ tf->flags |= ATA_TFLAG_OUT_FEATURE;
+ if (req_task->out_flags.b.nsector)
+ tf->flags |= ATA_TFLAG_OUT_NSECT;
+ if (req_task->out_flags.b.sector)
+ tf->flags |= ATA_TFLAG_OUT_LBAL;
+ if (req_task->out_flags.b.lcyl)
+ tf->flags |= ATA_TFLAG_OUT_LBAM;
+ if (req_task->out_flags.b.hcyl)
+ tf->flags |= ATA_TFLAG_OUT_LBAH;
+
+ if (req_task->out_flags.b.select)
+ tf->flags |= ATA_TFLAG_OUT_DEVICE;
+ if (req_task->out_flags.b.data)
+ args.load_data = 1;
+
+ if (req_task->in_flags.b.data)
+ args.read_data = 1;
+
args.data_phase = req_task->data_phase;
args.command_type = req_task->req_cmd;

- tf->flags = ATA_TFLAG_IO_16BIT;
+ tf->flags |= ATA_TFLAG_IO_16BIT;
if (drive->addressing == 1)
- tf->flags |= ATA_TFLAG_LBA48;
+ tf->flags |= ATA_TFLAG_IDE_LBA48;

if (drive->select.b.lba)
tf->device |= ATA_LBA;
@@ -672,9 +782,6 @@ int ide_taskfile_ioctl (ide_drive_t *dri
req_task->io_ports[6] = tf->device;
req_task->io_ports[7] = tf->command;

- req_task->in_flags = args.tf_in_flags;
- req_task->out_flags = args.tf_out_flags;
-
if (copy_to_user(buf, req_task, tasksize)) {
err = -EFAULT;
goto abort;
@@ -838,76 +945,19 @@ ide_startstop_t flagged_taskfile (ide_dr
}
}

- /*
- * (ks) Check taskfile in/out flags.
- * If set, then execute as it is defined.
- * If not set, then define default settings.
- * The default values are:
- * write and read all taskfile registers (except data)
- * write and read the hob registers (sector,nsector,lcyl,hcyl)
- */
- if (task->tf_out_flags.all == 0) {
- task->tf_out_flags.all = IDE_TASKFILE_STD_OUT_FLAGS;
- if (drive->addressing == 1)
- task->tf_out_flags.all |= (IDE_HOB_STD_OUT_FLAGS << 8);
- }
-
- if (task->tf_in_flags.all == 0) {
- task->tf_in_flags.all = IDE_TASKFILE_STD_IN_FLAGS;
- if (drive->addressing == 1)
- task->tf_in_flags.all |= (IDE_HOB_STD_IN_FLAGS << 8);
- }
-
/* ALL Command Block Executions SHALL clear nIEN, unless otherwise */
if (IDE_CONTROL_REG)
/* clear nIEN */
hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
SELECT_MASK(drive, 0);

-#if DEBUG_TASKFILE
- status = hwif->INB(IDE_STATUS_REG);
- if (status & 0x80) {
- printk("flagged_taskfile -> Bad status. Status = %02x. wait 100 usec ...\n", status);
- udelay(100);
- status = hwif->INB(IDE_STATUS_REG);
- printk("flagged_taskfile -> Status = %02x\n", status);
- }
-#endif
+ /* Adjust task. */
+ tf->flags &= ~ATA_TFLAG_OUT_HOB_FEATURE;
+ tf->flags |= ATA_TFLAG_OUT_DEVICE;
+ tf->device |= drive->select.all & 0xBF;

- if (task->tf_out_flags.b.data)
- hwif->OUTW(task->data, IDE_DATA_REG);
+ ide_load_taskfile(drive, task);

- /* (ks) send hob registers first */
- if (task->tf_out_flags.b.nsector_hob)
- hwif->OUTB(tf->hob_nsect, IDE_NSECTOR_REG);
- if (task->tf_out_flags.b.sector_hob)
- hwif->OUTB(tf->hob_lbal, IDE_SECTOR_REG);
- if (task->tf_out_flags.b.lcyl_hob)
- hwif->OUTB(tf->hob_lbam, IDE_LCYL_REG);
- if (task->tf_out_flags.b.hcyl_hob)
- hwif->OUTB(tf->hob_lbah, IDE_HCYL_REG);
-
- /* (ks) Send now the standard registers */
- if (task->tf_out_flags.b.error_feature)
- hwif->OUTB(tf->feature, IDE_FEATURE_REG);
- /* refers to number of sectors to transfer */
- if (task->tf_out_flags.b.nsector)
- hwif->OUTB(tf->nsect, IDE_NSECTOR_REG);
- /* refers to sector offset or start sector */
- if (task->tf_out_flags.b.sector)
- hwif->OUTB(tf->lbal, IDE_SECTOR_REG);
- if (task->tf_out_flags.b.lcyl)
- hwif->OUTB(tf->lbam, IDE_LCYL_REG);
- if (task->tf_out_flags.b.hcyl)
- hwif->OUTB(tf->lbah, IDE_HCYL_REG);
-
- /*
- * (ks) In the flagged taskfile approch, we will use all specified
- * registers and the register value will not be changed, except the
- * select bit (master/slave) in the drive_head register. We must make
- * sure that the desired drive is selected.
- */
- hwif->OUTB(tf->device | (drive->select.all & 0xBF), IDE_SELECT_REG);
switch(task->data_phase) {

case TASKFILE_OUT_DMAQ:
Index: linux-taskfile-ng/include/linux/ata.h
===================================================================
--- linux-taskfile-ng.orig/include/linux/ata.h 2005-03-05 10:37:51.739348441 +0900
+++ linux-taskfile-ng/include/linux/ata.h 2005-03-05 10:46:58.316077220 +0900
@@ -168,11 +168,67 @@ enum {
SCR_NOTIFICATION = 4,

/* struct ata_taskfile flags */
- ATA_TFLAG_LBA48 = (1 << 0), /* enable 48-bit LBA and "HOB" */
- ATA_TFLAG_ISADDR = (1 << 1), /* enable r/w to nsect/lba regs */
- ATA_TFLAG_DEVICE = (1 << 2), /* enable r/w to device reg */
- ATA_TFLAG_WRITE = (1 << 3), /* data dir: host->dev==1 (write) */
- ATA_TFLAG_IO_16BIT = (1 << 4), /* force 16bit pio */
+ ATA_TFLAG_OUT_FEATURE = (1 << 0),
+ ATA_TFLAG_OUT_NSECT = (1 << 1),
+ ATA_TFLAG_OUT_LBAL = (1 << 2),
+ ATA_TFLAG_OUT_LBAM = (1 << 3),
+ ATA_TFLAG_OUT_LBAH = (1 << 4),
+ ATA_TFLAG_OUT_HOB_FEATURE = (1 << 5),
+ ATA_TFLAG_OUT_HOB_NSECT = (1 << 6),
+ ATA_TFLAG_OUT_HOB_LBAL = (1 << 7),
+ ATA_TFLAG_OUT_HOB_LBAM = (1 << 8),
+ ATA_TFLAG_OUT_HOB_LBAH = (1 << 9),
+ ATA_TFLAG_OUT_DEVICE = (1 << 10),
+
+ ATA_TFLAG_IN_FEATURE = (1 << 11),
+ ATA_TFLAG_IN_NSECT = (1 << 12),
+ ATA_TFLAG_IN_LBAL = (1 << 13),
+ ATA_TFLAG_IN_LBAM = (1 << 14),
+ ATA_TFLAG_IN_LBAH = (1 << 15),
+ ATA_TFLAG_IN_HOB_FEATURE = (1 << 16),
+ ATA_TFLAG_IN_HOB_NSECT = (1 << 17),
+ ATA_TFLAG_IN_HOB_LBAL = (1 << 18),
+ ATA_TFLAG_IN_HOB_LBAM = (1 << 19),
+ ATA_TFLAG_IN_HOB_LBAH = (1 << 20),
+ ATA_TFLAG_IN_DEVICE = (1 << 21),
+
+ /* The following four aggreate flags are used by IDE to control
+ register IO. */
+ ATA_TFLAG_OUT_LBA48 = (ATA_TFLAG_OUT_HOB_FEATURE |
+ ATA_TFLAG_OUT_HOB_NSECT |
+ ATA_TFLAG_OUT_HOB_LBAL |
+ ATA_TFLAG_OUT_HOB_LBAM |
+ ATA_TFLAG_OUT_HOB_LBAH ),
+ ATA_TFLAG_OUT_ADDR = (ATA_TFLAG_OUT_FEATURE |
+ ATA_TFLAG_OUT_NSECT |
+ ATA_TFLAG_OUT_LBAL |
+ ATA_TFLAG_OUT_LBAM |
+ ATA_TFLAG_OUT_LBAH ),
+ ATA_TFLAG_IN_LBA48 = (ATA_TFLAG_IN_HOB_FEATURE |
+ ATA_TFLAG_IN_HOB_NSECT |
+ ATA_TFLAG_IN_HOB_LBAL |
+ ATA_TFLAG_IN_HOB_LBAM |
+ ATA_TFLAG_IN_HOB_LBAH ),
+ ATA_TFLAG_IN_ADDR = (ATA_TFLAG_IN_FEATURE |
+ ATA_TFLAG_IN_NSECT |
+ ATA_TFLAG_IN_LBAL |
+ ATA_TFLAG_IN_LBAM |
+ ATA_TFLAG_IN_LBAH ),
+
+ /* These three aggregate flags are used by libata, as it doesn't
+ really need to optimize register INs */
+ ATA_TFLAG_LBA48 = (ATA_TFLAG_OUT_LBA48 | ATA_TFLAG_IN_LBA48 ),
+ ATA_TFLAG_ISADDR = (ATA_TFLAG_OUT_ADDR | ATA_TFLAG_IN_ADDR ),
+ ATA_TFLAG_DEVICE = (ATA_TFLAG_OUT_DEVICE | ATA_TFLAG_IN_DEVICE),
+
+ ATA_TFLAG_WRITE = (1 << 22), /* data dir */
+ ATA_TFLAG_IO_16BIT = (1 << 23), /* force 16bit PIO (IDE) */
+
+ /* Following two flags are just to ease migration to the new
+ taskfile implementation. They will go away as soon as the
+ transition is complete. */
+ ATA_TFLAG_IDE_FLAGGED = (1 << 24),
+ ATA_TFLAG_IDE_LBA48 = (1 << 25),
};

enum ata_tf_protocols {
Index: linux-taskfile-ng/include/linux/ide.h
===================================================================
--- linux-taskfile-ng.orig/include/linux/ide.h 2005-03-05 10:37:51.739348441 +0900
+++ linux-taskfile-ng/include/linux/ide.h 2005-03-05 10:46:58.318076908 +0900
@@ -927,8 +927,8 @@ typedef int (ide_expiry_t)(ide_drive_t *
typedef struct ide_task_s {
struct ata_taskfile tf;
u16 data;
- ide_reg_valid_t tf_out_flags;
- ide_reg_valid_t tf_in_flags;
+ unsigned load_data:1;
+ unsigned read_data:1;
int data_phase;
int command_type;
ide_pre_handler_t *prehandler;
@@ -1276,6 +1276,12 @@ extern int drive_is_ready(ide_drive_t *)
extern int wait_for_ready(ide_drive_t *, int /* timeout */);

/*
+ * Taskfile load/read functions
+ */
+void ide_load_taskfile(ide_drive_t *drive, ide_task_t *task);
+void ide_read_taskfile(ide_drive_t *drive, ide_task_t *task, u8 stat, u8 err);
+
+/*
* taskfile io for disks for now...and builds request from ide_ioctl
*/
extern ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/