[ARM] dma: remove dmach_t typedef

Remove a pointless integer typedef.

Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

diff --git a/arch/arm/include/asm/dma.h b/arch/arm/include/asm/dma.h
index df5638f3643aea42d72d0a04d20284ca36995c70..c5557a650d1d83cdf27514db3a9469e1b028de9e 100644 (file)
--- a/arch/arm/include/asm/dma.h
+++ b/arch/arm/include/asm/dma.h
@@ -19,8 +19,6 @@
 #include <asm/system.h>
 #include <asm/scatterlist.h>
 
-typedef unsigned int dmach_t;
-
 #include <mach/isa-dma.h>
 
 /*
@@ -52,44 +50,44 @@ static inline void release_dma_lock(unsigned long flags)
 /* Clear the 'DMA Pointer Flip Flop'.
  * Write 0 for LSB/MSB, 1 for MSB/LSB access.
  */
-#define clear_dma_ff(channel)
+#define clear_dma_ff(chan)
 
 /* Set only the page register bits of the transfer address.
  *
  * NOTE: This is an architecture specific function, and should
  *       be hidden from the drivers
  */
-extern void set_dma_page(dmach_t channel, char pagenr);
+extern void set_dma_page(unsigned int chan, char pagenr);
 
 /* Request a DMA channel
  *
  * Some architectures may need to do allocate an interrupt
  */
-extern int  request_dma(dmach_t channel, const char * device_id);
+extern int  request_dma(unsigned int chan, const char * device_id);
 
 /* Free a DMA channel
  *
  * Some architectures may need to do free an interrupt
  */
-extern void free_dma(dmach_t channel);
+extern void free_dma(unsigned int chan);
 
 /* Enable DMA for this channel
  *
  * On some architectures, this may have other side effects like
  * enabling an interrupt and setting the DMA registers.
  */
-extern void enable_dma(dmach_t channel);
+extern void enable_dma(unsigned int chan);
 
 /* Disable DMA for this channel
  *
  * On some architectures, this may have other side effects like
  * disabling an interrupt or whatever.
  */
-extern void disable_dma(dmach_t channel);
+extern void disable_dma(unsigned int chan);
 
 /* Test whether the specified channel has an active DMA transfer
  */
-extern int dma_channel_active(dmach_t channel);
+extern int dma_channel_active(unsigned int chan);
 
 /* Set the DMA scatter gather list for this channel
  *
@@ -97,7 +95,7 @@ extern int dma_channel_active(dmach_t channel);
  * especially since some DMA architectures don't update the
  * DMA address immediately, but defer it to the enable_dma().
  */
-extern void set_dma_sg(dmach_t channel, struct scatterlist *sg, int nr_sg);
+extern void set_dma_sg(unsigned int chan, struct scatterlist *sg, int nr_sg);
 
 /* Set the DMA address for this channel
  *
@@ -105,9 +103,9 @@ extern void set_dma_sg(dmach_t channel, struct scatterlist *sg, int nr_sg);
  * especially since some DMA architectures don't update the
  * DMA address immediately, but defer it to the enable_dma().
  */
-extern void __set_dma_addr(dmach_t channel, void *addr);
-#define set_dma_addr(channel, addr)                            \
-       __set_dma_addr(channel, bus_to_virt(addr))
+extern void __set_dma_addr(unsigned int chan, void *addr);
+#define set_dma_addr(chan, addr)                               \
+       __set_dma_addr(chan, bus_to_virt(addr))
 
 /* Set the DMA byte count for this channel
  *
@@ -115,7 +113,7 @@ extern void __set_dma_addr(dmach_t channel, void *addr);
  * especially since some DMA architectures don't update the
  * DMA count immediately, but defer it to the enable_dma().
  */
-extern void set_dma_count(dmach_t channel, unsigned long count);
+extern void set_dma_count(unsigned int chan, unsigned long count);
 
 /* Set the transfer direction for this channel
  *
@@ -124,11 +122,11 @@ extern void set_dma_count(dmach_t channel, unsigned long count);
  * DMA transfer direction immediately, but defer it to the
  * enable_dma().
  */
-extern void set_dma_mode(dmach_t channel, dmamode_t mode);
+extern void set_dma_mode(unsigned int chan, dmamode_t mode);
 
 /* Set the transfer speed for this channel
  */
-extern void set_dma_speed(dmach_t channel, int cycle_ns);
+extern void set_dma_speed(unsigned int chan, int cycle_ns);
 
 /* Get DMA residue count. After a DMA transfer, this
  * should return zero. Reading this while a DMA transfer is
@@ -136,7 +134,7 @@ extern void set_dma_speed(dmach_t channel, int cycle_ns);
  * If called before the channel has been used, it may return 1.
  * Otherwise, it returns the number of _bytes_ left to transfer.
  */
-extern int  get_dma_residue(dmach_t channel);
+extern int  get_dma_residue(unsigned int chan);
 
 #ifndef NO_DMA
 #define NO_DMA 255

diff --git a/arch/arm/include/asm/mach/dma.h b/arch/arm/include/asm/mach/dma.h
index fc7278ea7146798d50c0dfb219bae5db025fefab..281ae7e40a90c486cdd076c42cce0e6b4f9954e2 100644 (file)
--- a/arch/arm/include/asm/mach/dma.h
+++ b/arch/arm/include/asm/mach/dma.h
@@ -15,12 +15,12 @@ struct dma_struct;
 typedef struct dma_struct dma_t;
 
 struct dma_ops {
-       int     (*request)(dmach_t, dma_t *);           /* optional */
-       void    (*free)(dmach_t, dma_t *);              /* optional */
-       void    (*enable)(dmach_t, dma_t *);            /* mandatory */
-       void    (*disable)(dmach_t, dma_t *);           /* mandatory */
-       int     (*residue)(dmach_t, dma_t *);           /* optional */
-       int     (*setspeed)(dmach_t, dma_t *, int);     /* optional */
+       int     (*request)(unsigned int, dma_t *);              /* optional */
+       void    (*free)(unsigned int, dma_t *);                 /* optional */
+       void    (*enable)(unsigned int, dma_t *);               /* mandatory */
+       void    (*disable)(unsigned int, dma_t *);              /* mandatory */
+       int     (*residue)(unsigned int, dma_t *);              /* optional */
+       int     (*setspeed)(unsigned int, dma_t *, int);        /* optional */
        char    *type;
 };
 

diff --git a/arch/arm/kernel/dma-isa.c b/arch/arm/kernel/dma-isa.c
index 4a3a50495c60778c813acbf192b1fa16475a995d..29eca48925d8e2dbfdc161a35ffa63715e56c8d4 100644 (file)
--- a/arch/arm/kernel/dma-isa.c
+++ b/arch/arm/kernel/dma-isa.c
@@ -49,25 +49,25 @@ static unsigned int isa_dma_port[8][7] = {
        {  0xd4,  0xd6,  0xd8,  0x48a,  0x08a,  0xcc, 0xce }
 };
 
-static int isa_get_dma_residue(dmach_t channel, dma_t *dma)
+static int isa_get_dma_residue(unsigned int chan, dma_t *dma)
 {
-       unsigned int io_port = isa_dma_port[channel][ISA_DMA_COUNT];
+       unsigned int io_port = isa_dma_port[chan][ISA_DMA_COUNT];
        int count;
 
        count = 1 + inb(io_port);
        count |= inb(io_port) << 8;
 
-       return channel < 4 ? count : (count << 1);
+       return chan < 4 ? count : (count << 1);
 }
 
-static void isa_enable_dma(dmach_t channel, dma_t *dma)
+static void isa_enable_dma(unsigned int chan, dma_t *dma)
 {
        if (dma->invalid) {
                unsigned long address, length;
                unsigned int mode;
                enum dma_data_direction direction;
 
-               mode = channel & 3;
+               mode = chan & 3;
                switch (dma->dma_mode & DMA_MODE_MASK) {
                case DMA_MODE_READ:
                        mode |= ISA_DMA_MODE_READ;
@@ -105,34 +105,34 @@ static void isa_enable_dma(dmach_t channel, dma_t *dma)
                address = dma->buf.dma_address;
                length  = dma->buf.length - 1;
 
-               outb(address >> 16, isa_dma_port[channel][ISA_DMA_PGLO]);
-               outb(address >> 24, isa_dma_port[channel][ISA_DMA_PGHI]);
+               outb(address >> 16, isa_dma_port[chan][ISA_DMA_PGLO]);
+               outb(address >> 24, isa_dma_port[chan][ISA_DMA_PGHI]);
 
-               if (channel >= 4) {
+               if (chan >= 4) {
                        address >>= 1;
                        length >>= 1;
                }
 
-               outb(0, isa_dma_port[channel][ISA_DMA_CLRFF]);
+               outb(0, isa_dma_port[chan][ISA_DMA_CLRFF]);
 
-               outb(address, isa_dma_port[channel][ISA_DMA_ADDR]);
-               outb(address >> 8, isa_dma_port[channel][ISA_DMA_ADDR]);
+               outb(address, isa_dma_port[chan][ISA_DMA_ADDR]);
+               outb(address >> 8, isa_dma_port[chan][ISA_DMA_ADDR]);
 
-               outb(length, isa_dma_port[channel][ISA_DMA_COUNT]);
-               outb(length >> 8, isa_dma_port[channel][ISA_DMA_COUNT]);
+               outb(length, isa_dma_port[chan][ISA_DMA_COUNT]);
+               outb(length >> 8, isa_dma_port[chan][ISA_DMA_COUNT]);
 
                if (dma->dma_mode & DMA_AUTOINIT)
                        mode |= ISA_DMA_AUTOINIT;
 
-               outb(mode, isa_dma_port[channel][ISA_DMA_MODE]);
+               outb(mode, isa_dma_port[chan][ISA_DMA_MODE]);
                dma->invalid = 0;
        }
-       outb(channel & 3, isa_dma_port[channel][ISA_DMA_MASK]);
+       outb(chan & 3, isa_dma_port[chan][ISA_DMA_MASK]);
 }
 
-static void isa_disable_dma(dmach_t channel, dma_t *dma)
+static void isa_disable_dma(unsigned int chan, dma_t *dma)
 {
-       outb(channel | 4, isa_dma_port[channel][ISA_DMA_MASK]);
+       outb(chan | 4, isa_dma_port[chan][ISA_DMA_MASK]);
 }
 
 static struct dma_ops isa_dma_ops = {
@@ -178,11 +178,11 @@ void __init isa_init_dma(dma_t *dma)
        outb(0xaa, 0x00);
 
        if (inb(0) == 0x55 && inb(0) == 0xaa) {
-               int channel, i;
+               int chan, i;
 
-               for (channel = 0; channel < 8; channel++) {
-                       dma[channel].d_ops = &isa_dma_ops;
-                       isa_disable_dma(channel, NULL);
+               for (chan = 0; chan < 8; chan++) {
+                       dma[chan].d_ops = &isa_dma_ops;
+                       isa_disable_dma(chan, NULL);
                }
 
                outb(0x40, 0x0b);

diff --git a/arch/arm/kernel/dma.c b/arch/arm/kernel/dma.c
index d006085ed7e7b882966510d09695fbb4b1a6091a..c31bf00e5bae378842912df1673b5dcaf9e6f3a2 100644 (file)
--- a/arch/arm/kernel/dma.c
+++ b/arch/arm/kernel/dma.c
@@ -30,12 +30,12 @@ static dma_t dma_chan[MAX_DMA_CHANNELS];
  *
  * On certain platforms, we have to allocate an interrupt as well...
  */
-int request_dma(dmach_t channel, const char *device_id)
+int request_dma(unsigned int chan, const char *device_id)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
        int ret;
 
-       if (channel >= MAX_DMA_CHANNELS || !dma->d_ops)
+       if (chan >= MAX_DMA_CHANNELS || !dma->d_ops)
                goto bad_dma;
 
        if (xchg(&dma->lock, 1) != 0)
@@ -47,7 +47,7 @@ int request_dma(dmach_t channel, const char *device_id)
 
        ret = 0;
        if (dma->d_ops->request)
-               ret = dma->d_ops->request(channel, dma);
+               ret = dma->d_ops->request(chan, dma);
 
        if (ret)
                xchg(&dma->lock, 0);
@@ -55,7 +55,7 @@ int request_dma(dmach_t channel, const char *device_id)
        return ret;
 
 bad_dma:
-       printk(KERN_ERR "dma: trying to allocate DMA%d\n", channel);
+       printk(KERN_ERR "dma: trying to allocate DMA%d\n", chan);
        return -EINVAL;
 
 busy:
@@ -68,42 +68,42 @@ EXPORT_SYMBOL(request_dma);
  *
  * On certain platforms, we have to free interrupt as well...
  */
-void free_dma(dmach_t channel)
+void free_dma(unsigned int chan)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
 
-       if (channel >= MAX_DMA_CHANNELS || !dma->d_ops)
+       if (chan >= MAX_DMA_CHANNELS || !dma->d_ops)
                goto bad_dma;
 
        if (dma->active) {
-               printk(KERN_ERR "dma%d: freeing active DMA\n", channel);
-               dma->d_ops->disable(channel, dma);
+               printk(KERN_ERR "dma%d: freeing active DMA\n", chan);
+               dma->d_ops->disable(chan, dma);
                dma->active = 0;
        }
 
        if (xchg(&dma->lock, 0) != 0) {
                if (dma->d_ops->free)
-                       dma->d_ops->free(channel, dma);
+                       dma->d_ops->free(chan, dma);
                return;
        }
 
-       printk(KERN_ERR "dma%d: trying to free free DMA\n", channel);
+       printk(KERN_ERR "dma%d: trying to free free DMA\n", chan);
        return;
 
 bad_dma:
-       printk(KERN_ERR "dma: trying to free DMA%d\n", channel);
+       printk(KERN_ERR "dma: trying to free DMA%d\n", chan);
 }
 EXPORT_SYMBOL(free_dma);
 
 /* Set DMA Scatter-Gather list
  */
-void set_dma_sg (dmach_t channel, struct scatterlist *sg, int nr_sg)
+void set_dma_sg (unsigned int chan, struct scatterlist *sg, int nr_sg)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
 
        if (dma->active)
                printk(KERN_ERR "dma%d: altering DMA SG while "
-                      "DMA active\n", channel);
+                      "DMA active\n", chan);
 
        dma->sg = sg;
        dma->sgcount = nr_sg;
@@ -115,13 +115,13 @@ EXPORT_SYMBOL(set_dma_sg);
  *
  * Copy address to the structure, and set the invalid bit
  */
-void __set_dma_addr (dmach_t channel, void *addr)
+void __set_dma_addr (unsigned int chan, void *addr)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
 
        if (dma->active)
                printk(KERN_ERR "dma%d: altering DMA address while "
-                      "DMA active\n", channel);
+                      "DMA active\n", chan);
 
        dma->sg = NULL;
        dma->addr = addr;
@@ -133,13 +133,13 @@ EXPORT_SYMBOL(__set_dma_addr);
  *
  * Copy address to the structure, and set the invalid bit
  */
-void set_dma_count (dmach_t channel, unsigned long count)
+void set_dma_count (unsigned int chan, unsigned long count)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
 
        if (dma->active)
                printk(KERN_ERR "dma%d: altering DMA count while "
-                      "DMA active\n", channel);
+                      "DMA active\n", chan);
 
        dma->sg = NULL;
        dma->count = count;
@@ -149,13 +149,13 @@ EXPORT_SYMBOL(set_dma_count);
 
 /* Set DMA direction mode
  */
-void set_dma_mode (dmach_t channel, dmamode_t mode)
+void set_dma_mode (unsigned int chan, dmamode_t mode)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
 
        if (dma->active)
                printk(KERN_ERR "dma%d: altering DMA mode while "
-                      "DMA active\n", channel);
+                      "DMA active\n", chan);
 
        dma->dma_mode = mode;
        dma->invalid = 1;
@@ -164,42 +164,42 @@ EXPORT_SYMBOL(set_dma_mode);
 
 /* Enable DMA channel
  */
-void enable_dma (dmach_t channel)
+void enable_dma (unsigned int chan)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
 
        if (!dma->lock)
                goto free_dma;
 
        if (dma->active == 0) {
                dma->active = 1;
-               dma->d_ops->enable(channel, dma);
+               dma->d_ops->enable(chan, dma);
        }
        return;
 
 free_dma:
-       printk(KERN_ERR "dma%d: trying to enable free DMA\n", channel);
+       printk(KERN_ERR "dma%d: trying to enable free DMA\n", chan);
        BUG();
 }
 EXPORT_SYMBOL(enable_dma);
 
 /* Disable DMA channel
  */
-void disable_dma (dmach_t channel)
+void disable_dma (unsigned int chan)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
 
        if (!dma->lock)
                goto free_dma;
 
        if (dma->active == 1) {
                dma->active = 0;
-               dma->d_ops->disable(channel, dma);
+               dma->d_ops->disable(chan, dma);
        }
        return;
 
 free_dma:
-       printk(KERN_ERR "dma%d: trying to disable free DMA\n", channel);
+       printk(KERN_ERR "dma%d: trying to disable free DMA\n", chan);
        BUG();
 }
 EXPORT_SYMBOL(disable_dma);
@@ -207,36 +207,36 @@ EXPORT_SYMBOL(disable_dma);
 /*
  * Is the specified DMA channel active?
  */
-int dma_channel_active(dmach_t channel)
+int dma_channel_active(unsigned int chan)
 {
-       return dma_chan[channel].active;
+       return dma_chan[chan].active;
 }
 EXPORT_SYMBOL(dma_channel_active);
 
-void set_dma_page(dmach_t channel, char pagenr)
+void set_dma_page(unsigned int chan, char pagenr)
 {
-       printk(KERN_ERR "dma%d: trying to set_dma_page\n", channel);
+       printk(KERN_ERR "dma%d: trying to set_dma_page\n", chan);
 }
 EXPORT_SYMBOL(set_dma_page);
 
-void set_dma_speed(dmach_t channel, int cycle_ns)
+void set_dma_speed(unsigned int chan, int cycle_ns)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
        int ret = 0;
 
        if (dma->d_ops->setspeed)
-               ret = dma->d_ops->setspeed(channel, dma, cycle_ns);
+               ret = dma->d_ops->setspeed(chan, dma, cycle_ns);
        dma->speed = ret;
 }
 EXPORT_SYMBOL(set_dma_speed);
 
-int get_dma_residue(dmach_t channel)
+int get_dma_residue(unsigned int chan)
 {
-       dma_t *dma = dma_chan + channel;
+       dma_t *dma = dma_chan + chan;
        int ret = 0;
 
        if (dma->d_ops->residue)
-               ret = dma->d_ops->residue(channel, dma);
+               ret = dma->d_ops->residue(chan, dma);
 
        return ret;
 }

diff --git a/arch/arm/mach-footbridge/dma.c b/arch/arm/mach-footbridge/dma.c
index b653e9cfa3f7761ee9d988a213223c71470eb706..e7b8a6adaf7acec3683af70a392bcbca0bfa7575 100644 (file)
--- a/arch/arm/mach-footbridge/dma.c
+++ b/arch/arm/mach-footbridge/dma.c
@@ -20,16 +20,16 @@
 #include <asm/hardware/dec21285.h>
 
 #if 0
-static int fb_dma_request(dmach_t channel, dma_t *dma)
+static int fb_dma_request(unsigned int chan, dma_t *dma)
 {
        return -EINVAL;
 }
 
-static void fb_dma_enable(dmach_t channel, dma_t *dma)
+static void fb_dma_enable(unsigned int chan, dma_t *dma)
 {
 }
 
-static void fb_dma_disable(dmach_t channel, dma_t *dma)
+static void fb_dma_disable(unsigned int chan, dma_t *dma)
 {
 }
 

diff --git a/arch/arm/mach-rpc/dma.c b/arch/arm/mach-rpc/dma.c
index 7958a30f8932a5a418149ccd857f805b1f56af47..a86d3ed859a7d3a62b1e150c98310a8374e80031 100644 (file)
--- a/arch/arm/mach-rpc/dma.c
+++ b/arch/arm/mach-rpc/dma.c
@@ -125,18 +125,18 @@ static irqreturn_t iomd_dma_handle(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
 
-static int iomd_request_dma(dmach_t channel, dma_t *dma)
+static int iomd_request_dma(unsigned int chan, dma_t *dma)
 {
        return request_irq(dma->dma_irq, iomd_dma_handle,
                           IRQF_DISABLED, dma->device_id, dma);
 }
 
-static void iomd_free_dma(dmach_t channel, dma_t *dma)
+static void iomd_free_dma(unsigned int chan, dma_t *dma)
 {
        free_irq(dma->dma_irq, dma);
 }
 
-static void iomd_enable_dma(dmach_t channel, dma_t *dma)
+static void iomd_enable_dma(unsigned int chan, dma_t *dma)
 {
        unsigned long dma_base = dma->dma_base;
        unsigned int ctrl = TRANSFER_SIZE | DMA_CR_E;
@@ -169,7 +169,7 @@ static void iomd_enable_dma(dmach_t channel, dma_t *dma)
        enable_irq(dma->dma_irq);
 }
 
-static void iomd_disable_dma(dmach_t channel, dma_t *dma)
+static void iomd_disable_dma(unsigned int chan, dma_t *dma)
 {
        unsigned long dma_base = dma->dma_base;
        unsigned long flags;
@@ -181,7 +181,7 @@ static void iomd_disable_dma(dmach_t channel, dma_t *dma)
        local_irq_restore(flags);
 }
 
-static int iomd_set_dma_speed(dmach_t channel, dma_t *dma, int cycle)
+static int iomd_set_dma_speed(unsigned int chan, dma_t *dma, int cycle)
 {
        int tcr, speed;
 
@@ -197,7 +197,7 @@ static int iomd_set_dma_speed(dmach_t channel, dma_t *dma, int cycle)
        tcr = iomd_readb(IOMD_DMATCR);
        speed &= 3;
 
-       switch (channel) {
+       switch (chan) {
        case DMA_0:
                tcr = (tcr & ~0x03) | speed;
                break;
@@ -236,7 +236,7 @@ static struct fiq_handler fh = {
        .name   = "floppydma"
 };
 
-static void floppy_enable_dma(dmach_t channel, dma_t *dma)
+static void floppy_enable_dma(unsigned int chan, dma_t *dma)
 {
        void *fiqhandler_start;
        unsigned int fiqhandler_length;
@@ -269,13 +269,13 @@ static void floppy_enable_dma(dmach_t channel, dma_t *dma)
        enable_fiq(dma->dma_irq);
 }
 
-static void floppy_disable_dma(dmach_t channel, dma_t *dma)
+static void floppy_disable_dma(unsigned int chan, dma_t *dma)
 {
        disable_fiq(dma->dma_irq);
        release_fiq(&fh);
 }
 
-static int floppy_get_residue(dmach_t channel, dma_t *dma)
+static int floppy_get_residue(unsigned int chan, dma_t *dma)
 {
        struct pt_regs regs;
        get_fiq_regs(&regs);
@@ -292,7 +292,7 @@ static struct dma_ops floppy_dma_ops = {
 /*
  * This is virtual DMA - we don't need anything here.
  */
-static void sound_enable_disable_dma(dmach_t channel, dma_t *dma)
+static void sound_enable_disable_dma(unsigned int chan, dma_t *dma)
 {
 }