renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-17 17:53:56 +08:00
Code

[ARM] dma: remove dmach_t typedef

Browse Source 
Remove a pointless integer typedef.

Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
This commit is contained in:
Russell King 2008-12-08 15:58:50 +00:00 committed by Russell King
parent f40b121d98
commit 1df8130278
6 changed files with 98 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
arch/arm/include/asm/dma.h
View File

@ -19,8 +19,6 @@
#include <asm/system.h> #include <asm/system.h>
#include <asm/scatterlist.h> #include <asm/scatterlist.h>
typedef unsigned int dmach_t;
#include <mach/isa-dma.h> #include <mach/isa-dma.h>
/* /*
@ -52,44 +50,44 @@ static inline void release_dma_lock(unsigned long flags)
/* Clear the 'DMA Pointer Flip Flop'. /* Clear the 'DMA Pointer Flip Flop'.
* Write 0 for LSB/MSB, 1 for MSB/LSB access. * 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. /* Set only the page register bits of the transfer address.
* *
* NOTE: This is an architecture specific function, and should * NOTE: This is an architecture specific function, and should
* be hidden from the drivers * 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 /* Request a DMA channel
* *
* Some architectures may need to do allocate an interrupt * 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 /* Free a DMA channel
* *
* Some architectures may need to do free an interrupt * 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 /* Enable DMA for this channel
* *
* On some architectures, this may have other side effects like * On some architectures, this may have other side effects like
* enabling an interrupt and setting the DMA registers. * 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 /* Disable DMA for this channel
* *
* On some architectures, this may have other side effects like * On some architectures, this may have other side effects like
* disabling an interrupt or whatever. * 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 /* 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 /* 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 * especially since some DMA architectures don't update the
* DMA address immediately, but defer it to the enable_dma(). * 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 /* 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 * especially since some DMA architectures don't update the
* DMA address immediately, but defer it to the enable_dma(). * DMA address immediately, but defer it to the enable_dma().
*/ */
extern void __set_dma_addr(dmach_t channel, void *addr); extern void __set_dma_addr(unsigned int chan, void *addr);
#define set_dma_addr(channel, addr) \ #define set_dma_addr(chan, addr) \
__set_dma_addr(channel, bus_to_virt(addr)) __set_dma_addr(chan, bus_to_virt(addr))
/* Set the DMA byte count for this channel /* 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 * especially since some DMA architectures don't update the
* DMA count immediately, but defer it to the enable_dma(). * 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 /* 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 * DMA transfer direction immediately, but defer it to the
* enable_dma(). * 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 /* 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 /* Get DMA residue count. After a DMA transfer, this
* should return zero. Reading this while a DMA transfer is * 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. * If called before the channel has been used, it may return 1.
* Otherwise, it returns the number of _bytes_ left to transfer. * 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 #ifndef NO_DMA
#define NO_DMA 255 #define NO_DMA 255

12
arch/arm/include/asm/mach/dma.h
View File

@ -15,12 +15,12 @@ struct dma_struct;
typedef struct dma_struct dma_t; typedef struct dma_struct dma_t;
struct dma_ops { struct dma_ops {
int (*request)(dmach_t, dma_t *); /* optional */ int (*request)(unsigned int, dma_t *); /* optional */
void (*free)(dmach_t, dma_t *); /* optional */ void (*free)(unsigned int, dma_t *); /* optional */
void (*enable)(dmach_t, dma_t *); /* mandatory */ void (*enable)(unsigned int, dma_t *); /* mandatory */
void (*disable)(dmach_t, dma_t *); /* mandatory */ void (*disable)(unsigned int, dma_t *); /* mandatory */
int (*residue)(dmach_t, dma_t *); /* optional */ int (*residue)(unsigned int, dma_t *); /* optional */
int (*setspeed)(dmach_t, dma_t *, int); /* optional */ int (*setspeed)(unsigned int, dma_t *, int); /* optional */
char *type; char *type;
}; };

42
arch/arm/kernel/dma-isa.c
View File

@ -49,25 +49,25 @@ static unsigned int isa_dma_port[8][7] = {
{ 0xd4, 0xd6, 0xd8, 0x48a, 0x08a, 0xcc, 0xce } { 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; int count;
count = 1 + inb(io_port); count = 1 + inb(io_port);
count |= inb(io_port) << 8; 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) { if (dma->invalid) {
unsigned long address, length; unsigned long address, length;
unsigned int mode; unsigned int mode;
enum dma_data_direction direction; enum dma_data_direction direction;
mode = channel & 3; mode = chan & 3;
switch (dma->dma_mode & DMA_MODE_MASK) { switch (dma->dma_mode & DMA_MODE_MASK) {
case DMA_MODE_READ: case DMA_MODE_READ:
mode |= ISA_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; address = dma->buf.dma_address;
length = dma->buf.length - 1; length = dma->buf.length - 1;
outb(address >> 16, isa_dma_port[channel][ISA_DMA_PGLO]); outb(address >> 16, isa_dma_port[chan][ISA_DMA_PGLO]);
outb(address >> 24, isa_dma_port[channel][ISA_DMA_PGHI]); outb(address >> 24, isa_dma_port[chan][ISA_DMA_PGHI]);
if (channel >= 4) { if (chan >= 4) {
address >>= 1; address >>= 1;
length >>= 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, isa_dma_port[chan][ISA_DMA_ADDR]);
outb(address >> 8, isa_dma_port[channel][ISA_DMA_ADDR]); outb(address >> 8, isa_dma_port[chan][ISA_DMA_ADDR]);
outb(length, isa_dma_port[channel][ISA_DMA_COUNT]); outb(length, isa_dma_port[chan][ISA_DMA_COUNT]);
outb(length >> 8, isa_dma_port[channel][ISA_DMA_COUNT]); outb(length >> 8, isa_dma_port[chan][ISA_DMA_COUNT]);
if (dma->dma_mode & DMA_AUTOINIT) if (dma->dma_mode & DMA_AUTOINIT)
mode |= ISA_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; 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 = { static struct dma_ops isa_dma_ops = {
@ -178,11 +178,11 @@ void __init isa_init_dma(dma_t *dma)
outb(0xaa, 0x00); outb(0xaa, 0x00);
if (inb(0) == 0x55 && inb(0) == 0xaa) { if (inb(0) == 0x55 && inb(0) == 0xaa) {
int channel, i; int chan, i;
for (channel = 0; channel < 8; channel++) { for (chan = 0; chan < 8; chan++) {
dma[channel].d_ops = &isa_dma_ops; dma[chan].d_ops = &isa_dma_ops;
isa_disable_dma(channel, NULL); isa_disable_dma(chan, NULL);
} }
outb(0x40, 0x0b); outb(0x40, 0x0b);

86
arch/arm/kernel/dma.c
View File

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

6
arch/arm/mach-footbridge/dma.c
View File

@ -20,16 +20,16 @@
#include <asm/hardware/dec21285.h> #include <asm/hardware/dec21285.h>
#if 0 #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; 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)
{ {
} }

20
arch/arm/mach-rpc/dma.c
View File

@ -125,18 +125,18 @@ static irqreturn_t iomd_dma_handle(int irq, void *dev_id)
return IRQ_HANDLED; 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, return request_irq(dma->dma_irq, iomd_dma_handle,
IRQF_DISABLED, dma->device_id, dma); 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); 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 long dma_base = dma->dma_base;
unsigned int ctrl = TRANSFER_SIZE | DMA_CR_E; 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); 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 dma_base = dma->dma_base;
unsigned long flags; unsigned long flags;
@ -181,7 +181,7 @@ static void iomd_disable_dma(dmach_t channel, dma_t *dma)
local_irq_restore(flags); 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; 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); tcr = iomd_readb(IOMD_DMATCR);
speed &= 3; speed &= 3;
switch (channel) { switch (chan) {
case DMA_0: case DMA_0:
tcr = (tcr & ~0x03) | speed; tcr = (tcr & ~0x03) | speed;
break; break;
@ -236,7 +236,7 @@ static struct fiq_handler fh = {
.name = "floppydma" .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; void *fiqhandler_start;
unsigned int fiqhandler_length; unsigned int fiqhandler_length;
@ -269,13 +269,13 @@ static void floppy_enable_dma(dmach_t channel, dma_t *dma)
enable_fiq(dma->dma_irq); 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); disable_fiq(dma->dma_irq);
release_fiq(&fh); 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; struct pt_regs regs;
get_fiq_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. * 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)
{ {
} }