ide: remove ide_task_t typedef
authorBartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Fri, 27 Mar 2009 11:46:37 +0000 (12:46 +0100)
committerBartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Fri, 27 Mar 2009 11:46:37 +0000 (12:46 +0100)
While at it:
- rename struct ide_task_s to struct ide_cmd
- remove stale comments from idedisk_{read_native,set}_max_address()
- drop unused 'cmd' argument from ide_{cmd,task}_ioctl()
- drop unused 'task' argument from tx4939ide_tf_load_fixup()
- rename ide_complete_task() to ide_complete_cmd()
- use consistent naming for struct ide_cmd variables

There should be no functional changes caused by this patch.

Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
22 files changed:
drivers/ide/at91_ide.c
drivers/ide/ide-acpi.c
drivers/ide/ide-atapi.c
drivers/ide/ide-disk.c
drivers/ide/ide-disk_proc.c
drivers/ide/ide-eh.c
drivers/ide/ide-h8300.c
drivers/ide/ide-io-std.c
drivers/ide/ide-io.c
drivers/ide/ide-ioctls.c
drivers/ide/ide-iops.c
drivers/ide/ide-lib.c
drivers/ide/ide-park.c
drivers/ide/ide-pm.c
drivers/ide/ide-probe.c
drivers/ide/ide-proc.c
drivers/ide/ide-taskfile.c
drivers/ide/ns87415.c
drivers/ide/scc_pata.c
drivers/ide/tx4938ide.c
drivers/ide/tx4939ide.c
include/linux/ide.h

index 6eabf9e31290268aa19c009fb508040cbf5fed6f..6be7d87382ab0a3e93cff5ab3426cfe89fe29982 100644 (file)
@@ -185,55 +185,55 @@ static void ide_mm_outb(u8 value, unsigned long port)
        writeb(value, (void __iomem *) port);
 }
 
-static void at91_ide_tf_load(ide_drive_t *drive, ide_task_t *task)
+static void at91_ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
-       u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
+       struct ide_taskfile *tf = &cmd->tf;
+       u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
 
-       if (task->tf_flags & IDE_FTFLAG_FLAGGED)
+       if (cmd->tf_flags & IDE_FTFLAG_FLAGGED)
                HIHI = 0xFF;
 
-       if (task->tf_flags & IDE_FTFLAG_OUT_DATA) {
+       if (cmd->tf_flags & IDE_FTFLAG_OUT_DATA) {
                u16 data = (tf->hob_data << 8) | tf->data;
 
                at91_ide_output_data(drive, NULL, &data, 2);
        }
 
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
                ide_mm_outb(tf->hob_feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
                ide_mm_outb(tf->hob_nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
                ide_mm_outb(tf->hob_lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
                ide_mm_outb(tf->hob_lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
                ide_mm_outb(tf->hob_lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
                ide_mm_outb(tf->feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
                ide_mm_outb(tf->nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
                ide_mm_outb(tf->lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
                ide_mm_outb(tf->lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
                ide_mm_outb(tf->lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
                ide_mm_outb((tf->device & HIHI) | drive->select, io_ports->device_addr);
 }
 
-static void at91_ide_tf_read(ide_drive_t *drive, ide_task_t *task)
+static void at91_ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
 
-       if (task->tf_flags & IDE_FTFLAG_IN_DATA) {
+       if (cmd->tf_flags & IDE_FTFLAG_IN_DATA) {
                u16 data;
 
                at91_ide_input_data(drive, NULL, &data, 2);
@@ -244,31 +244,31 @@ static void at91_ide_tf_read(ide_drive_t *drive, ide_task_t *task)
        /* be sure we're looking at the low order bits */
        ide_mm_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
 
-       if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_FEATURE)
                tf->feature = ide_mm_inb(io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
                tf->nsect  = ide_mm_inb(io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
                tf->lbal   = ide_mm_inb(io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
                tf->lbam   = ide_mm_inb(io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
                tf->lbah   = ide_mm_inb(io_ports->lbah_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
                tf->device = ide_mm_inb(io_ports->device_addr);
 
-       if (task->tf_flags & IDE_TFLAG_LBA48) {
+       if (cmd->tf_flags & IDE_TFLAG_LBA48) {
                ide_mm_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
 
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
                        tf->hob_feature = ide_mm_inb(io_ports->feature_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
                        tf->hob_nsect   = ide_mm_inb(io_ports->nsect_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
                        tf->hob_lbal    = ide_mm_inb(io_ports->lbal_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
                        tf->hob_lbam    = ide_mm_inb(io_ports->lbam_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
                        tf->hob_lbah    = ide_mm_inb(io_ports->lbah_addr);
        }
 }
index 5b704f1ea90c901f446897ca21715b8f558bbd64..12f436951bffcf9ace9094a727e7bbabe9bd346a 100644 (file)
@@ -304,7 +304,7 @@ static int do_drive_set_taskfiles(ide_drive_t *drive,
        /* send all taskfile registers (0x1f1-0x1f7) *in*that*order* */
        for (ix = 0; ix < gtf_count; ix++) {
                u8 *gtf = (u8 *)(gtf_address + ix * REGS_PER_GTF);
-               ide_task_t task;
+               struct ide_cmd cmd;
 
                DEBPRINT("(0x1f1-1f7): "
                         "hex: %02x %02x %02x %02x %02x %02x %02x\n",
@@ -317,11 +317,11 @@ static int do_drive_set_taskfiles(ide_drive_t *drive,
                }
 
                /* convert GTF to taskfile */
-               memset(&task, 0, sizeof(ide_task_t));
-               memcpy(&task.tf_array[7], gtf, REGS_PER_GTF);
-               task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+               memset(&cmd, 0, sizeof(cmd));
+               memcpy(&cmd.tf_array[7], gtf, REGS_PER_GTF);
+               cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
-               err = ide_no_data_taskfile(drive, &task);
+               err = ide_no_data_taskfile(drive, &cmd);
                if (err) {
                        printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n",
                                        __func__, err);
index 2b9ac2106674d8827ac8b3f3c1343dd2007ab14b..92c6ef6feb57ec5ef17b765871d92f602b9c0f7b 100644 (file)
@@ -302,16 +302,16 @@ EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
 
 void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
 {
-       ide_task_t task;
+       struct ide_cmd cmd;
 
-       memset(&task, 0, sizeof(task));
-       task.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |
-                       IDE_TFLAG_IN_NSECT;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |
+                      IDE_TFLAG_IN_NSECT;
 
-       drive->hwif->tp_ops->tf_read(drive, &task);
+       drive->hwif->tp_ops->tf_read(drive, &cmd);
 
-       *bcount = (task.tf.lbah << 8) | task.tf.lbam;
-       *ireason = task.tf.nsect & 3;
+       *bcount = (cmd.tf.lbah << 8) | cmd.tf.lbam;
+       *ireason = cmd.tf.nsect & 3;
 }
 EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
 
@@ -482,32 +482,32 @@ next_irq:
 static void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount)
 {
        ide_hwif_t *hwif = drive->hwif;
-       ide_task_t task;
+       struct ide_cmd cmd;
        u8 dma = drive->dma;
 
-       memset(&task, 0, sizeof(task));
-       task.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM |
-                       IDE_TFLAG_OUT_FEATURE | tf_flags;
-       task.tf.feature = dma;          /* Use PIO/DMA */
-       task.tf.lbam    = bcount & 0xff;
-       task.tf.lbah    = (bcount >> 8) & 0xff;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM |
+                      IDE_TFLAG_OUT_FEATURE | tf_flags;
+       cmd.tf.feature = dma;           /* Use PIO/DMA */
+       cmd.tf.lbam    = bcount & 0xff;
+       cmd.tf.lbah    = (bcount >> 8) & 0xff;
 
-       ide_tf_dump(drive->name, &task.tf);
+       ide_tf_dump(drive->name, &cmd.tf);
        hwif->tp_ops->set_irq(hwif, 1);
        SELECT_MASK(drive, 0);
-       hwif->tp_ops->tf_load(drive, &task);
+       hwif->tp_ops->tf_load(drive, &cmd);
 }
 
 static u8 ide_read_ireason(ide_drive_t *drive)
 {
-       ide_task_t task;
+       struct ide_cmd cmd;
 
-       memset(&task, 0, sizeof(task));
-       task.tf_flags = IDE_TFLAG_IN_NSECT;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf_flags = IDE_TFLAG_IN_NSECT;
 
-       drive->hwif->tp_ops->tf_read(drive, &task);
+       drive->hwif->tp_ops->tf_read(drive, &cmd);
 
-       return task.tf.nsect & 3;
+       return cmd.tf.nsect & 3;
 }
 
 static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
index 912be155a8c16207419c8de23ab9f68864ba884e..6647cb8bd910e65811bfd7d0546fe2abba092050 100644 (file)
@@ -62,24 +62,24 @@ static const u8 ide_data_phases[] = {
        TASKFILE_OUT_DMA,
 };
 
-static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
+static void ide_tf_set_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 dma)
 {
        u8 index, lba48, write;
 
-       lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
-       write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
+       lba48 = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
+       write = (cmd->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
 
        if (dma)
                index = 8;
        else
                index = drive->mult_count ? 0 : 4;
 
-       task->tf.command = ide_rw_cmds[index + lba48 + write];
+       cmd->tf.command = ide_rw_cmds[index + lba48 + write];
 
        if (dma)
                index = 8; /* fixup index */
 
-       task->data_phase = ide_data_phases[index / 2 + write];
+       cmd->data_phase = ide_data_phases[index / 2 + write];
 }
 
 /*
@@ -93,8 +93,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
        u16 nsectors            = (u16)rq->nr_sectors;
        u8 lba48                = !!(drive->dev_flags & IDE_DFLAG_LBA48);
        u8 dma                  = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
-       ide_task_t              task;
-       struct ide_taskfile     *tf = &task.tf;
+       struct ide_cmd          cmd;
+       struct ide_taskfile     *tf = &cmd.tf;
        ide_startstop_t         rc;
 
        if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
@@ -109,8 +109,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
                ide_map_sg(drive, rq);
        }
 
-       memset(&task, 0, sizeof(task));
-       task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
        if (drive->dev_flags & IDE_DFLAG_LBA) {
                if (lba48) {
@@ -129,7 +129,7 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
                        tf->lbam   = (u8)(block >>  8);
                        tf->lbah   = (u8)(block >> 16);
 
-                       task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
+                       cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
                } else {
                        tf->nsect  = nsectors & 0xff;
                        tf->lbal   = block;
@@ -157,19 +157,19 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
        }
 
        if (rq_data_dir(rq))
-               task.tf_flags |= IDE_TFLAG_WRITE;
+               cmd.tf_flags |= IDE_TFLAG_WRITE;
 
-       ide_tf_set_cmd(drive, &task, dma);
-       task.rq = rq;
+       ide_tf_set_cmd(drive, &cmd, dma);
+       cmd.rq = rq;
 
-       rc = do_rw_taskfile(drive, &task);
+       rc = do_rw_taskfile(drive, &cmd);
 
        if (rc == ide_stopped && dma) {
                /* fallback to PIO */
-               task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
-               ide_tf_set_cmd(drive, &task, 0);
+               cmd.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
+               ide_tf_set_cmd(drive, &cmd, 0);
                ide_init_sg_cmd(drive, rq);
-               rc = do_rw_taskfile(drive, &task);
+               rc = do_rw_taskfile(drive, &cmd);
        }
 
        return rc;
@@ -213,22 +213,22 @@ static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
  */
 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
 {
-       ide_task_t args;
-       struct ide_taskfile *tf = &args.tf;
+       struct ide_cmd cmd;
+       struct ide_taskfile *tf = &cmd.tf;
        u64 addr = 0;
 
-       /* Create IDE/ATA command request structure */
-       memset(&args, 0, sizeof(ide_task_t));
+       memset(&cmd, 0, sizeof(cmd));
        if (lba48)
                tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
        else
                tf->command = ATA_CMD_READ_NATIVE_MAX;
        tf->device  = ATA_LBA;
-       args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+
+       cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
        if (lba48)
-               args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
-       /* submit command request */
-       ide_no_data_taskfile(drive, &args);
+               cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
+
+       ide_no_data_taskfile(drive, &cmd);
 
        /* if OK, compute maximum address value */
        if ((tf->status & 0x01) == 0)
@@ -243,13 +243,13 @@ static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
  */
 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
 {
-       ide_task_t args;
-       struct ide_taskfile *tf = &args.tf;
+       struct ide_cmd cmd;
+       struct ide_taskfile *tf = &cmd.tf;
        u64 addr_set = 0;
 
        addr_req--;
-       /* Create IDE/ATA command request structure */
-       memset(&args, 0, sizeof(ide_task_t));
+
+       memset(&cmd, 0, sizeof(cmd));
        tf->lbal     = (addr_req >>  0) & 0xff;
        tf->lbam     = (addr_req >>= 8) & 0xff;
        tf->lbah     = (addr_req >>= 8) & 0xff;
@@ -263,11 +263,13 @@ static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
                tf->command  = ATA_CMD_SET_MAX;
        }
        tf->device |= ATA_LBA;
-       args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+
+       cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
        if (lba48)
-               args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
-       /* submit command request */
-       ide_no_data_taskfile(drive, &args);
+               cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
+
+       ide_no_data_taskfile(drive, &cmd);
+
        /* if OK, compute maximum address value */
        if ((tf->status & 0x01) == 0)
                addr_set = ide_get_lba_addr(tf, lba48) + 1;
@@ -386,24 +388,24 @@ static int ide_disk_get_capacity(ide_drive_t *drive)
 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 {
        ide_drive_t *drive = q->queuedata;
-       ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
+       struct ide_cmd *cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
 
        /* FIXME: map struct ide_taskfile on rq->cmd[] */
-       BUG_ON(task == NULL);
+       BUG_ON(cmd == NULL);
 
-       memset(task, 0, sizeof(*task));
+       memset(cmd, 0, sizeof(*cmd));
        if (ata_id_flush_ext_enabled(drive->id) &&
            (drive->capacity64 >= (1UL << 28)))
-               task->tf.command = ATA_CMD_FLUSH_EXT;
+               cmd->tf.command = ATA_CMD_FLUSH_EXT;
        else
-               task->tf.command = ATA_CMD_FLUSH;
-       task->tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
+               cmd->tf.command = ATA_CMD_FLUSH;
+       cmd->tf_flags    = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
                           IDE_TFLAG_DYN;
-       task->data_phase = TASKFILE_NO_DATA;
+       cmd->data_phase = TASKFILE_NO_DATA;
 
        rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
        rq->cmd_flags |= REQ_SOFTBARRIER;
-       rq->special = task;
+       rq->special = cmd;
 }
 
 ide_devset_get(multcount, mult_count);
@@ -453,15 +455,15 @@ static int set_nowerr(ide_drive_t *drive, int arg)
 
 static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
 {
-       ide_task_t task;
+       struct ide_cmd cmd;
 
-       memset(&task, 0, sizeof(task));
-       task.tf.feature = feature;
-       task.tf.nsect   = nsect;
-       task.tf.command = ATA_CMD_SET_FEATURES;
-       task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf.feature = feature;
+       cmd.tf.nsect   = nsect;
+       cmd.tf.command = ATA_CMD_SET_FEATURES;
+       cmd.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
-       return ide_no_data_taskfile(drive, &task);
+       return ide_no_data_taskfile(drive, &cmd);
 }
 
 static void update_ordered(ide_drive_t *drive)
@@ -528,15 +530,16 @@ static int set_wcache(ide_drive_t *drive, int arg)
 
 static int do_idedisk_flushcache(ide_drive_t *drive)
 {
-       ide_task_t args;
+       struct ide_cmd cmd;
 
-       memset(&args, 0, sizeof(ide_task_t));
+       memset(&cmd, 0, sizeof(cmd));
        if (ata_id_flush_ext_enabled(drive->id))
-               args.tf.command = ATA_CMD_FLUSH_EXT;
+               cmd.tf.command = ATA_CMD_FLUSH_EXT;
        else
-               args.tf.command = ATA_CMD_FLUSH;
-       args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-       return ide_no_data_taskfile(drive, &args);
+               cmd.tf.command = ATA_CMD_FLUSH;
+       cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+
+       return ide_no_data_taskfile(drive, &cmd);
 }
 
 ide_devset_get(acoustic, acoustic);
@@ -708,17 +711,17 @@ static int ide_disk_init_media(ide_drive_t *drive, struct gendisk *disk)
 static int ide_disk_set_doorlock(ide_drive_t *drive, struct gendisk *disk,
                                 int on)
 {
-       ide_task_t task;
+       struct ide_cmd cmd;
        int ret;
 
        if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
                return 0;
 
-       memset(&task, 0, sizeof(task));
-       task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
-       task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
+       cmd.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
-       ret = ide_no_data_taskfile(drive, &task);
+       ret = ide_no_data_taskfile(drive, &cmd);
 
        if (ret)
                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
index 5766c1f62ad2abd7964bedd4804ba6b86d77a74f..afe4f47e9e1993de5bd064d0f17e8734b8b037be 100644 (file)
@@ -6,33 +6,34 @@
 
 static int smart_enable(ide_drive_t *drive)
 {
-       ide_task_t args;
-       struct ide_taskfile *tf = &args.tf;
+       struct ide_cmd cmd;
+       struct ide_taskfile *tf = &cmd.tf;
 
-       memset(&args, 0, sizeof(ide_task_t));
+       memset(&cmd, 0, sizeof(cmd));
        tf->feature = ATA_SMART_ENABLE;
        tf->lbam    = ATA_SMART_LBAM_PASS;
        tf->lbah    = ATA_SMART_LBAH_PASS;
        tf->command = ATA_CMD_SMART;
-       args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-       return ide_no_data_taskfile(drive, &args);
+       cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+
+       return ide_no_data_taskfile(drive, &cmd);
 }
 
 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
 {
-       ide_task_t args;
-       struct ide_taskfile *tf = &args.tf;
+       struct ide_cmd cmd;
+       struct ide_taskfile *tf = &cmd.tf;
 
-       memset(&args, 0, sizeof(ide_task_t));
+       memset(&cmd, 0, sizeof(cmd));
        tf->feature = sub_cmd;
        tf->nsect   = 0x01;
        tf->lbam    = ATA_SMART_LBAM_PASS;
        tf->lbah    = ATA_SMART_LBAH_PASS;
        tf->command = ATA_CMD_SMART;
-       args.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-       args.data_phase = TASKFILE_IN;
+       cmd.tf_flags    = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+       cmd.data_phase  = TASKFILE_IN;
 
-       return ide_raw_taskfile(drive, &args, buf, 1);
+       return ide_raw_taskfile(drive, &cmd, buf, 1);
 }
 
 static int proc_idedisk_read_cache
index e2c04886616f1668e8480788b5b3525a570279d7..f6e1a82a3cc5f8f65cb936b19b6ca761a542ea3a 100644 (file)
@@ -125,10 +125,10 @@ ide_startstop_t ide_error(ide_drive_t *drive, const char *msg, u8 stat)
        if (!blk_fs_request(rq)) {
                rq->errors = 1;
                if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
-                       ide_task_t *task = rq->special;
+                       struct ide_cmd *cmd = rq->special;
 
-                       if (task)
-                               ide_complete_task(drive, task, stat, err);
+                       if (cmd)
+                               ide_complete_cmd(drive, cmd, stat, err);
                } else if (blk_pm_request(rq)) {
                        ide_complete_pm_rq(drive, rq);
                        return ide_stopped;
index 11e937485bff2b6c77a7f6ef4c77474141d8b06d..c7883f23c66a87d7d6633fa0f09d62df01309f64 100644 (file)
@@ -44,53 +44,53 @@ static u16 mm_inw(unsigned long a)
        return r;
 }
 
-static void h8300_tf_load(ide_drive_t *drive, ide_task_t *task)
+static void h8300_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
-       u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
+       struct ide_taskfile *tf = &cmd->tf;
+       u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
 
-       if (task->ftf_flags & IDE_FTFLAG_FLAGGED)
+       if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
                HIHI = 0xFF;
 
-       if (task->ftf_flags & IDE_FTFLAG_OUT_DATA)
+       if (cmd->ftf_flags & IDE_FTFLAG_OUT_DATA)
                mm_outw((tf->hob_data << 8) | tf->data, io_ports->data_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
                outb(tf->hob_feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
                outb(tf->hob_nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
                outb(tf->hob_lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
                outb(tf->hob_lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
                outb(tf->hob_lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
                outb(tf->feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
                outb(tf->nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
                outb(tf->lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
                outb(tf->lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
                outb(tf->lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
                outb((tf->device & HIHI) | drive->select,
                     io_ports->device_addr);
 }
 
-static void h8300_tf_read(ide_drive_t *drive, ide_task_t *task)
+static void h8300_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
 
-       if (task->ftf_flags & IDE_FTFLAG_IN_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) {
                u16 data = mm_inw(io_ports->data_addr);
 
                tf->data = data & 0xff;
@@ -100,31 +100,31 @@ static void h8300_tf_read(ide_drive_t *drive, ide_task_t *task)
        /* be sure we're looking at the low order bits */
        outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
 
-       if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_FEATURE)
                tf->feature = inb(io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
                tf->nsect  = inb(io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
                tf->lbal   = inb(io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
                tf->lbam   = inb(io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
                tf->lbah   = inb(io_ports->lbah_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
                tf->device = inb(io_ports->device_addr);
 
-       if (task->tf_flags & IDE_TFLAG_LBA48) {
+       if (cmd->tf_flags & IDE_TFLAG_LBA48) {
                outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
 
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
                        tf->hob_feature = inb(io_ports->feature_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
                        tf->hob_nsect   = inb(io_ports->nsect_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
                        tf->hob_lbal    = inb(io_ports->lbal_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
                        tf->hob_lbam    = inb(io_ports->lbam_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
                        tf->hob_lbah    = inb(io_ports->lbah_addr);
        }
 }
index cad59f0bfbce395d3b9ce284d2b16e4fb3864ca1..570c0cc4514dc248b4e65e69de21190d410e5d9e 100644 (file)
@@ -82,24 +82,24 @@ void ide_set_irq(ide_hwif_t *hwif, int on)
 }
 EXPORT_SYMBOL_GPL(ide_set_irq);
 
-void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
+void ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
        void (*tf_outb)(u8 addr, unsigned long port);
        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
-       u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
+       u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
 
        if (mmio)
                tf_outb = ide_mm_outb;
        else
                tf_outb = ide_outb;
 
-       if (task->ftf_flags & IDE_FTFLAG_FLAGGED)
+       if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
                HIHI = 0xFF;
 
-       if (task->ftf_flags & IDE_FTFLAG_OUT_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_OUT_DATA) {
                u16 data = (tf->hob_data << 8) | tf->data;
 
                if (mmio)
@@ -108,39 +108,39 @@ void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
                        outw(data, io_ports->data_addr);
        }
 
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
                tf_outb(tf->hob_feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
                tf_outb(tf->hob_nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
                tf_outb(tf->hob_lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
                tf_outb(tf->hob_lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
                tf_outb(tf->hob_lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
                tf_outb(tf->feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
                tf_outb(tf->nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
                tf_outb(tf->lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
                tf_outb(tf->lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
                tf_outb(tf->lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
                tf_outb((tf->device & HIHI) | drive->select,
                         io_ports->device_addr);
 }
 EXPORT_SYMBOL_GPL(ide_tf_load);
 
-void ide_tf_read(ide_drive_t *drive, ide_task_t *task)
+void ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
        void (*tf_outb)(u8 addr, unsigned long port);
        u8 (*tf_inb)(unsigned long port);
        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
@@ -153,7 +153,7 @@ void ide_tf_read(ide_drive_t *drive, ide_task_t *task)
                tf_inb  = ide_inb;
        }
 
-       if (task->ftf_flags & IDE_FTFLAG_IN_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) {
                u16 data;
 
                if (mmio)
@@ -168,31 +168,31 @@ void ide_tf_read(ide_drive_t *drive, ide_task_t *task)
        /* be sure we're looking at the low order bits */
        tf_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
 
-       if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_FEATURE)
                tf->feature = tf_inb(io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
                tf->nsect  = tf_inb(io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
                tf->lbal   = tf_inb(io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
                tf->lbam   = tf_inb(io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
                tf->lbah   = tf_inb(io_ports->lbah_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
                tf->device = tf_inb(io_ports->device_addr);
 
-       if (task->tf_flags & IDE_TFLAG_LBA48) {
+       if (cmd->tf_flags & IDE_TFLAG_LBA48) {
                tf_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
 
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
                        tf->hob_feature = tf_inb(io_ports->feature_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
                        tf->hob_nsect   = tf_inb(io_ports->nsect_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
                        tf->hob_lbal    = tf_inb(io_ports->lbal_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
                        tf->hob_lbam    = tf_inb(io_ports->lbam_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
                        tf->hob_lbah    = tf_inb(io_ports->lbah_addr);
        }
 }
index 6eee41beec732e635bc265aa40e2269b0a02f6cf..2900271c6ddd78c3c6dad6c912b77f79ae0d7631 100644 (file)
@@ -144,21 +144,21 @@ int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
 }
 EXPORT_SYMBOL_GPL(ide_end_dequeued_request);
 
-void ide_complete_task(ide_drive_t *drive, ide_task_t *task, u8 stat, u8 err)
+void ide_complete_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat, u8 err)
 {
-       struct ide_taskfile *tf = &task->tf;
-       struct request *rq = task->rq;
+       struct ide_taskfile *tf = &cmd->tf;
+       struct request *rq = cmd->rq;
 
        tf->error = err;
        tf->status = stat;
 
-       drive->hwif->tp_ops->tf_read(drive, task);
+       drive->hwif->tp_ops->tf_read(drive, cmd);
 
        if (rq && rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
-               memcpy(rq->special, task, sizeof(*task));
+               memcpy(rq->special, cmd, sizeof(*cmd));
 
-       if (task->tf_flags & IDE_TFLAG_DYN)
-               kfree(task);
+       if (cmd->tf_flags & IDE_TFLAG_DYN)
+               kfree(cmd);
 }
 
 void ide_complete_rq(ide_drive_t *drive, u8 err)
@@ -217,20 +217,20 @@ static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
 static ide_startstop_t ide_disk_special(ide_drive_t *drive)
 {
        special_t *s = &drive->special;
-       ide_task_t args;
+       struct ide_cmd cmd;
 
-       memset(&args, 0, sizeof(ide_task_t));
-       args.data_phase = TASKFILE_NO_DATA;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.data_phase = TASKFILE_NO_DATA;
 
        if (s->b.set_geometry) {
                s->b.set_geometry = 0;
-               ide_tf_set_specify_cmd(drive, &args.tf);
+               ide_tf_set_specify_cmd(drive, &cmd.tf);
        } else if (s->b.recalibrate) {
                s->b.recalibrate = 0;
-               ide_tf_set_restore_cmd(drive, &args.tf);
+               ide_tf_set_restore_cmd(drive, &cmd.tf);
        } else if (s->b.set_multmode) {
                s->b.set_multmode = 0;
-               ide_tf_set_setmult_cmd(drive, &args.tf);
+               ide_tf_set_setmult_cmd(drive, &cmd.tf);
        } else if (s->all) {
                int special = s->all;
                s->all = 0;
@@ -238,10 +238,10 @@ static ide_startstop_t ide_disk_special(ide_drive_t *drive)
                return ide_stopped;
        }
 
-       args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE |
-                       IDE_TFLAG_CUSTOM_HANDLER;
+       cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE |
+                      IDE_TFLAG_CUSTOM_HANDLER;
 
-       do_rw_taskfile(drive, &args);
+       do_rw_taskfile(drive, &cmd);
 
        return ide_started;
 }
@@ -315,10 +315,10 @@ EXPORT_SYMBOL_GPL(ide_init_sg_cmd);
 static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                struct request *rq)
 {
-       ide_task_t *task = rq->special;
+       struct ide_cmd *cmd = rq->special;
 
-       if (task) {
-               switch (task->data_phase) {
+       if (cmd) {
+               switch (cmd->data_phase) {
                case TASKFILE_MULTI_OUT:
                case TASKFILE_OUT:
                case TASKFILE_MULTI_IN:
@@ -329,7 +329,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                        break;
                }
 
-               return do_rw_taskfile(drive, task);
+               return do_rw_taskfile(drive, cmd);
        }
 
        /*
index 1be263eb9c071c3cf7e3b48e0010ec9d4f02f476..4953028a13d47e603163789aa3c3251415a421d2 100644 (file)
@@ -111,13 +111,13 @@ static int ide_set_nice_ioctl(ide_drive_t *drive, unsigned long arg)
        return 0;
 }
 
-static int ide_cmd_ioctl(ide_drive_t *drive, unsigned cmd, unsigned long arg)
+static int ide_cmd_ioctl(ide_drive_t *drive, unsigned long arg)
 {
        u8 *buf = NULL;
        int bufsize = 0, err = 0;
        u8 args[4], xfer_rate = 0;
-       ide_task_t tfargs;
-       struct ide_taskfile *tf = &tfargs.tf;
+       struct ide_cmd cmd;
+       struct ide_taskfile *tf = &cmd.tf;
        u16 *id = drive->id;
 
        if (NULL == (void *) arg) {
@@ -134,24 +134,24 @@ static int ide_cmd_ioctl(ide_drive_t *drive, unsigned cmd, unsigned long arg)
        if (copy_from_user(args, (void __user *)arg, 4))
                return -EFAULT;
 
-       memset(&tfargs, 0, sizeof(ide_task_t));
+       memset(&cmd, 0, sizeof(cmd));
        tf->feature = args[2];
        if (args[0] == ATA_CMD_SMART) {
                tf->nsect = args[3];
                tf->lbal  = args[1];
                tf->lbam  = 0x4f;
                tf->lbah  = 0xc2;
-               tfargs.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_IN_NSECT;
+               cmd.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_IN_NSECT;
        } else {
                tf->nsect = args[1];
-               tfargs.tf_flags = IDE_TFLAG_OUT_FEATURE |
-                                 IDE_TFLAG_OUT_NSECT | IDE_TFLAG_IN_NSECT;
+               cmd.tf_flags = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT |
+                              IDE_TFLAG_IN_NSECT;
        }
        tf->command = args[0];
-       tfargs.data_phase = args[3] ? TASKFILE_IN : TASKFILE_NO_DATA;
+       cmd.data_phase = args[3] ? TASKFILE_IN : TASKFILE_NO_DATA;
 
        if (args[3]) {
-               tfargs.tf_flags |= IDE_TFLAG_IO_16BIT;
+               cmd.tf_flags |= IDE_TFLAG_IO_16BIT;
                bufsize = SECTOR_SIZE * args[3];
                buf = kzalloc(bufsize, GFP_KERNEL);
                if (buf == NULL)
@@ -172,7 +172,7 @@ static int ide_cmd_ioctl(ide_drive_t *drive, unsigned cmd, unsigned long arg)
                }
        }
 
-       err = ide_raw_taskfile(drive, &tfargs, buf, args[3]);
+       err = ide_raw_taskfile(drive, &cmd, buf, args[3]);
 
        args[0] = tf->status;
        args[1] = tf->error;
@@ -194,25 +194,25 @@ abort:
        return err;
 }
 
-static int ide_task_ioctl(ide_drive_t *drive, unsigned cmd, unsigned long arg)
+static int ide_task_ioctl(ide_drive_t *drive, unsigned long arg)
 {
        void __user *p = (void __user *)arg;
        int err = 0;
        u8 args[7];
-       ide_task_t task;
+       struct ide_cmd cmd;
 
        if (copy_from_user(args, p, 7))
                return -EFAULT;
 
-       memset(&task, 0, sizeof(task));
-       memcpy(&task.tf_array[7], &args[1], 6);
-       task.tf.command = args[0];
-       task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+       memset(&cmd, 0, sizeof(cmd));
+       memcpy(&cmd.tf_array[7], &args[1], 6);
+       cmd.tf.command = args[0];
+       cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
-       err = ide_no_data_taskfile(drive, &task);
+       err = ide_no_data_taskfile(drive, &cmd);
 
-       args[0] = task.tf.command;
-       memcpy(&args[1], &task.tf_array[7], 6);
+       args[0] = cmd.tf.command;
+       memcpy(&args[1], &cmd.tf_array[7], 6);
 
        if (copy_to_user(p, args, 7))
                err = -EFAULT;
@@ -262,17 +262,17 @@ int generic_ide_ioctl(ide_drive_t *drive, struct block_device *bdev,
                if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
                        return -EACCES;
                if (drive->media == ide_disk)
-                       return ide_taskfile_ioctl(drive, cmd, arg);
+                       return ide_taskfile_ioctl(drive, arg);
                return -ENOMSG;
 #endif
        case HDIO_DRIVE_CMD:
                if (!capable(CAP_SYS_RAWIO))
                        return -EACCES;
-               return ide_cmd_ioctl(drive, cmd, arg);
+               return ide_cmd_ioctl(drive, arg);
        case HDIO_DRIVE_TASK:
                if (!capable(CAP_SYS_RAWIO))
                        return -EACCES;
-               return ide_task_ioctl(drive, cmd, arg);
+               return ide_task_ioctl(drive, arg);
        case HDIO_DRIVE_RESET:
                if (!capable(CAP_SYS_ADMIN))
                        return -EACCES;
index 317c5dadd7c0220b3021049bc2bb2415eb0e0172..c3023de7270c351d751af69b43c8a4474c659761 100644 (file)
@@ -31,15 +31,15 @@ void SELECT_DRIVE(ide_drive_t *drive)
 {
        ide_hwif_t *hwif = drive->hwif;
        const struct ide_port_ops *port_ops = hwif->port_ops;
-       ide_task_t task;
+       struct ide_cmd cmd;
 
        if (port_ops && port_ops->selectproc)
                port_ops->selectproc(drive);
 
-       memset(&task, 0, sizeof(task));
-       task.tf_flags = IDE_TFLAG_OUT_DEVICE;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf_flags = IDE_TFLAG_OUT_DEVICE;
 
-       drive->hwif->tp_ops->tf_load(drive, &task);
+       drive->hwif->tp_ops->tf_load(drive, &cmd);
 }
 
 void SELECT_MASK(ide_drive_t *drive, int mask)
@@ -52,14 +52,14 @@ void SELECT_MASK(ide_drive_t *drive, int mask)
 
 u8 ide_read_error(ide_drive_t *drive)
 {
-       ide_task_t task;
+       struct ide_cmd cmd;
 
-       memset(&task, 0, sizeof(task));
-       task.tf_flags = IDE_TFLAG_IN_FEATURE;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf_flags = IDE_TFLAG_IN_FEATURE;
 
-       drive->hwif->tp_ops->tf_read(drive, &task);
+       drive->hwif->tp_ops->tf_read(drive, &cmd);
 
-       return task.tf.error;
+       return cmd.tf.error;
 }
 EXPORT_SYMBOL_GPL(ide_read_error);
 
@@ -329,7 +329,7 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
        u16 *id = drive->id, i;
        int error = 0;
        u8 stat;
-       ide_task_t task;
+       struct ide_cmd cmd;
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
        if (hwif->dma_ops)      /* check if host supports DMA */
@@ -361,12 +361,12 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
        udelay(1);
        tp_ops->set_irq(hwif, 0);
 
-       memset(&task, 0, sizeof(task));
-       task.tf_flags = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT;
-       task.tf.feature = SETFEATURES_XFER;
-       task.tf.nsect   = speed;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf_flags = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT;
+       cmd.tf.feature = SETFEATURES_XFER;
+       cmd.tf.nsect   = speed;
 
-       tp_ops->tf_load(drive, &task);
+       tp_ops->tf_load(drive, &cmd);
 
        tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
 
index f6c683dd29873bad3ef622e6defe6785ed6f1b39..217b7fdf2b1779f7ea881a140ba6bc84e998cc57 100644 (file)
@@ -34,19 +34,19 @@ void ide_toggle_bounce(ide_drive_t *drive, int on)
 static void ide_dump_opcode(ide_drive_t *drive)
 {
        struct request *rq = drive->hwif->rq;
-       ide_task_t *task = NULL;
+       struct ide_cmd *cmd = NULL;
 
        if (!rq)
                return;
 
        if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
-               task = rq->special;
+               cmd = rq->special;
 
        printk(KERN_ERR "ide: failed opcode was: ");
-       if (task == NULL)
+       if (cmd == NULL)
                printk(KERN_CONT "unknown\n");
        else
-               printk(KERN_CONT "0x%02x\n", task->tf.command);
+               printk(KERN_CONT "0x%02x\n", cmd->tf.command);
 }
 
 u64 ide_get_lba_addr(struct ide_taskfile *tf, int lba48)
@@ -66,18 +66,18 @@ EXPORT_SYMBOL_GPL(ide_get_lba_addr);
 
 static void ide_dump_sector(ide_drive_t *drive)
 {
-       ide_task_t task;
-       struct ide_taskfile *tf = &task.tf;
+       struct ide_cmd cmd;
+       struct ide_taskfile *tf = &cmd.tf;
        u8 lba48 = !!(drive->dev_flags & IDE_DFLAG_LBA48);
 
-       memset(&task, 0, sizeof(task));
+       memset(&cmd, 0, sizeof(cmd));
        if (lba48)
-               task.tf_flags = IDE_TFLAG_IN_LBA | IDE_TFLAG_IN_HOB_LBA |
+               cmd.tf_flags = IDE_TFLAG_IN_LBA | IDE_TFLAG_IN_HOB_LBA |
                                IDE_TFLAG_LBA48;
        else
-               task.tf_flags = IDE_TFLAG_IN_LBA | IDE_TFLAG_IN_DEVICE;
+               cmd.tf_flags = IDE_TFLAG_IN_LBA | IDE_TFLAG_IN_DEVICE;
 
-       drive->hwif->tp_ops->tf_read(drive, &task);
+       drive->hwif->tp_ops->tf_read(drive, &cmd);
 
        if (lba48 || (tf->device & ATA_LBA))
                printk(KERN_CONT ", LBAsect=%llu",
index cddc7c7787608a518a320a1579c4b66fce196844..63c77f99a726a9b3836fa743f4a508195e639f92 100644 (file)
@@ -63,10 +63,10 @@ out:
 
 ide_startstop_t ide_do_park_unpark(ide_drive_t *drive, struct request *rq)
 {
-       ide_task_t task;
-       struct ide_taskfile *tf = &task.tf;
+       struct ide_cmd cmd;
+       struct ide_taskfile *tf = &cmd.tf;
 
-       memset(&task, 0, sizeof(task));
+       memset(&cmd, 0, sizeof(cmd));
        if (rq->cmd[0] == REQ_PARK_HEADS) {
                drive->sleep = *(unsigned long *)rq->special;
                drive->dev_flags |= IDE_DFLAG_SLEEPING;
@@ -75,14 +75,15 @@ ide_startstop_t ide_do_park_unpark(ide_drive_t *drive, struct request *rq)
                tf->lbal = 0x4c;
                tf->lbam = 0x4e;
                tf->lbah = 0x55;
-               task.tf_flags |= IDE_TFLAG_CUSTOM_HANDLER;
+               cmd.tf_flags |= IDE_TFLAG_CUSTOM_HANDLER;
        } else          /* cmd == REQ_UNPARK_HEADS */
                tf->command = ATA_CMD_CHK_POWER;
 
-       task.tf_flags |= IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-       task.rq = rq;
-       task.data_phase = TASKFILE_NO_DATA;
-       return do_rw_taskfile(drive, &task);
+       cmd.tf_flags |= IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+       cmd.rq = rq;
+       cmd.data_phase = TASKFILE_NO_DATA;
+
+       return do_rw_taskfile(drive, &cmd);
 }
 
 ssize_t ide_park_show(struct device *dev, struct device_attribute *attr,
index 74c7c2bbe0fdf41df69c605049b114cecd410c30..5c9fc20f95b58519893ebb42a0fe60420d030c8d 100644 (file)
@@ -8,7 +8,7 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
        ide_hwif_t *hwif = drive->hwif;
        struct request *rq;
        struct request_pm_state rqpm;
-       ide_task_t args;
+       struct ide_cmd cmd;
        int ret;
 
        /* call ACPI _GTM only once */
@@ -16,10 +16,10 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
                ide_acpi_get_timing(hwif);
 
        memset(&rqpm, 0, sizeof(rqpm));
-       memset(&args, 0, sizeof(args));
+       memset(&cmd, 0, sizeof(cmd));
        rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
        rq->cmd_type = REQ_TYPE_PM_SUSPEND;
-       rq->special = &args;
+       rq->special = &cmd;
        rq->data = &rqpm;
        rqpm.pm_step = IDE_PM_START_SUSPEND;
        if (mesg.event == PM_EVENT_PRETHAW)
@@ -42,7 +42,7 @@ int generic_ide_resume(struct device *dev)
        ide_hwif_t *hwif = drive->hwif;
        struct request *rq;
        struct request_pm_state rqpm;
-       ide_task_t args;
+       struct ide_cmd cmd;
        int err;
 
        /* call ACPI _PS0 / _STM only once */
@@ -54,11 +54,11 @@ int generic_ide_resume(struct device *dev)
        ide_acpi_exec_tfs(drive);
 
        memset(&rqpm, 0, sizeof(rqpm));
-       memset(&args, 0, sizeof(args));
+       memset(&cmd, 0, sizeof(cmd));
        rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
        rq->cmd_type = REQ_TYPE_PM_RESUME;
        rq->cmd_flags |= REQ_PREEMPT;
-       rq->special = &args;
+       rq->special = &cmd;
        rq->data = &rqpm;
        rqpm.pm_step = IDE_PM_START_RESUME;
        rqpm.pm_state = PM_EVENT_ON;
@@ -109,9 +109,9 @@ void ide_complete_power_step(ide_drive_t *drive, struct request *rq)
 ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
 {
        struct request_pm_state *pm = rq->data;
-       ide_task_t *args = rq->special;
+       struct ide_cmd *cmd = rq->special;
 
-       memset(args, 0, sizeof(*args));
+       memset(cmd, 0, sizeof(*cmd));
 
        switch (pm->pm_step) {
        case IDE_PM_FLUSH_CACHE:        /* Suspend step 1 (flush cache) */
@@ -124,12 +124,12 @@ ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
                        return ide_stopped;
                }
                if (ata_id_flush_ext_enabled(drive->id))
-                       args->tf.command = ATA_CMD_FLUSH_EXT;
+                       cmd->tf.command = ATA_CMD_FLUSH_EXT;
                else
-                       args->tf.command = ATA_CMD_FLUSH;
+                       cmd->tf.command = ATA_CMD_FLUSH;
                goto out_do_tf;
        case IDE_PM_STANDBY:            /* Suspend step 2 (standby) */
-               args->tf.command = ATA_CMD_STANDBYNOW1;
+               cmd->tf.command = ATA_CMD_STANDBYNOW1;
                goto out_do_tf;
        case IDE_PM_RESTORE_PIO:        /* Resume step 1 (restore PIO) */
                ide_set_max_pio(drive);
@@ -142,7 +142,7 @@ ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
                        ide_complete_power_step(drive, rq);
                return ide_stopped;
        case IDE_PM_IDLE:               /* Resume step 2 (idle) */
-               args->tf.command = ATA_CMD_IDLEIMMEDIATE;
+               cmd->tf.command = ATA_CMD_IDLEIMMEDIATE;
                goto out_do_tf;
        case IDE_PM_RESTORE_DMA:        /* Resume step 3 (restore DMA) */
                /*
@@ -160,12 +160,14 @@ ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
        }
 
        pm->pm_step = IDE_PM_COMPLETED;
+
        return ide_stopped;
 
 out_do_tf:
-       args->tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-       args->data_phase = TASKFILE_NO_DATA;
-       return do_rw_taskfile(drive, args);
+       cmd->tf_flags    = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+       cmd->data_phase = TASKFILE_NO_DATA;
+
+       return do_rw_taskfile(drive, cmd);
 }
 
 /**
index 335322f40c5a1ea5a777811213f3869fc15d5cda..548864510ba9a88cf4af72042e317fe899f9f5ab 100644 (file)
@@ -283,13 +283,13 @@ int ide_dev_read_id(ide_drive_t *drive, u8 cmd, u16 *id)
         * identify command to be sure of reply
         */
        if (cmd == ATA_CMD_ID_ATAPI) {
-               ide_task_t task;
+               struct ide_cmd cmd;
 
-               memset(&task, 0, sizeof(task));
+               memset(&cmd, 0, sizeof(cmd));
                /* disable DMA & overlap */
-               task.tf_flags = IDE_TFLAG_OUT_FEATURE;
+               cmd.tf_flags = IDE_TFLAG_OUT_FEATURE;
 
-               tp_ops->tf_load(drive, &task);
+               tp_ops->tf_load(drive, &cmd);
        }
 
        /* ask drive for ID */
@@ -337,14 +337,14 @@ int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
 
 static u8 ide_read_device(ide_drive_t *drive)
 {
-       ide_task_t task;
+       struct ide_cmd cmd;
 
-       memset(&task, 0, sizeof(task));
-       task.tf_flags = IDE_TFLAG_IN_DEVICE;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf_flags = IDE_TFLAG_IN_DEVICE;
 
-       drive->hwif->tp_ops->tf_read(drive, &task);
+       drive->hwif->tp_ops->tf_read(drive, &cmd);
 
-       return task.tf.device;
+       return cmd.tf.device;
 }
 
 /**
index 417cde56eafd9766815a067a12480743cb28ea1e..10a88bf3eefa8cfc3bd25dce6ea0f334150af764 100644 (file)
@@ -194,20 +194,20 @@ ide_devset_get(xfer_rate, current_speed);
 
 static int set_xfer_rate (ide_drive_t *drive, int arg)
 {
-       ide_task_t task;
+       struct ide_cmd cmd;
        int err;
 
        if (arg < XFER_PIO_0 || arg > XFER_UDMA_6)
                return -EINVAL;
 
-       memset(&task, 0, sizeof(task));
-       task.tf.command = ATA_CMD_SET_FEATURES;
-       task.tf.feature = SETFEATURES_XFER;
-       task.tf.nsect   = (u8)arg;
-       task.tf_flags = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT |
-                       IDE_TFLAG_IN_NSECT;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf.command = ATA_CMD_SET_FEATURES;
+       cmd.tf.feature = SETFEATURES_XFER;
+       cmd.tf.nsect   = (u8)arg;
+       cmd.tf_flags   = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT |
+                        IDE_TFLAG_IN_NSECT;
 
-       err = ide_no_data_taskfile(drive, &task);
+       err = ide_no_data_taskfile(drive, &cmd);
 
        if (!err) {
                ide_set_xfer_rate(drive, (u8) arg);
index 925fb92418932b6cb8f8ab12ee6282ae50cf3a2f..2b85c137764a37e80395ee74f526d20017a3e1c0 100644 (file)
@@ -39,33 +39,34 @@ void ide_tf_dump(const char *s, struct ide_taskfile *tf)
 
 int taskfile_lib_get_identify (ide_drive_t *drive, u8 *buf)
 {
-       ide_task_t args;
+       struct ide_cmd cmd;
 
-       memset(&args, 0, sizeof(ide_task_t));
-       args.tf.nsect = 0x01;
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.tf.nsect = 0x01;
        if (drive->media == ide_disk)
-               args.tf.command = ATA_CMD_ID_ATA;
+               cmd.tf.command = ATA_CMD_ID_ATA;
        else
-               args.tf.command = ATA_CMD_ID_ATAPI;
-       args.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-       args.data_phase = TASKFILE_IN;
-       return ide_raw_taskfile(drive, &args, buf, 1);
+               cmd.tf.command = ATA_CMD_ID_ATAPI;
+       cmd.tf_flags    = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+       cmd.data_phase  = TASKFILE_IN;
+
+       return ide_raw_taskfile(drive, &cmd, buf, 1);
 }
 
 static ide_startstop_t task_no_data_intr(ide_drive_t *);
 static ide_startstop_t pre_task_out_intr(ide_drive_t *, struct request *);
 static ide_startstop_t task_in_intr(ide_drive_t *);
 
-ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
+ide_startstop_t do_rw_taskfile(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
        ide_handler_t *handler = NULL;
        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
        const struct ide_dma_ops *dma_ops = hwif->dma_ops;
 
-       if (task->data_phase == TASKFILE_MULTI_IN ||
-           task->data_phase == TASKFILE_MULTI_OUT) {
+       if (cmd->data_phase == TASKFILE_MULTI_IN ||
+           cmd->data_phase == TASKFILE_MULTI_OUT) {
                if (!drive->mult_count) {
                        printk(KERN_ERR "%s: multimode not set!\n",
                                        drive->name);
@@ -73,24 +74,24 @@ ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
                }
        }
 
-       if (task->ftf_flags & IDE_FTFLAG_FLAGGED)
-               task->ftf_flags |= IDE_FTFLAG_SET_IN_FLAGS;
+       if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
+               cmd->ftf_flags |= IDE_FTFLAG_SET_IN_FLAGS;
 
-       memcpy(&hwif->task, task, sizeof(*task));
+       memcpy(&hwif->cmd, cmd, sizeof(*cmd));
 
-       if ((task->tf_flags & IDE_TFLAG_DMA_PIO_FALLBACK) == 0) {
+       if ((cmd->tf_flags & IDE_TFLAG_DMA_PIO_FALLBACK) == 0) {
                ide_tf_dump(drive->name, tf);
                tp_ops->set_irq(hwif, 1);
                SELECT_MASK(drive, 0);
-               tp_ops->tf_load(drive, task);
+               tp_ops->tf_load(drive, cmd);
        }
 
-       switch (task->data_phase) {
+       switch (cmd->data_phase) {
        case TASKFILE_MULTI_OUT:
        case TASKFILE_OUT:
                tp_ops->exec_command(hwif, tf->command);
                ndelay(400);    /* FIXME */
-               return pre_task_out_intr(drive, task->rq);
+               return pre_task_out_intr(drive, cmd->rq);
        case TASKFILE_MULTI_IN:
        case TASKFILE_IN:
                handler = task_in_intr;
@@ -119,9 +120,9 @@ EXPORT_SYMBOL_GPL(do_rw_taskfile);
 static ide_startstop_t task_no_data_intr(ide_drive_t *drive)
 {
        ide_hwif_t *hwif = drive->hwif;
-       ide_task_t *task = &hwif->task;
-       struct ide_taskfile *tf = &task->tf;
-       int custom = (task->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) ? 1 : 0;
+       struct ide_cmd *cmd = &hwif->cmd;
+       struct ide_taskfile *tf = &cmd->tf;
+       int custom = (cmd->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) ? 1 : 0;
        int retries = (custom && tf->command == ATA_CMD_INIT_DEV_PARAMS) ? 5 : 1;
        u8 stat;
 
@@ -151,7 +152,7 @@ static ide_startstop_t task_no_data_intr(ide_drive_t *drive)
        }
 
        if (custom && tf->command == ATA_CMD_IDLEIMMEDIATE) {
-               hwif->tp_ops->tf_read(drive, task);
+               hwif->tp_ops->tf_read(drive, cmd);
                if (tf->lbal != 0xc4) {
                        printk(KERN_ERR "%s: head unload failed!\n",
                               drive->name);
@@ -169,7 +170,7 @@ static ide_startstop_t task_no_data_intr(ide_drive_t *drive)
                        ide_complete_pm_rq(drive, rq);
                else {
                        if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
-                               ide_complete_task(drive, task, stat, err);
+                               ide_complete_cmd(drive, cmd, stat, err);
                        ide_complete_rq(drive, err);
                }
        }
@@ -266,18 +267,18 @@ static void ide_pio_multi(ide_drive_t *drive, struct request *rq,
 static void ide_pio_datablock(ide_drive_t *drive, struct request *rq,
                                     unsigned int write)
 {
-       ide_task_t *task = &drive->hwif->task;
+       struct ide_cmd *cmd = &drive->hwif->cmd;
        u8 saved_io_32bit = drive->io_32bit;
 
        if (blk_fs_request(rq))
                rq->errors = 0;
 
-       if (task->tf_flags & IDE_TFLAG_IO_16BIT)
+       if (cmd->tf_flags & IDE_TFLAG_IO_16BIT)
                drive->io_32bit = 0;
 
        touch_softlockup_watchdog();
 
-       switch (task->data_phase) {
+       switch (cmd->data_phase) {
        case TASKFILE_MULTI_IN:
        case TASKFILE_MULTI_OUT:
                ide_pio_multi(drive, rq, write);
@@ -295,10 +296,10 @@ static ide_startstop_t task_error(ide_drive_t *drive, struct request *rq,
 {
        if (blk_fs_request(rq)) {
                ide_hwif_t *hwif = drive->hwif;
-               ide_task_t *task = &hwif->task;
+               struct ide_cmd *cmd = &hwif->cmd;
                int sectors = hwif->nsect - hwif->nleft;
 
-               switch (task->data_phase) {
+               switch (cmd->data_phase) {
                case TASKFILE_IN:
                        if (hwif->nleft)
                                break;
@@ -325,11 +326,11 @@ static ide_startstop_t task_error(ide_drive_t *drive, struct request *rq,
 void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat)
 {
        if (blk_fs_request(rq) == 0) {
-               ide_task_t *task = rq->special;
+               struct ide_cmd *cmd = rq->special;
                u8 err = ide_read_error(drive);
 
-               if (task)
-                       ide_complete_task(drive, task, stat, err);
+               if (cmd)
+                       ide_complete_cmd(drive, cmd, stat, err);
                ide_complete_rq(drive, err);
                return;
        }
@@ -420,14 +421,14 @@ static ide_startstop_t task_out_intr (ide_drive_t *drive)
 
 static ide_startstop_t pre_task_out_intr(ide_drive_t *drive, struct request *rq)
 {
-       ide_task_t *task = &drive->hwif->task;
+       struct ide_cmd *cmd = &drive->hwif->cmd;
        ide_startstop_t startstop;
 
        if (ide_wait_stat(&startstop, drive, ATA_DRQ,
                          drive->bad_wstat, WAIT_DRQ)) {
                printk(KERN_ERR "%s: no DRQ after issuing %sWRITE%s\n",
                        drive->name,
-                       task->data_phase == TASKFILE_MULTI_OUT ? "MULT" : "",
+                       cmd->data_phase == TASKFILE_MULTI_OUT ? "MULT" : "",
                        (drive->dev_flags & IDE_DFLAG_LBA48) ? "_EXT" : "");
                return startstop;
        }
@@ -441,7 +442,8 @@ static ide_startstop_t pre_task_out_intr(ide_drive_t *drive, struct request *rq)
        return ide_started;
 }
 
-int ide_raw_taskfile(ide_drive_t *drive, ide_task_t *task, u8 *buf, u16 nsect)
+int ide_raw_taskfile(ide_drive_t *drive, struct ide_cmd *cmd, u8 *buf,
+                    u16 nsect)
 {
        struct request *rq;
        int error;
@@ -459,11 +461,11 @@ int ide_raw_taskfile(ide_drive_t *drive, ide_task_t *task, u8 *buf, u16 nsect)
        rq->hard_nr_sectors = rq->nr_sectors = nsect;
        rq->hard_cur_sectors = rq->current_nr_sectors = nsect;
 
-       if (task->tf_flags & IDE_TFLAG_WRITE)
+       if (cmd->tf_flags & IDE_TFLAG_WRITE)
                rq->cmd_flags |= REQ_RW;
 
-       rq->special = task;
-       task->rq = rq;
+       rq->special = cmd;
+       cmd->rq = rq;
 
        error = blk_execute_rq(drive->queue, NULL, rq, 0);
        blk_put_request(rq);
@@ -473,19 +475,19 @@ int ide_raw_taskfile(ide_drive_t *drive, ide_task_t *task, u8 *buf, u16 nsect)
 
 EXPORT_SYMBOL(ide_raw_taskfile);
 
-int ide_no_data_taskfile(ide_drive_t *drive, ide_task_t *task)
+int ide_no_data_taskfile(ide_drive_t *drive, struct ide_cmd *cmd)
 {
-       task->data_phase = TASKFILE_NO_DATA;
+       cmd->data_phase = TASKFILE_NO_DATA;
 
-       return ide_raw_taskfile(drive, task, NULL, 0);
+       return ide_raw_taskfile(drive, cmd, NULL, 0);
 }
 EXPORT_SYMBOL_GPL(ide_no_data_taskfile);
 
 #ifdef CONFIG_IDE_TASK_IOCTL
-int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg)
+int ide_taskfile_ioctl(ide_drive_t *drive, unsigned long arg)
 {
        ide_task_request_t      *req_task;
-       ide_task_t              args;
+       struct ide_cmd          cmd;
        u8 *outbuf              = NULL;
        u8 *inbuf               = NULL;
        u8 *data_buf            = NULL;
@@ -539,51 +541,53 @@ int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg)
                }
        }
 
-       memset(&args, 0, sizeof(ide_task_t));
+       memset(&cmd, 0, sizeof(cmd));
 
-       memcpy(&args.tf_array[0], req_task->hob_ports, HDIO_DRIVE_HOB_HDR_SIZE - 2);
-       memcpy(&args.tf_array[6], req_task->io_ports, HDIO_DRIVE_TASK_HDR_SIZE);
+       memcpy(&cmd.tf_array[0], req_task->hob_ports,
+              HDIO_DRIVE_HOB_HDR_SIZE - 2);
+       memcpy(&cmd.tf_array[6], req_task->io_ports,
+              HDIO_DRIVE_TASK_HDR_SIZE);
 
-       args.data_phase = req_task->data_phase;
+       cmd.data_phase = req_task->data_phase;
+       cmd.tf_flags   = IDE_TFLAG_IO_16BIT | IDE_TFLAG_DEVICE |
+                        IDE_TFLAG_IN_TF;
 
-       args.tf_flags = IDE_TFLAG_IO_16BIT | IDE_TFLAG_DEVICE |
-                       IDE_TFLAG_IN_TF;
        if (drive->dev_flags & IDE_DFLAG_LBA48)
-               args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_IN_HOB);
+               cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_IN_HOB);
 
        if (req_task->out_flags.all) {
-               args.ftf_flags |= IDE_FTFLAG_FLAGGED;
+               cmd.ftf_flags |= IDE_FTFLAG_FLAGGED;
 
                if (req_task->out_flags.b.data)
-                       args.ftf_flags |= IDE_FTFLAG_OUT_DATA;
+                       cmd.ftf_flags |= IDE_FTFLAG_OUT_DATA;
 
                if (req_task->out_flags.b.nsector_hob)
-                       args.tf_flags |= IDE_TFLAG_OUT_HOB_NSECT;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_HOB_NSECT;
                if (req_task->out_flags.b.sector_hob)
-                       args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAL;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_HOB_LBAL;
                if (req_task->out_flags.b.lcyl_hob)
-                       args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAM;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_HOB_LBAM;
                if (req_task->out_flags.b.hcyl_hob)
-                       args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAH;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_HOB_LBAH;
 
                if (req_task->out_flags.b.error_feature)
-                       args.tf_flags |= IDE_TFLAG_OUT_FEATURE;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_FEATURE;
                if (req_task->out_flags.b.nsector)
-                       args.tf_flags |= IDE_TFLAG_OUT_NSECT;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_NSECT;
                if (req_task->out_flags.b.sector)
-                       args.tf_flags |= IDE_TFLAG_OUT_LBAL;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_LBAL;
                if (req_task->out_flags.b.lcyl)
-                       args.tf_flags |= IDE_TFLAG_OUT_LBAM;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_LBAM;
                if (req_task->out_flags.b.hcyl)
-                       args.tf_flags |= IDE_TFLAG_OUT_LBAH;
+                       cmd.tf_flags |= IDE_TFLAG_OUT_LBAH;
        } else {
-               args.tf_flags |= IDE_TFLAG_OUT_TF;
-               if (args.tf_flags & IDE_TFLAG_LBA48)
-                       args.tf_flags |= IDE_TFLAG_OUT_HOB;
+               cmd.tf_flags |= IDE_TFLAG_OUT_TF;
+               if (cmd.tf_flags & IDE_TFLAG_LBA48)
+                       cmd.tf_flags |= IDE_TFLAG_OUT_HOB;
        }
 
        if (req_task->in_flags.b.data)
-               args.ftf_flags |= IDE_FTFLAG_IN_DATA;
+               cmd.ftf_flags |= IDE_FTFLAG_IN_DATA;
 
        switch(req_task->data_phase) {
                case TASKFILE_MULTI_OUT:
@@ -630,7 +634,7 @@ int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg)
        if (req_task->req_cmd == IDE_DRIVE_TASK_NO_DATA)
                nsect = 0;
        else if (!nsect) {
-               nsect = (args.tf.hob_nsect << 8) | args.tf.nsect;
+               nsect = (cmd.tf.hob_nsect << 8) | cmd.tf.nsect;
 
                if (!nsect) {
                        printk(KERN_ERR "%s: in/out command without data\n",
@@ -641,14 +645,16 @@ int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg)
        }
 
        if (req_task->req_cmd == IDE_DRIVE_TASK_RAW_WRITE)
-               args.tf_flags |= IDE_TFLAG_WRITE;
+               cmd.tf_flags |= IDE_TFLAG_WRITE;
 
-       err = ide_raw_taskfile(drive, &args, data_buf, nsect);
+       err = ide_raw_taskfile(drive, &cmd, data_buf, nsect);
 
-       memcpy(req_task->hob_ports, &args.tf_array[0], HDIO_DRIVE_HOB_HDR_SIZE - 2);
-       memcpy(req_task->io_ports, &args.tf_array[6], HDIO_DRIVE_TASK_HDR_SIZE);
+       memcpy(req_task->hob_ports, &cmd.tf_array[0],
+              HDIO_DRIVE_HOB_HDR_SIZE - 2);
+       memcpy(req_task->io_ports, &cmd.tf_array[6],
+              HDIO_DRIVE_TASK_HDR_SIZE);
 
-       if ((args.ftf_flags & IDE_FTFLAG_SET_IN_FLAGS) &&
+       if ((cmd.ftf_flags & IDE_FTFLAG_SET_IN_FLAGS) &&
            req_task->in_flags.all == 0) {
                req_task->in_flags.all = IDE_TASKFILE_STD_IN_FLAGS;
                if (drive->dev_flags & IDE_DFLAG_LBA48)
index 159eb39c7932733db57e01b5a01a06bf5c8b3387..d93c8001632667b0770d8fd3ade80dcc6cdc6c91 100644 (file)
@@ -61,12 +61,12 @@ static u8 superio_dma_sff_read_status(ide_hwif_t *hwif)
        return superio_ide_inb(hwif->dma_base + ATA_DMA_STATUS);
 }
 
-static void superio_tf_read(ide_drive_t *drive, ide_task_t *task)
+static void superio_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        struct ide_io_ports *io_ports = &drive->hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
 
-       if (task->ftf_flags & IDE_FTFLAG_IN_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) {
                u16 data = inw(io_ports->data_addr);
 
                tf->data = data & 0xff;
@@ -76,31 +76,31 @@ static void superio_tf_read(ide_drive_t *drive, ide_task_t *task)
        /* be sure we're looking at the low order bits */
        outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
 
-       if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_FEATURE)
                tf->feature = inb(io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
                tf->nsect  = inb(io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
                tf->lbal   = inb(io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
                tf->lbam   = inb(io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
                tf->lbah   = inb(io_ports->lbah_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
                tf->device = superio_ide_inb(io_ports->device_addr);
 
-       if (task->tf_flags & IDE_TFLAG_LBA48) {
+       if (cmd->tf_flags & IDE_TFLAG_LBA48) {
                outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
 
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
                        tf->hob_feature = inb(io_ports->feature_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
                        tf->hob_nsect   = inb(io_ports->nsect_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
                        tf->hob_lbal    = inb(io_ports->lbal_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
                        tf->hob_lbam    = inb(io_ports->lbam_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
                        tf->hob_lbah    = inb(io_ports->lbah_addr);
        }
 }
index 82929c725d82899d01cb11d52b72aad78d0e6435..d6336753bd2cc4dbf4f14ebdc9e43c18a8db5719 100644 (file)
@@ -666,52 +666,52 @@ static int __devinit init_setup_scc(struct pci_dev *dev,
        return rc;
 }
 
-static void scc_tf_load(ide_drive_t *drive, ide_task_t *task)
+static void scc_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        struct ide_io_ports *io_ports = &drive->hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
-       u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
+       struct ide_taskfile *tf = &cmd->tf;
+       u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
 
-       if (task->ftf_flags & IDE_FTFLAG_FLAGGED)
+       if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
                HIHI = 0xFF;
 
-       if (task->ftf_flags & IDE_FTFLAG_OUT_DATA)
+       if (cmd->ftf_flags & IDE_FTFLAG_OUT_DATA)
                out_be32((void *)io_ports->data_addr,
                         (tf->hob_data << 8) | tf->data);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
                scc_ide_outb(tf->hob_feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
                scc_ide_outb(tf->hob_nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
                scc_ide_outb(tf->hob_lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
                scc_ide_outb(tf->hob_lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
                scc_ide_outb(tf->hob_lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
                scc_ide_outb(tf->feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
                scc_ide_outb(tf->nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
                scc_ide_outb(tf->lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
                scc_ide_outb(tf->lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
                scc_ide_outb(tf->lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
                scc_ide_outb((tf->device & HIHI) | drive->select,
                             io_ports->device_addr);
 }
 
-static void scc_tf_read(ide_drive_t *drive, ide_task_t *task)
+static void scc_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        struct ide_io_ports *io_ports = &drive->hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
 
-       if (task->ftf_flags & IDE_FTFLAG_IN_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) {
                u16 data = (u16)in_be32((void *)io_ports->data_addr);
 
                tf->data = data & 0xff;
@@ -721,31 +721,31 @@ static void scc_tf_read(ide_drive_t *drive, ide_task_t *task)
        /* be sure we're looking at the low order bits */
        scc_ide_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
 
-       if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_FEATURE)
                tf->feature = scc_ide_inb(io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
                tf->nsect  = scc_ide_inb(io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
                tf->lbal   = scc_ide_inb(io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
                tf->lbam   = scc_ide_inb(io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
                tf->lbah   = scc_ide_inb(io_ports->lbah_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
                tf->device = scc_ide_inb(io_ports->device_addr);
 
-       if (task->tf_flags & IDE_TFLAG_LBA48) {
+       if (cmd->tf_flags & IDE_TFLAG_LBA48) {
                scc_ide_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
 
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
                        tf->hob_feature = scc_ide_inb(io_ports->feature_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
                        tf->hob_nsect   = scc_ide_inb(io_ports->nsect_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
                        tf->hob_lbal    = scc_ide_inb(io_ports->lbal_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
                        tf->hob_lbam    = scc_ide_inb(io_ports->lbam_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
                        tf->hob_lbah    = scc_ide_inb(io_ports->lbah_addr);
        }
 }
index 6b51e0c58af79c315aa527b2f9f27bcf949e2f0d..947596d3620ca58fb8823781cd5db18b9b74f51f 100644 (file)
@@ -82,57 +82,57 @@ static void tx4938ide_outb(u8 value, unsigned long port)
        __raw_writeb(value, (void __iomem *)port);
 }
 
-static void tx4938ide_tf_load(ide_drive_t *drive, ide_task_t *task)
+static void tx4938ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
-       u8 HIHI = task->tf_flags & IDE_TFLAG_LBA48 ? 0xE0 : 0xEF;
+       struct ide_taskfile *tf = &cmd->tf;
+       u8 HIHI = cmd->tf_flags & IDE_TFLAG_LBA48 ? 0xE0 : 0xEF;
 
-       if (task->ftf_flags & IDE_FTFLAG_FLAGGED)
+       if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
                HIHI = 0xFF;
 
-       if (task->ftf_flags & IDE_FTFLAG_OUT_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_OUT_DATA) {
                u16 data = (tf->hob_data << 8) | tf->data;
 
                /* no endian swap */
                __raw_writew(data, (void __iomem *)io_ports->data_addr);
        }
 
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
                tx4938ide_outb(tf->hob_feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
                tx4938ide_outb(tf->hob_nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
                tx4938ide_outb(tf->hob_lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
                tx4938ide_outb(tf->hob_lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
                tx4938ide_outb(tf->hob_lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
                tx4938ide_outb(tf->feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
                tx4938ide_outb(tf->nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
                tx4938ide_outb(tf->lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
                tx4938ide_outb(tf->lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
                tx4938ide_outb(tf->lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
                tx4938ide_outb((tf->device & HIHI) | drive->select,
                               io_ports->device_addr);
 }
 
-static void tx4938ide_tf_read(ide_drive_t *drive, ide_task_t *task)
+static void tx4938ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
 
-       if (task->ftf_flags & IDE_FTFLAG_IN_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) {
                u16 data;
 
                /* no endian swap */
@@ -144,32 +144,32 @@ static void tx4938ide_tf_read(ide_drive_t *drive, ide_task_t *task)
        /* be sure we're looking at the low order bits */
        tx4938ide_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
 
-       if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_FEATURE)
                tf->feature = tx4938ide_inb(io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
                tf->nsect  = tx4938ide_inb(io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
                tf->lbal   = tx4938ide_inb(io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
                tf->lbam   = tx4938ide_inb(io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
                tf->lbah   = tx4938ide_inb(io_ports->lbah_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
                tf->device = tx4938ide_inb(io_ports->device_addr);
 
-       if (task->tf_flags & IDE_TFLAG_LBA48) {
+       if (cmd->tf_flags & IDE_TFLAG_LBA48) {
                tx4938ide_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
 
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
                        tf->hob_feature =
                                tx4938ide_inb(io_ports->feature_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
                        tf->hob_nsect   = tx4938ide_inb(io_ports->nsect_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
                        tf->hob_lbal    = tx4938ide_inb(io_ports->lbal_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
                        tf->hob_lbam    = tx4938ide_inb(io_ports->lbam_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
                        tf->hob_lbah    = tx4938ide_inb(io_ports->lbah_addr);
        }
 }
index ee86688d8461d7fe51a7fbc8952dd7610208c068..bf11791476f0a257538e5d4f5c371f446403cab3 100644 (file)
@@ -435,7 +435,7 @@ static int tx4939ide_init_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
        return ide_allocate_dma_engine(hwif);
 }
 
-static void tx4939ide_tf_load_fixup(ide_drive_t *drive, ide_task_t *task)
+static void tx4939ide_tf_load_fixup(ide_drive_t *drive)
 {
        ide_hwif_t *hwif = drive->hwif;
        void __iomem *base = TX4939IDE_BASE(hwif);
@@ -463,59 +463,59 @@ static void tx4939ide_outb(u8 value, unsigned long port)
        __raw_writeb(value, (void __iomem *)port);
 }
 
-static void tx4939ide_tf_load(ide_drive_t *drive, ide_task_t *task)
+static void tx4939ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
-       u8 HIHI = task->tf_flags & IDE_TFLAG_LBA48 ? 0xE0 : 0xEF;
+       struct ide_taskfile *tf = &cmd->tf;
+       u8 HIHI = cmd->tf_flags & IDE_TFLAG_LBA48 ? 0xE0 : 0xEF;
 
-       if (task->ftf_flags & IDE_FTFLAG_FLAGGED)
+       if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
                HIHI = 0xFF;
 
-       if (task->ftf_flags & IDE_FTFLAG_OUT_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_OUT_DATA) {
                u16 data = (tf->hob_data << 8) | tf->data;
 
                /* no endian swap */
                __raw_writew(data, (void __iomem *)io_ports->data_addr);
        }
 
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
                tx4939ide_outb(tf->hob_feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
                tx4939ide_outb(tf->hob_nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
                tx4939ide_outb(tf->hob_lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
                tx4939ide_outb(tf->hob_lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
                tx4939ide_outb(tf->hob_lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
                tx4939ide_outb(tf->feature, io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
                tx4939ide_outb(tf->nsect, io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
                tx4939ide_outb(tf->lbal, io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
                tx4939ide_outb(tf->lbam, io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
                tx4939ide_outb(tf->lbah, io_ports->lbah_addr);
 
-       if (task->tf_flags & IDE_TFLAG_OUT_DEVICE) {
+       if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE) {
                tx4939ide_outb((tf->device & HIHI) | drive->select,
                               io_ports->device_addr);
-               tx4939ide_tf_load_fixup(drive, task);
+               tx4939ide_tf_load_fixup(drive);
        }
 }
 
-static void tx4939ide_tf_read(ide_drive_t *drive, ide_task_t *task)
+static void tx4939ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-       struct ide_taskfile *tf = &task->tf;
+       struct ide_taskfile *tf = &cmd->tf;
 
-       if (task->ftf_flags & IDE_FTFLAG_IN_DATA) {
+       if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) {
                u16 data;
 
                /* no endian swap */
@@ -527,32 +527,32 @@ static void tx4939ide_tf_read(ide_drive_t *drive, ide_task_t *task)
        /* be sure we're looking at the low order bits */
        tx4939ide_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
 
-       if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_FEATURE)
                tf->feature = tx4939ide_inb(io_ports->feature_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_NSECT)
+       if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
                tf->nsect  = tx4939ide_inb(io_ports->nsect_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAL)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
                tf->lbal   = tx4939ide_inb(io_ports->lbal_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAM)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
                tf->lbam   = tx4939ide_inb(io_ports->lbam_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_LBAH)
+       if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
                tf->lbah   = tx4939ide_inb(io_ports->lbah_addr);
-       if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
+       if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
                tf->device = tx4939ide_inb(io_ports->device_addr);
 
-       if (task->tf_flags & IDE_TFLAG_LBA48) {
+       if (cmd->tf_flags & IDE_TFLAG_LBA48) {
                tx4939ide_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
 
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
                        tf->hob_feature =
                                tx4939ide_inb(io_ports->feature_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
                        tf->hob_nsect   = tx4939ide_inb(io_ports->nsect_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
                        tf->hob_lbal    = tx4939ide_inb(io_ports->lbal_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
                        tf->hob_lbam    = tx4939ide_inb(io_ports->lbam_addr);
-               if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
+               if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
                        tf->hob_lbah    = tx4939ide_inb(io_ports->lbah_addr);
        }
 }
@@ -599,11 +599,12 @@ static const struct ide_tp_ops tx4939ide_tp_ops = {
 
 #else  /* __LITTLE_ENDIAN */
 
-static void tx4939ide_tf_load(ide_drive_t *drive, ide_task_t *task)
+static void tx4939ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
 {
-       ide_tf_load(drive, task);
-       if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
-               tx4939ide_tf_load_fixup(drive, task);
+       ide_tf_load(drive, cmd);
+
+       if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
+               tx4939ide_tf_load_fixup(drive);
 }
 
 static const struct ide_tp_ops tx4939ide_tp_ops = {
index 2ee236d1f3ac06f7ad65b6df5a874eaff2dc0b73..f0e3618c725774a391f308c939712c8d0c096c7a 100644 (file)
@@ -295,7 +295,7 @@ enum {
                                          IDE_TFLAG_IN_DEVICE,
        /* force 16-bit I/O operations */
        IDE_TFLAG_IO_16BIT              = (1 << 26),
-       /* ide_task_t was allocated using kmalloc() */
+       /* struct ide_cmd was allocated using kmalloc() */
        IDE_TFLAG_DYN                   = (1 << 27),
 };
 
@@ -335,7 +335,7 @@ struct ide_taskfile {
        };
 };
 
-typedef struct ide_task_s {
+struct ide_cmd {
        union {
                struct ide_taskfile     tf;
                u8                      tf_array[14];
@@ -345,7 +345,7 @@ typedef struct ide_task_s {
        int                     data_phase;
        struct request          *rq;            /* copy of request */
        void                    *special;       /* valid_t generally */
-} ide_task_t;
+};
 
 /* ATAPI packet command flags */
 enum {
@@ -652,8 +652,8 @@ struct ide_tp_ops {
 
        void    (*set_irq)(struct hwif_s *, int);
 
-       void    (*tf_load)(ide_drive_t *, struct ide_task_s *);
-       void    (*tf_read)(ide_drive_t *, struct ide_task_s *);
+       void    (*tf_load)(ide_drive_t *, struct ide_cmd *);
+       void    (*tf_read)(ide_drive_t *, struct ide_cmd *);
 
        void    (*input_data)(ide_drive_t *, struct request *, void *,
                              unsigned int);
@@ -775,7 +775,7 @@ typedef struct hwif_s {
        int orig_sg_nents;
        int sg_dma_direction;           /* dma transfer direction */
 
-       struct ide_task_s task;         /* current command */
+       struct ide_cmd cmd;             /* current command */
 
        unsigned int nsect;
        unsigned int nleft;
@@ -1161,7 +1161,7 @@ extern ide_startstop_t ide_do_reset (ide_drive_t *);
 extern int ide_devset_execute(ide_drive_t *drive,
                              const struct ide_devset *setting, int arg);
 
-void ide_complete_task(ide_drive_t *, ide_task_t *, u8, u8);
+void ide_complete_cmd(ide_drive_t *, struct ide_cmd *, u8, u8);
 void ide_complete_rq(ide_drive_t *, u8);
 
 void ide_tf_dump(const char *, struct ide_taskfile *);
@@ -1172,8 +1172,8 @@ u8 ide_read_altstatus(ide_hwif_t *);
 
 void ide_set_irq(ide_hwif_t *, int);
 
-void ide_tf_load(ide_drive_t *, ide_task_t *);
-void ide_tf_read(ide_drive_t *, ide_task_t *);
+void ide_tf_load(ide_drive_t *, struct ide_cmd *);
+void ide_tf_read(ide_drive_t *, struct ide_cmd *);
 
 void ide_input_data(ide_drive_t *, struct request *, void *, unsigned int);
 void ide_output_data(ide_drive_t *, struct request *, void *, unsigned int);
@@ -1224,14 +1224,14 @@ int ide_cd_get_xferlen(struct request *);
 
 ide_startstop_t ide_issue_pc(ide_drive_t *);
 
-ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
+ide_startstop_t do_rw_taskfile(ide_drive_t *, struct ide_cmd *);
 
 void task_end_request(ide_drive_t *, struct request *, u8);
 
-int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *, u16);
-int ide_no_data_taskfile(ide_drive_t *, ide_task_t *);
+int ide_raw_taskfile(ide_drive_t *, struct ide_cmd *, u8 *, u16);
+int ide_no_data_taskfile(ide_drive_t *, struct ide_cmd *);
 
-int ide_taskfile_ioctl(ide_drive_t *, unsigned int, unsigned long);
+int ide_taskfile_ioctl(ide_drive_t *, unsigned long);
 
 int ide_dev_read_id(ide_drive_t *, u8, u16 *);