ide: merge ->atapi_*put_bytes and ->ata_*put_data methods

* Merge ->atapi_{in,out}put_bytes and ->ata_{in,out}put_data methods
  into new ->{in,out}put_data methods which take number of bytes to
  transfer as an argument and always do padding.

While at it:

* Use 'hwif' or 'drive->hwif' instead of 'HWIF(drive)'.

There should be no functional changes caused by this patch (all users
of ->ata_{in,out}put_data methods were using multiply-of-4 word counts).

Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>

diff --git a/drivers/ide/cris/ide-cris.c b/drivers/ide/cris/ide-cris.c
index aa263df76569667c65f870baeeb8660c7f5afaef..72ff63ed5f2b758c33b57ba259c6b48563934aa3 100644 (file)
--- a/drivers/ide/cris/ide-cris.c
+++ b/drivers/ide/cris/ide-cris.c
@@ -673,12 +673,8 @@ cris_ide_inb(unsigned long reg)
        return (unsigned char)cris_ide_inw(reg);
 }
 
-static void cris_ide_input_data(ide_drive_t *, struct request *,
-                               void *, unsigned int);
-static void cris_ide_output_data(ide_drive_t *, struct request *,
-                                void *, unsigned int);
-static void cris_atapi_input_bytes(ide_drive_t *drive, void *, unsigned int);
-static void cris_atapi_output_bytes(ide_drive_t *drive, void *, unsigned int);
+static void cris_input_data(ide_drive_t *, struct request *, void *, unsigned);
+static void cris_output_data(ide_drive_t *, struct request *, void *, unsigned);
 
 static void cris_dma_host_set(ide_drive_t *drive, int on)
 {
@@ -816,10 +812,9 @@ static int __init init_e100_ide(void)
                ide_init_port_data(hwif, hwif->index);
                ide_init_port_hw(hwif, &hw);
 
-               hwif->ata_input_data = &cris_ide_input_data;
-               hwif->ata_output_data = &cris_ide_output_data;
-               hwif->atapi_input_bytes = &cris_atapi_input_bytes;
-               hwif->atapi_output_bytes = &cris_atapi_output_bytes;
+               hwif->input_data  = cris_input_data;
+               hwif->output_data = cris_output_data;
+
                hwif->OUTB = &cris_ide_outb;
                hwif->OUTW = &cris_ide_outw;
                hwif->OUTBSYNC = &cris_ide_outbsync;
@@ -849,17 +844,16 @@ static int __init init_e100_ide(void)
 static cris_dma_descr_type mydescr __attribute__ ((__aligned__(16)));
 
 /*
- * The following routines are mainly used by the ATAPI drivers.
+ * This is used for most PIO data transfers *from* the IDE interface
  *
  * These routines will round up any request for an odd number of bytes,
  * so if an odd bytecount is specified, be sure that there's at least one
  * extra byte allocated for the buffer.
  */
-static void
-cris_atapi_input_bytes (ide_drive_t *drive, void *buffer, unsigned int bytecount)
+static void cris_input_data(ide_drive_t *drive, struct request *rq,
+                           void *buffer, unsigned int bytecount)
 {
-       D(printk("atapi_input_bytes, buffer 0x%x, count %d\n",
-                buffer, bytecount));
+       D(printk("input_data, buffer 0x%x, count %d\n", buffer, bytecount));
 
        if(bytecount & 1) {
                printk("warning, odd bytecount in cdrom_in_bytes = %d.\n", bytecount);
@@ -877,11 +871,13 @@ cris_atapi_input_bytes (ide_drive_t *drive, void *buffer, unsigned int bytecount
        LED_DISK_READ(0);
 }
 
-static void
-cris_atapi_output_bytes (ide_drive_t *drive, void *buffer, unsigned int bytecount)
+/*
+ * This is used for most PIO data transfers *to* the IDE interface
+ */
+static void cris_output_data(ide_drive_t *drive,  struct request *rq,
+                            void *buffer, unsigned int bytecount)
 {
-       D(printk("atapi_output_bytes, buffer 0x%x, count %d\n",
-                buffer, bytecount));
+       D(printk("output_data, buffer 0x%x, count %d\n", buffer, bytecount));
 
        if(bytecount & 1) {
                printk("odd bytecount %d in atapi_out_bytes!\n", bytecount);
@@ -899,24 +895,6 @@ cris_atapi_output_bytes (ide_drive_t *drive, void *buffer, unsigned int bytecoun
        LED_DISK_WRITE(0);
 }
 
-/*
- * This is used for most PIO data transfers *from* the IDE interface
- */
-static void cris_ide_input_data(ide_drive_t *drive, struct request *rq,
-                               void *buffer, unsigned int wcount)
-{
-       cris_atapi_input_bytes(drive, buffer, wcount << 2);
-}
-
-/*
- * This is used for most PIO data transfers *to* the IDE interface
- */
-static void cris_ide_output_data(ide_drive_t *drive, struct request *,
-                                void *buffer, unsigned int wcount)
-{
-       cris_atapi_output_bytes(drive, buffer, wcount << 2);
-}
-
 /* we only have one DMA channel on the chip for ATA, so we can keep these statically */
 static cris_dma_descr_type ata_descrs[MAX_DMA_DESCRS] __attribute__ ((__aligned__(16)));
 static unsigned int ata_tot_size;

diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index b34fd2bde96ffe8e743caf2fad30de0ee1fa03fc..095e50a93869170efce20a3caf305b7ab57f1d43 100644 (file)
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -613,7 +613,7 @@ static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive,
                cmd_len = ATAPI_MIN_CDB_BYTES;
 
        /* send the command to the device */
-       HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
+       hwif->output_data(drive, NULL, rq->cmd, cmd_len);
 
        /* start the DMA if need be */
        if (info->dma)
@@ -629,7 +629,7 @@ static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
 {
        while (len > 0) {
                int dum = 0;
-               xf(drive, &dum, sizeof(dum));
+               xf(drive, NULL, &dum, sizeof(dum));
                len -= sizeof(dum);
        }
 }
@@ -639,7 +639,7 @@ static void ide_cd_drain_data(ide_drive_t *drive, int nsects)
        while (nsects > 0) {
                static char dum[SECTOR_SIZE];
 
-               drive->hwif->atapi_input_bytes(drive, dum, sizeof(dum));
+               drive->hwif->input_data(drive, NULL, dum, sizeof(dum));
                nsects--;
        }
 }
@@ -666,7 +666,7 @@ static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq,
                printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
                                drive->name, __func__);
 
-               xf = rw ? hwif->atapi_output_bytes : hwif->atapi_input_bytes;
+               xf = rw ? hwif->output_data : hwif->input_data;
                ide_cd_pad_transfer(drive, xf, len);
        } else  if (rw == 0 && ireason == 1) {
                /*
@@ -1019,10 +1019,10 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
 
        if (ireason == 0) {
                write = 1;
-               xferfunc = HWIF(drive)->atapi_output_bytes;
+               xferfunc = hwif->output_data;
        } else {
                write = 0;
-               xferfunc = HWIF(drive)->atapi_input_bytes;
+               xferfunc = hwif->input_data;
        }
 
        /* transfer data */
@@ -1061,7 +1061,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                if (blen > thislen)
                        blen = thislen;
 
-               xferfunc(drive, ptr, blen);
+               xferfunc(drive, NULL, ptr, blen);
 
                thislen -= blen;
                len -= blen;

diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 489079b8ed03fdfce46615fd7f24b6d1ecfb07ae..e2bcd3af45db3ea6d9a4e6cd1834c17ca464407d 100644 (file)
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -231,6 +231,7 @@ static int idefloppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
 static void ide_floppy_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
                                  unsigned int bcount, int direction)
 {
+       ide_hwif_t *hwif = drive->hwif;
        struct request *rq = pc->rq;
        struct req_iterator iter;
        struct bio_vec *bvec;
@@ -246,9 +247,9 @@ static void ide_floppy_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
 
                data = bvec_kmap_irq(bvec, &flags);
                if (direction)
-                       drive->hwif->atapi_output_bytes(drive, data, count);
+                       hwif->output_data(drive, NULL, data, count);
                else
-                       drive->hwif->atapi_input_bytes(drive, data, count);
+                       hwif->input_data(drive, NULL, data, count);
                bvec_kunmap_irq(data, &flags);
 
                bcount -= count;
@@ -503,12 +504,12 @@ static ide_startstop_t idefloppy_pc_intr(ide_drive_t *drive)
                }
        }
        if (pc->flags & PC_FLAG_WRITING)
-               xferfunc = hwif->atapi_output_bytes;
+               xferfunc = hwif->output_data;
        else
-               xferfunc = hwif->atapi_input_bytes;
+               xferfunc = hwif->input_data;
 
        if (pc->buf)
-               xferfunc(drive, pc->cur_pos, bcount);
+               xferfunc(drive, NULL, pc->cur_pos, bcount);
        else
                ide_floppy_io_buffers(drive, pc, bcount,
                                      !!(pc->flags & PC_FLAG_WRITING));
@@ -548,8 +549,10 @@ static ide_startstop_t idefloppy_transfer_pc(ide_drive_t *drive)
 
        /* Set the interrupt routine */
        ide_set_handler(drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL);
+
        /* Send the actual packet */
-       HWIF(drive)->atapi_output_bytes(drive, floppy->pc->c, 12);
+       hwif->output_data(drive, NULL, floppy->pc->c, 12);
+
        return ide_started;
 }
 
@@ -569,7 +572,8 @@ static int idefloppy_transfer_pc2(ide_drive_t *drive)
        idefloppy_floppy_t *floppy = drive->driver_data;
 
        /* Send the actual packet */
-       HWIF(drive)->atapi_output_bytes(drive, floppy->pc->c, 12);
+       drive->hwif->output_data(drive, NULL, floppy->pc->c, 12);
+
        /* Timeout for the packet command */
        return IDEFLOPPY_WAIT_CMD;
 }

diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 60078cf307fbd574c41be2183b75ccbf26786cde..a17fc643000106d7470265d33ead3cc03846f49a 100644 (file)
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -422,7 +422,7 @@ static void try_to_flush_leftover_data (ide_drive_t *drive)
                u32 wcount = (i > 16) ? 16 : i;
 
                i -= wcount;
-               drive->hwif->ata_input_data(drive, NULL, buffer, wcount);
+               drive->hwif->input_data(drive, NULL, buffer, wcount * 4);
        }
 }
 

diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index 7ec7fa2aef96ca2866a69777efcf86092f59000e..fbbbb30ae96455cf74f5b1f264b2407b329517bb 100644 (file)
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -191,36 +191,47 @@ static void ata_vlb_sync(ide_drive_t *drive, unsigned long port)
 
 /*
  * This is used for most PIO data transfers *from* the IDE interface
+ *
+ * These routines will round up any request for an odd number of bytes,
+ * so if an odd len is specified, be sure that there's at least one
+ * extra byte allocated for the buffer.
  */
 static void ata_input_data(ide_drive_t *drive, struct request *rq,
-                          void *buffer, u32 wcount)
+                          void *buf, unsigned int len)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
+       unsigned long data_addr = io_ports->data_addr;
        u8 io_32bit = drive->io_32bit;
 
+       len++;
+
        if (io_32bit) {
                if (io_32bit & 2) {
                        unsigned long flags;
 
                        local_irq_save(flags);
                        ata_vlb_sync(drive, io_ports->nsect_addr);
-                       hwif->INSL(io_ports->data_addr, buffer, wcount);
+                       hwif->INSL(data_addr, buf, len / 4);
                        local_irq_restore(flags);
                } else
-                       hwif->INSL(io_ports->data_addr, buffer, wcount);
+                       hwif->INSL(data_addr, buf, len / 4);
+
+               if ((len & 3) >= 2)
+                       hwif->INSW(data_addr, (u8 *)buf + (len & ~3), 1);
        } else
-               hwif->INSW(io_ports->data_addr, buffer, wcount << 1);
+               hwif->INSW(data_addr, buf, len / 2);
 }
 
 /*
  * This is used for most PIO data transfers *to* the IDE interface
  */
 static void ata_output_data(ide_drive_t *drive, struct request *rq,
-                           void *buffer, u32 wcount)
+                           void *buf, unsigned int len)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
+       unsigned long data_addr = io_ports->data_addr;
        u8 io_32bit = drive->io_32bit;
 
        if (io_32bit) {
@@ -229,50 +240,21 @@ static void ata_output_data(ide_drive_t *drive, struct request *rq,
 
                        local_irq_save(flags);
                        ata_vlb_sync(drive, io_ports->nsect_addr);
-                       hwif->OUTSL(io_ports->data_addr, buffer, wcount);
+                       hwif->OUTSL(data_addr, buf, len / 4);
                        local_irq_restore(flags);
                } else
-                       hwif->OUTSL(io_ports->data_addr, buffer, wcount);
-       } else
-               hwif->OUTSW(io_ports->data_addr, buffer, wcount << 1);
-}
-
-/*
- * The following routines are mainly used by the ATAPI drivers.
- *
- * These routines will round up any request for an odd number of bytes,
- * so if an odd bytecount is specified, be sure that there's at least one
- * extra byte allocated for the buffer.
- */
-
-static void atapi_input_bytes(ide_drive_t *drive, void *buffer, u32 bytecount)
-{
-       ide_hwif_t *hwif = HWIF(drive);
+                       hwif->OUTSL(data_addr, buf, len / 4);
 
-       ++bytecount;
-       hwif->ata_input_data(drive, NULL, buffer, bytecount / 4);
-       if ((bytecount & 0x03) >= 2)
-               hwif->INSW(hwif->io_ports.data_addr,
-                          (u8 *)buffer + (bytecount & ~0x03), 1);
-}
-
-static void atapi_output_bytes(ide_drive_t *drive, void *buffer, u32 bytecount)
-{
-       ide_hwif_t *hwif = HWIF(drive);
-
-       ++bytecount;
-       hwif->ata_output_data(drive, NULL, buffer, bytecount / 4);
-       if ((bytecount & 0x03) >= 2)
-               hwif->OUTSW(hwif->io_ports.data_addr,
-                           (u8 *)buffer + (bytecount & ~0x03), 1);
+               if ((len & 3) >= 2)
+                       hwif->OUTSW(data_addr, (u8 *)buf + (len & ~3), 1);
+       } else
+               hwif->OUTSW(data_addr, buf, len / 2);
 }
 
 void default_hwif_transport(ide_hwif_t *hwif)
 {
-       hwif->ata_input_data            = ata_input_data;
-       hwif->ata_output_data           = ata_output_data;
-       hwif->atapi_input_bytes         = atapi_input_bytes;
-       hwif->atapi_output_bytes        = atapi_output_bytes;
+       hwif->input_data  = ata_input_data;
+       hwif->output_data = ata_output_data;
 }
 
 void ide_fix_driveid (struct hd_driveid *id)
@@ -656,7 +638,7 @@ int ide_driveid_update(ide_drive_t *drive)
                local_irq_restore(flags);
                return 0;
        }
-       hwif->ata_input_data(drive, NULL, id, SECTOR_WORDS);
+       hwif->input_data(drive, NULL, id, SECTOR_SIZE);
        (void)ide_read_status(drive);   /* clear drive IRQ */
        local_irq_enable();
        local_irq_restore(flags);

diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index e06a6460521571ef90baaea1c5aa1175e377be7b..8f7d576606439139324ba47b7ddc964869303a3a 100644 (file)
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -124,7 +124,7 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
 
        id = drive->id;
        /* read 512 bytes of id info */
-       hwif->ata_input_data(drive, NULL, id, SECTOR_WORDS);
+       hwif->input_data(drive, NULL, id, SECTOR_SIZE);
 
        drive->id_read = 1;
        local_irq_enable();

diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 29870c415110ad0bc3cf2d4bf76791ebfe0d5763..f4f31238bbef5b79495b0770958903410201819a 100644 (file)
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -401,7 +401,7 @@ static void idetape_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
                count = min(
                        (unsigned int)(bh->b_size - atomic_read(&bh->b_count)),
                        bcount);
-               HWIF(drive)->atapi_input_bytes(drive, bh->b_data +
+               drive->hwif->input_data(drive, NULL, bh->b_data +
                                        atomic_read(&bh->b_count), count);
                bcount -= count;
                atomic_add(count, &bh->b_count);
@@ -427,7 +427,7 @@ static void idetape_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
                        return;
                }
                count = min((unsigned int)pc->b_count, (unsigned int)bcount);
-               HWIF(drive)->atapi_output_bytes(drive, pc->b_data, count);
+               drive->hwif->output_data(drive, NULL, pc->b_data, count);
                bcount -= count;
                pc->b_data += count;
                pc->b_count -= count;
@@ -880,16 +880,16 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)
                                "data than expected - allowing transfer\n");
                }
                iobuf = &idetape_input_buffers;
-               xferfunc = hwif->atapi_input_bytes;
+               xferfunc = hwif->input_data;
        } else {
                iobuf = &idetape_output_buffers;
-               xferfunc = hwif->atapi_output_bytes;
+               xferfunc = hwif->output_data;
        }
 
        if (pc->bh)
                iobuf(drive, pc, bcount);
        else
-               xferfunc(drive, pc->cur_pos, bcount);
+               xferfunc(drive, NULL, pc->cur_pos, bcount);
 
        /* Update the current position */
        pc->xferred += bcount;
@@ -979,7 +979,8 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive)
                hwif->dma_ops->dma_start(drive);
 #endif
        /* Send the actual packet */
-       HWIF(drive)->atapi_output_bytes(drive, pc->c, 12);
+       hwif->output_data(drive, NULL, pc->c, 12);
+
        return ide_started;
 }
 

diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index 7f6bfd314411700f94a4997c6abf5bff78785c0c..0321884f9d921a68d009ccef7d7cc0e0c2013005 100644 (file)
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -324,9 +324,9 @@ static void ide_pio_sector(ide_drive_t *drive, struct request *rq,
 
        /* do the actual data transfer */
        if (write)
-               hwif->ata_output_data(drive, rq, buf, SECTOR_WORDS);
+               hwif->output_data(drive, rq, buf, SECTOR_SIZE);
        else
-               hwif->ata_input_data(drive, rq, buf, SECTOR_WORDS);
+               hwif->input_data(drive, rq, buf, SECTOR_SIZE);
 
        kunmap_atomic(buf, KM_BIO_SRC_IRQ);
 #ifdef CONFIG_HIGHMEM

diff --git a/drivers/ide/legacy/falconide.c b/drivers/ide/legacy/falconide.c
index 32c044b17d455c3f8cd75ea5d32470332b86c419..83555ca513b58c6b0f9330398431a151bd5ee027 100644 (file)
--- a/drivers/ide/legacy/falconide.c
+++ b/drivers/ide/legacy/falconide.c
@@ -44,34 +44,26 @@
 int falconide_intr_lock;
 EXPORT_SYMBOL(falconide_intr_lock);
 
-static void falconide_atapi_input_bytes(ide_drive_t *drive, void *buf,
-                                       unsigned int len)
+static void falconide_input_data(ide_drive_t *drive, struct request *rq,
+                                void *buf, unsigned int len)
 {
-       insw_swapw(drive->hwif->io_ports.data_addr, buf, (len + 1) / 2);
-}
-
-static void falconide_atapi_output_bytes(ide_drive_t *drive, void *buf,
-                                        unsigned int len)
-{
-       outsw_swapw(drive->hwif->io_ports.data_addr, buf, (len + 1) / 2);
-}
+       unsigned long data_addr = drive->hwif->io_ports.data_addr;
 
-static void falconide_ata_input_data(ide_drive_t *drive, struct request *rq,
-                                    void *buf, unsigned int wcount)
-{
        if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
-               return insw(drive->hwif->io_ports.data_addr, buf, wcount * 2);
+               return insw(data_addr, buf, (len + 1) / 2);
 
-       falconide_atapi_input_bytes(drive, buf, wcount * 4);
+       insw_swapw(data_addr, buf, (len + 1) / 2);
 }
 
-static void falconide_ata_output_data(ide_drive_t *drive, struct request *rq,
-                                     void *buf, unsigned int wcount)
+static void falconide_output_data(ide_drive_t *drive, struct request *rq,
+                                 void *buf, unsigned int len)
 {
+       unsigned long data_addr = drive->hwif->io_ports.data_addr;
+
        if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
-               return outsw(drive->hwif->io_ports.data_addr, buf, wcount * 2);
+               return outsw(data_adr, buf, (len + 1) / 2);
 
-       falconide_atapi_output_bytes(drive, buf, wcount * 4);
+       outsw_swapw(data_addr, buf, (len + 1) / 2);
 }
 
 static void __init falconide_setup_ports(hw_regs_t *hw)
@@ -121,10 +113,8 @@ static int __init falconide_init(void)
                ide_init_port_hw(hwif, &hw);
 
                /* Atari has a byte-swapped IDE interface */
-               hwif->atapi_input_bytes  = falconide_atapi_input_bytes;
-               hwif->atapi_output_bytes = falconide_atapi_output_bytes;
-               hwif->ata_input_data     = falconide_ata_input_data;
-               hwif->ata_output_data    = falconide_ata_output_data;
+               hwif->input_data  = falconide_input_data;
+               hwif->output_data = falconide_output_data;
 
                ide_get_lock(NULL, NULL);
                ide_device_add(idx, NULL);

diff --git a/drivers/ide/legacy/q40ide.c b/drivers/ide/legacy/q40ide.c
index deae3d2ca65e7a57de640f9806f2d29824cfbab1..6f535d00e6389d26ccc1f7187eebe8238dadc498 100644 (file)
--- a/drivers/ide/legacy/q40ide.c
+++ b/drivers/ide/legacy/q40ide.c
@@ -72,34 +72,26 @@ static void q40_ide_setup_ports(hw_regs_t *hw, unsigned long base,
        hw->ack_intr = ack_intr;
 }
 
-static void q40ide_atapi_input_bytes(ide_drive_t *drive, void *buf,
-                                    unsigned int len)
+static void q40ide_input_data(ide_drive_t *drive, struct request *rq,
+                             void *buf, unsigned int len)
 {
-       insw_swapw(drive->hwif->io_ports.data_addr, buf, (len + 1) / 2);
-}
-
-static void q40ide_atapi_output_bytes(ide_drive_t *drive, void *buf,
-                                     unsigned int len)
-{
-       outsw_swapw(drive->hwif->io_ports.data_addr, buf, (len + 1) / 2);
-}
+       unsigned long data_addr = drive->hwif->io_ports.data_addr;
 
-static void q40ide_ata_input_data(ide_drive_t *drive, struct request *rq,
-                                 void *buf, unsigned int wcount)
-{
        if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
-               return insw(drive->hwif->io_ports.data_addr, buf, wcount * 2);
+               return insw(data_addr, buf, (len + 1) / 2);
 
-       q40ide_atapi_input_bytes(drive, buf, wcount * 4);
+       insw_swapw(data_addr, buf, (len + 1) / 2);
 }
 
-static void q40ide_ata_output_data(ide_drive_t *drive, struct request *rq,
-                                  void *buf, unsigned int wcount)
+static void q40ide_output_data(ide_drive_t *drive, struct request *rq,
+                              void *buf, unsigned int len)
 {
+       unsigned long data_addr = drive->hwif->io_ports.data_addr;
+
        if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
-               return outsw(drive->hwif->io_ports.data_addr, buf, wcount * 2);
+               return outsw(data_addr, buf, (len + 1) / 2);
 
-       q40ide_atapi_output_bytes(drive, buf, wcount * 4);
+       outsw_swapw(data_addr, buf, (len + 1) / 2);
 }
 
 /* 
@@ -152,10 +144,8 @@ static int __init q40ide_init(void)
                ide_init_port_hw(hwif, &hw);
 
                /* Q40 has a byte-swapped IDE interface */
-               hwif->atapi_input_bytes  = q40ide_atapi_input_bytes;
-               hwif->atapi_output_bytes = q40ide_atapi_output_bytes;
-               hwif->ata_input_data     = q40ide_ata_input_data;
-               hwif->ata_output_data    = q40ide_ata_output_data;
+               hwif->input_data  = q40ide_input_data;
+               hwif->output_data = q40ide_output_data;
 
                idx[i] = hwif->index;
        }

diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 32553639aded4d9e80ee9f54cf398250adaf0ddf..1168fb0a713cb5e9633c8c3aafd1eea324a12b58 100644 (file)
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -134,6 +134,7 @@ static inline idescsi_scsi_t *drive_to_idescsi(ide_drive_t *ide_drive)
 static void idescsi_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
                unsigned int bcount)
 {
+       ide_hwif_t *hwif = drive->hwif;
        int count;
        char *buf;
 
@@ -145,14 +146,12 @@ static void idescsi_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
                        local_irq_save(flags);
                        buf = kmap_atomic(sg_page(pc->sg), KM_IRQ0) +
                                        pc->sg->offset;
-                       drive->hwif->atapi_input_bytes(drive,
-                                               buf + pc->b_count, count);
+                       hwif->input_data(drive, NULL, buf + pc->b_count, count);
                        kunmap_atomic(buf - pc->sg->offset, KM_IRQ0);
                        local_irq_restore(flags);
                } else {
                        buf = sg_virt(pc->sg);
-                       drive->hwif->atapi_input_bytes(drive,
-                                               buf + pc->b_count, count);
+                       hwif->input_data(drive, NULL, buf + pc->b_count, count);
                }
                bcount -= count; pc->b_count += count;
                if (pc->b_count == pc->sg->length) {
@@ -172,6 +171,7 @@ static void idescsi_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
 static void idescsi_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
                unsigned int bcount)
 {
+       ide_hwif_t *hwif = drive->hwif;
        int count;
        char *buf;
 
@@ -183,14 +183,12 @@ static void idescsi_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
                        local_irq_save(flags);
                        buf = kmap_atomic(sg_page(pc->sg), KM_IRQ0) +
                                                pc->sg->offset;
-                       drive->hwif->atapi_output_bytes(drive,
-                                               buf + pc->b_count, count);
+                       hwif->output_data(drive, NULL, buf + pc->b_count, count);
                        kunmap_atomic(buf - pc->sg->offset, KM_IRQ0);
                        local_irq_restore(flags);
                } else {
                        buf = sg_virt(pc->sg);
-                       drive->hwif->atapi_output_bytes(drive,
-                                               buf + pc->b_count, count);
+                       hwif->output_data(drive, NULL, buf + pc->b_count, count);
                }
                bcount -= count; pc->b_count += count;
                if (pc->b_count == pc->sg->length) {
@@ -431,7 +429,8 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
                                                idescsi_input_buffers(drive, pc,
                                                                        temp);
                                        else
-                                               drive->hwif->atapi_input_bytes(drive, pc->cur_pos, temp);
+                                               hwif->input_data(drive, NULL,
+                                                       pc->cur_pos, temp);
                                        printk(KERN_ERR "ide-scsi: transferred"
                                                        " %d of %d bytes\n",
                                                        temp, bcount);
@@ -452,15 +451,13 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
                if (pc->sg)
                        idescsi_input_buffers(drive, pc, bcount);
                else
-                       hwif->atapi_input_bytes(drive, pc->cur_pos,
-                                               bcount);
+                       hwif->input_data(drive, NULL, pc->cur_pos, bcount);
        } else {
                pc->flags |= PC_FLAG_WRITING;
                if (pc->sg)
                        idescsi_output_buffers(drive, pc, bcount);
                else
-                       hwif->atapi_output_bytes(drive, pc->cur_pos,
-                                                bcount);
+                       hwif->output_data(drive, NULL, pc->cur_pos, bcount);
        }
        /* Update the current position */
        pc->xferred += bcount;
@@ -493,8 +490,10 @@ static ide_startstop_t idescsi_transfer_pc(ide_drive_t *drive)
        BUG_ON(HWGROUP(drive)->handler != NULL);
        /* Set the interrupt routine */
        ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), idescsi_expiry);
+
        /* Send the actual packet */
-       drive->hwif->atapi_output_bytes(drive, scsi->pc->c, 12);
+       hwif->output_data(drive, NULL, scsi->pc->c, 12);
+
        if (pc->flags & PC_FLAG_DMA_OK) {
                pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
                hwif->dma_ops->dma_start(drive);

diff --git a/include/linux/ide.h b/include/linux/ide.h
index 0cbc46bf08a5febcd65c0174484517a26b65f6b2..b89b95dcb70824ca5c743b224ab91b4336dcf401 100644 (file)
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -467,11 +467,8 @@ typedef struct hwif_s {
        const struct ide_port_ops       *port_ops;
        const struct ide_dma_ops        *dma_ops;
 
-       void (*ata_input_data)(ide_drive_t *, struct request *, void *, u32);
-       void (*ata_output_data)(ide_drive_t *, struct request *, void *, u32);
-
-       void (*atapi_input_bytes)(ide_drive_t *, void *, u32);
-       void (*atapi_output_bytes)(ide_drive_t *, void *, u32);
+       void (*input_data)(ide_drive_t *, struct request *, void *, unsigned);
+       void (*output_data)(ide_drive_t *, struct request *, void *, unsigned);
 
        void (*ide_dma_clear_irq)(ide_drive_t *drive);
 
@@ -547,7 +544,7 @@ typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
 typedef int (ide_expiry_t)(ide_drive_t *);
 
 /* used by ide-cd, ide-floppy, etc. */
-typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
+typedef void (xfer_func_t)(ide_drive_t *, struct request *rq, void *, unsigned);
 
 typedef struct hwgroup_s {
                /* irq handler, if active */
@@ -1369,7 +1366,7 @@ static inline void ide_atapi_discard_data(ide_drive_t *drive, unsigned bcount)
 {
        ide_hwif_t *hwif = drive->hwif;
 
-       /* FIXME: use ->atapi_input_bytes */
+       /* FIXME: use ->input_data */
        while (bcount--)
                (void)hwif->INB(hwif->io_ports.data_addr);
 }
@@ -1378,7 +1375,7 @@ static inline void ide_atapi_write_zeros(ide_drive_t *drive, unsigned bcount)
 {
        ide_hwif_t *hwif = drive->hwif;
 
-       /* FIXME: use ->atapi_output_bytes */
+       /* FIXME: use ->output_data */
        while (bcount--)
                hwif->OUTB(0, hwif->io_ports.data_addr);
 }