Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 1df8130278c4543555fea697e5714fbac300b899

Authored by Russell King
Committed by Russell King
1 parent f40b121d98
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

[ARM] dma: remove dmach_t typedef 

Remove a pointless integer typedef.

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

Showing 6 changed files with 98 additions and 100 deletions Side-by-side Diff

arch/arm/include/asm/dma.h
Diff comments   View file @ 1df8130
... ... @@ -19,8 +19,6 @@
19 19 #include <asm/system.h>
20 20 #include <asm/scatterlist.h>
21 21  
22   -typedef unsigned int dmach_t;
23   -
24 22 #include <mach/isa-dma.h>
25 23  
26 24 /*
27 25  
28 26  
29 27  
30 28  
31 29  
32 30  
... ... @@ -52,44 +50,44 @@
52 50 /* Clear the 'DMA Pointer Flip Flop'.
53 51 * Write 0 for LSB/MSB, 1 for MSB/LSB access.
54 52 */
55   -#define clear_dma_ff(channel)
  53 +#define clear_dma_ff(chan)
56 54  
57 55 /* Set only the page register bits of the transfer address.
58 56 *
59 57 * NOTE: This is an architecture specific function, and should
60 58 * be hidden from the drivers
61 59 */
62   -extern void set_dma_page(dmach_t channel, char pagenr);
  60 +extern void set_dma_page(unsigned int chan, char pagenr);
63 61  
64 62 /* Request a DMA channel
65 63 *
66 64 * Some architectures may need to do allocate an interrupt
67 65 */
68   -extern int request_dma(dmach_t channel, const char * device_id);
  66 +extern int request_dma(unsigned int chan, const char * device_id);
69 67  
70 68 /* Free a DMA channel
71 69 *
72 70 * Some architectures may need to do free an interrupt
73 71 */
74   -extern void free_dma(dmach_t channel);
  72 +extern void free_dma(unsigned int chan);
75 73  
76 74 /* Enable DMA for this channel
77 75 *
78 76 * On some architectures, this may have other side effects like
79 77 * enabling an interrupt and setting the DMA registers.
80 78 */
81   -extern void enable_dma(dmach_t channel);
  79 +extern void enable_dma(unsigned int chan);
82 80  
83 81 /* Disable DMA for this channel
84 82 *
85 83 * On some architectures, this may have other side effects like
86 84 * disabling an interrupt or whatever.
87 85 */
88   -extern void disable_dma(dmach_t channel);
  86 +extern void disable_dma(unsigned int chan);
89 87  
90 88 /* Test whether the specified channel has an active DMA transfer
91 89 */
92   -extern int dma_channel_active(dmach_t channel);
  90 +extern int dma_channel_active(unsigned int chan);
93 91  
94 92 /* Set the DMA scatter gather list for this channel
95 93 *
... ... @@ -97,7 +95,7 @@
97 95 * especially since some DMA architectures don't update the
98 96 * DMA address immediately, but defer it to the enable_dma().
99 97 */
100   -extern void set_dma_sg(dmach_t channel, struct scatterlist *sg, int nr_sg);
  98 +extern void set_dma_sg(unsigned int chan, struct scatterlist *sg, int nr_sg);
101 99  
102 100 /* Set the DMA address for this channel
103 101 *
... ... @@ -105,9 +103,9 @@
105 103 * especially since some DMA architectures don't update the
106 104 * DMA address immediately, but defer it to the enable_dma().
107 105 */
108   -extern void __set_dma_addr(dmach_t channel, void *addr);
109   -#define set_dma_addr(channel, addr) \
110   - __set_dma_addr(channel, bus_to_virt(addr))
  106 +extern void __set_dma_addr(unsigned int chan, void *addr);
  107 +#define set_dma_addr(chan, addr) \
  108 + __set_dma_addr(chan, bus_to_virt(addr))
111 109  
112 110 /* Set the DMA byte count for this channel
113 111 *
... ... @@ -115,7 +113,7 @@
115 113 * especially since some DMA architectures don't update the
116 114 * DMA count immediately, but defer it to the enable_dma().
117 115 */
118   -extern void set_dma_count(dmach_t channel, unsigned long count);
  116 +extern void set_dma_count(unsigned int chan, unsigned long count);
119 117  
120 118 /* Set the transfer direction for this channel
121 119 *
122 120  
... ... @@ -124,11 +122,11 @@
124 122 * DMA transfer direction immediately, but defer it to the
125 123 * enable_dma().
126 124 */
127   -extern void set_dma_mode(dmach_t channel, dmamode_t mode);
  125 +extern void set_dma_mode(unsigned int chan, dmamode_t mode);
128 126  
129 127 /* Set the transfer speed for this channel
130 128 */
131   -extern void set_dma_speed(dmach_t channel, int cycle_ns);
  129 +extern void set_dma_speed(unsigned int chan, int cycle_ns);
132 130  
133 131 /* Get DMA residue count. After a DMA transfer, this
134 132 * should return zero. Reading this while a DMA transfer is
... ... @@ -136,7 +134,7 @@
136 134 * If called before the channel has been used, it may return 1.
137 135 * Otherwise, it returns the number of _bytes_ left to transfer.
138 136 */
139   -extern int get_dma_residue(dmach_t channel);
  137 +extern int get_dma_residue(unsigned int chan);
140 138  
141 139 #ifndef NO_DMA
142 140 #define NO_DMA 255
arch/arm/include/asm/mach/dma.h
Diff comments   View file @ 1df8130
... ... @@ -15,12 +15,12 @@
15 15 typedef struct dma_struct dma_t;
16 16  
17 17 struct dma_ops {
18   - int (*request)(dmach_t, dma_t *); /* optional */
19   - void (*free)(dmach_t, dma_t *); /* optional */
20   - void (*enable)(dmach_t, dma_t *); /* mandatory */
21   - void (*disable)(dmach_t, dma_t *); /* mandatory */
22   - int (*residue)(dmach_t, dma_t *); /* optional */
23   - int (*setspeed)(dmach_t, dma_t *, int); /* optional */
  18 + int (*request)(unsigned int, dma_t *); /* optional */
  19 + void (*free)(unsigned int, dma_t *); /* optional */
  20 + void (*enable)(unsigned int, dma_t *); /* mandatory */
  21 + void (*disable)(unsigned int, dma_t *); /* mandatory */
  22 + int (*residue)(unsigned int, dma_t *); /* optional */
  23 + int (*setspeed)(unsigned int, dma_t *, int); /* optional */
24 24 char *type;
25 25 };
26 26  
arch/arm/kernel/dma-isa.c
Diff comments   View file @ 1df8130
... ... @@ -49,25 +49,25 @@
49 49 { 0xd4, 0xd6, 0xd8, 0x48a, 0x08a, 0xcc, 0xce }
50 50 };
51 51  
52   -static int isa_get_dma_residue(dmach_t channel, dma_t *dma)
  52 +static int isa_get_dma_residue(unsigned int chan, dma_t *dma)
53 53 {
54   - unsigned int io_port = isa_dma_port[channel][ISA_DMA_COUNT];
  54 + unsigned int io_port = isa_dma_port[chan][ISA_DMA_COUNT];
55 55 int count;
56 56  
57 57 count = 1 + inb(io_port);
58 58 count |= inb(io_port) << 8;
59 59  
60   - return channel < 4 ? count : (count << 1);
  60 + return chan < 4 ? count : (count << 1);
61 61 }
62 62  
63   -static void isa_enable_dma(dmach_t channel, dma_t *dma)
  63 +static void isa_enable_dma(unsigned int chan, dma_t *dma)
64 64 {
65 65 if (dma->invalid) {
66 66 unsigned long address, length;
67 67 unsigned int mode;
68 68 enum dma_data_direction direction;
69 69  
70   - mode = channel & 3;
  70 + mode = chan & 3;
71 71 switch (dma->dma_mode & DMA_MODE_MASK) {
72 72 case DMA_MODE_READ:
73 73 mode |= ISA_DMA_MODE_READ;
74 74  
75 75  
76 76  
77 77  
78 78  
79 79  
80 80  
81 81  
... ... @@ -105,34 +105,34 @@
105 105 address = dma->buf.dma_address;
106 106 length = dma->buf.length - 1;
107 107  
108   - outb(address >> 16, isa_dma_port[channel][ISA_DMA_PGLO]);
109   - outb(address >> 24, isa_dma_port[channel][ISA_DMA_PGHI]);
  108 + outb(address >> 16, isa_dma_port[chan][ISA_DMA_PGLO]);
  109 + outb(address >> 24, isa_dma_port[chan][ISA_DMA_PGHI]);
110 110  
111   - if (channel >= 4) {
  111 + if (chan >= 4) {
112 112 address >>= 1;
113 113 length >>= 1;
114 114 }
115 115  
116   - outb(0, isa_dma_port[channel][ISA_DMA_CLRFF]);
  116 + outb(0, isa_dma_port[chan][ISA_DMA_CLRFF]);
117 117  
118   - outb(address, isa_dma_port[channel][ISA_DMA_ADDR]);
119   - outb(address >> 8, isa_dma_port[channel][ISA_DMA_ADDR]);
  118 + outb(address, isa_dma_port[chan][ISA_DMA_ADDR]);
  119 + outb(address >> 8, isa_dma_port[chan][ISA_DMA_ADDR]);
120 120  
121   - outb(length, isa_dma_port[channel][ISA_DMA_COUNT]);
122   - outb(length >> 8, isa_dma_port[channel][ISA_DMA_COUNT]);
  121 + outb(length, isa_dma_port[chan][ISA_DMA_COUNT]);
  122 + outb(length >> 8, isa_dma_port[chan][ISA_DMA_COUNT]);
123 123  
124 124 if (dma->dma_mode & DMA_AUTOINIT)
125 125 mode |= ISA_DMA_AUTOINIT;
126 126  
127   - outb(mode, isa_dma_port[channel][ISA_DMA_MODE]);
  127 + outb(mode, isa_dma_port[chan][ISA_DMA_MODE]);
128 128 dma->invalid = 0;
129 129 }
130   - outb(channel & 3, isa_dma_port[channel][ISA_DMA_MASK]);
  130 + outb(chan & 3, isa_dma_port[chan][ISA_DMA_MASK]);
131 131 }
132 132  
133   -static void isa_disable_dma(dmach_t channel, dma_t *dma)
  133 +static void isa_disable_dma(unsigned int chan, dma_t *dma)
134 134 {
135   - outb(channel | 4, isa_dma_port[channel][ISA_DMA_MASK]);
  135 + outb(chan | 4, isa_dma_port[chan][ISA_DMA_MASK]);
136 136 }
137 137  
138 138 static struct dma_ops isa_dma_ops = {
139 139  
... ... @@ -178,11 +178,11 @@
178 178 outb(0xaa, 0x00);
179 179  
180 180 if (inb(0) == 0x55 && inb(0) == 0xaa) {
181   - int channel, i;
  181 + int chan, i;
182 182  
183   - for (channel = 0; channel < 8; channel++) {
184   - dma[channel].d_ops = &isa_dma_ops;
185   - isa_disable_dma(channel, NULL);
  183 + for (chan = 0; chan < 8; chan++) {
  184 + dma[chan].d_ops = &isa_dma_ops;
  185 + isa_disable_dma(chan, NULL);
186 186 }
187 187  
188 188 outb(0x40, 0x0b);
arch/arm/kernel/dma.c
Diff comments   View file @ 1df8130
... ... @@ -30,12 +30,12 @@
30 30 *
31 31 * On certain platforms, we have to allocate an interrupt as well...
32 32 */
33   -int request_dma(dmach_t channel, const char *device_id)
  33 +int request_dma(unsigned int chan, const char *device_id)
34 34 {
35   - dma_t *dma = dma_chan + channel;
  35 + dma_t *dma = dma_chan + chan;
36 36 int ret;
37 37  
38   - if (channel >= MAX_DMA_CHANNELS || !dma->d_ops)
  38 + if (chan >= MAX_DMA_CHANNELS || !dma->d_ops)
39 39 goto bad_dma;
40 40  
41 41 if (xchg(&dma->lock, 1) != 0)
... ... @@ -47,7 +47,7 @@
47 47  
48 48 ret = 0;
49 49 if (dma->d_ops->request)
50   - ret = dma->d_ops->request(channel, dma);
  50 + ret = dma->d_ops->request(chan, dma);
51 51  
52 52 if (ret)
53 53 xchg(&dma->lock, 0);
... ... @@ -55,7 +55,7 @@
55 55 return ret;
56 56  
57 57 bad_dma:
58   - printk(KERN_ERR "dma: trying to allocate DMA%d\n", channel);
  58 + printk(KERN_ERR "dma: trying to allocate DMA%d\n", chan);
59 59 return -EINVAL;
60 60  
61 61 busy:
62 62  
63 63  
64 64  
65 65  
66 66  
67 67  
68 68  
69 69  
70 70  
... ... @@ -68,42 +68,42 @@
68 68 *
69 69 * On certain platforms, we have to free interrupt as well...
70 70 */
71   -void free_dma(dmach_t channel)
  71 +void free_dma(unsigned int chan)
72 72 {
73   - dma_t *dma = dma_chan + channel;
  73 + dma_t *dma = dma_chan + chan;
74 74  
75   - if (channel >= MAX_DMA_CHANNELS || !dma->d_ops)
  75 + if (chan >= MAX_DMA_CHANNELS || !dma->d_ops)
76 76 goto bad_dma;
77 77  
78 78 if (dma->active) {
79   - printk(KERN_ERR "dma%d: freeing active DMA\n", channel);
80   - dma->d_ops->disable(channel, dma);
  79 + printk(KERN_ERR "dma%d: freeing active DMA\n", chan);
  80 + dma->d_ops->disable(chan, dma);
81 81 dma->active = 0;
82 82 }
83 83  
84 84 if (xchg(&dma->lock, 0) != 0) {
85 85 if (dma->d_ops->free)
86   - dma->d_ops->free(channel, dma);
  86 + dma->d_ops->free(chan, dma);
87 87 return;
88 88 }
89 89  
90   - printk(KERN_ERR "dma%d: trying to free free DMA\n", channel);
  90 + printk(KERN_ERR "dma%d: trying to free free DMA\n", chan);
91 91 return;
92 92  
93 93 bad_dma:
94   - printk(KERN_ERR "dma: trying to free DMA%d\n", channel);
  94 + printk(KERN_ERR "dma: trying to free DMA%d\n", chan);
95 95 }
96 96 EXPORT_SYMBOL(free_dma);
97 97  
98 98 /* Set DMA Scatter-Gather list
99 99 */
100   -void set_dma_sg (dmach_t channel, struct scatterlist *sg, int nr_sg)
  100 +void set_dma_sg (unsigned int chan, struct scatterlist *sg, int nr_sg)
101 101 {
102   - dma_t *dma = dma_chan + channel;
  102 + dma_t *dma = dma_chan + chan;
103 103  
104 104 if (dma->active)
105 105 printk(KERN_ERR "dma%d: altering DMA SG while "
106   - "DMA active\n", channel);
  106 + "DMA active\n", chan);
107 107  
108 108 dma->sg = sg;
109 109 dma->sgcount = nr_sg;
110 110  
111 111  
... ... @@ -115,13 +115,13 @@
115 115 *
116 116 * Copy address to the structure, and set the invalid bit
117 117 */
118   -void __set_dma_addr (dmach_t channel, void *addr)
  118 +void __set_dma_addr (unsigned int chan, void *addr)
119 119 {
120   - dma_t *dma = dma_chan + channel;
  120 + dma_t *dma = dma_chan + chan;
121 121  
122 122 if (dma->active)
123 123 printk(KERN_ERR "dma%d: altering DMA address while "
124   - "DMA active\n", channel);
  124 + "DMA active\n", chan);
125 125  
126 126 dma->sg = NULL;
127 127 dma->addr = addr;
128 128  
129 129  
... ... @@ -133,13 +133,13 @@
133 133 *
134 134 * Copy address to the structure, and set the invalid bit
135 135 */
136   -void set_dma_count (dmach_t channel, unsigned long count)
  136 +void set_dma_count (unsigned int chan, unsigned long count)
137 137 {
138   - dma_t *dma = dma_chan + channel;
  138 + dma_t *dma = dma_chan + chan;
139 139  
140 140 if (dma->active)
141 141 printk(KERN_ERR "dma%d: altering DMA count while "
142   - "DMA active\n", channel);
  142 + "DMA active\n", chan);
143 143  
144 144 dma->sg = NULL;
145 145 dma->count = count;
146 146  
147 147  
... ... @@ -149,13 +149,13 @@
149 149  
150 150 /* Set DMA direction mode
151 151 */
152   -void set_dma_mode (dmach_t channel, dmamode_t mode)
  152 +void set_dma_mode (unsigned int chan, dmamode_t mode)
153 153 {
154   - dma_t *dma = dma_chan + channel;
  154 + dma_t *dma = dma_chan + chan;
155 155  
156 156 if (dma->active)
157 157 printk(KERN_ERR "dma%d: altering DMA mode while "
158   - "DMA active\n", channel);
  158 + "DMA active\n", chan);
159 159  
160 160 dma->dma_mode = mode;
161 161 dma->invalid = 1;
162 162  
163 163  
164 164  
165 165  
166 166  
167 167  
168 168  
... ... @@ -164,42 +164,42 @@
164 164  
165 165 /* Enable DMA channel
166 166 */
167   -void enable_dma (dmach_t channel)
  167 +void enable_dma (unsigned int chan)
168 168 {
169   - dma_t *dma = dma_chan + channel;
  169 + dma_t *dma = dma_chan + chan;
170 170  
171 171 if (!dma->lock)
172 172 goto free_dma;
173 173  
174 174 if (dma->active == 0) {
175 175 dma->active = 1;
176   - dma->d_ops->enable(channel, dma);
  176 + dma->d_ops->enable(chan, dma);
177 177 }
178 178 return;
179 179  
180 180 free_dma:
181   - printk(KERN_ERR "dma%d: trying to enable free DMA\n", channel);
  181 + printk(KERN_ERR "dma%d: trying to enable free DMA\n", chan);
182 182 BUG();
183 183 }
184 184 EXPORT_SYMBOL(enable_dma);
185 185  
186 186 /* Disable DMA channel
187 187 */
188   -void disable_dma (dmach_t channel)
  188 +void disable_dma (unsigned int chan)
189 189 {
190   - dma_t *dma = dma_chan + channel;
  190 + dma_t *dma = dma_chan + chan;
191 191  
192 192 if (!dma->lock)
193 193 goto free_dma;
194 194  
195 195 if (dma->active == 1) {
196 196 dma->active = 0;
197   - dma->d_ops->disable(channel, dma);
  197 + dma->d_ops->disable(chan, dma);
198 198 }
199 199 return;
200 200  
201 201 free_dma:
202   - printk(KERN_ERR "dma%d: trying to disable free DMA\n", channel);
  202 + printk(KERN_ERR "dma%d: trying to disable free DMA\n", chan);
203 203 BUG();
204 204 }
205 205 EXPORT_SYMBOL(disable_dma);
206 206  
207 207  
208 208  
209 209  
210 210  
211 211  
212 212  
213 213  
214 214  
... ... @@ -207,36 +207,36 @@
207 207 /*
208 208 * Is the specified DMA channel active?
209 209 */
210   -int dma_channel_active(dmach_t channel)
  210 +int dma_channel_active(unsigned int chan)
211 211 {
212   - return dma_chan[channel].active;
  212 + return dma_chan[chan].active;
213 213 }
214 214 EXPORT_SYMBOL(dma_channel_active);
215 215  
216   -void set_dma_page(dmach_t channel, char pagenr)
  216 +void set_dma_page(unsigned int chan, char pagenr)
217 217 {
218   - printk(KERN_ERR "dma%d: trying to set_dma_page\n", channel);
  218 + printk(KERN_ERR "dma%d: trying to set_dma_page\n", chan);
219 219 }
220 220 EXPORT_SYMBOL(set_dma_page);
221 221  
222   -void set_dma_speed(dmach_t channel, int cycle_ns)
  222 +void set_dma_speed(unsigned int chan, int cycle_ns)
223 223 {
224   - dma_t *dma = dma_chan + channel;
  224 + dma_t *dma = dma_chan + chan;
225 225 int ret = 0;
226 226  
227 227 if (dma->d_ops->setspeed)
228   - ret = dma->d_ops->setspeed(channel, dma, cycle_ns);
  228 + ret = dma->d_ops->setspeed(chan, dma, cycle_ns);
229 229 dma->speed = ret;
230 230 }
231 231 EXPORT_SYMBOL(set_dma_speed);
232 232  
233   -int get_dma_residue(dmach_t channel)
  233 +int get_dma_residue(unsigned int chan)
234 234 {
235   - dma_t *dma = dma_chan + channel;
  235 + dma_t *dma = dma_chan + chan;
236 236 int ret = 0;
237 237  
238 238 if (dma->d_ops->residue)
239   - ret = dma->d_ops->residue(channel, dma);
  239 + ret = dma->d_ops->residue(chan, dma);
240 240  
241 241 return ret;
242 242 }
arch/arm/mach-footbridge/dma.c
Diff comments   View file @ 1df8130
... ... @@ -20,16 +20,16 @@
20 20 #include <asm/hardware/dec21285.h>
21 21  
22 22 #if 0
23   -static int fb_dma_request(dmach_t channel, dma_t *dma)
  23 +static int fb_dma_request(unsigned int chan, dma_t *dma)
24 24 {
25 25 return -EINVAL;
26 26 }
27 27  
28   -static void fb_dma_enable(dmach_t channel, dma_t *dma)
  28 +static void fb_dma_enable(unsigned int chan, dma_t *dma)
29 29 {
30 30 }
31 31  
32   -static void fb_dma_disable(dmach_t channel, dma_t *dma)
  32 +static void fb_dma_disable(unsigned int chan, dma_t *dma)
33 33 {
34 34 }
35 35  
arch/arm/mach-rpc/dma.c
Diff comments   View file @ 1df8130
... ... @@ -125,18 +125,18 @@
125 125 return IRQ_HANDLED;
126 126 }
127 127  
128   -static int iomd_request_dma(dmach_t channel, dma_t *dma)
  128 +static int iomd_request_dma(unsigned int chan, dma_t *dma)
129 129 {
130 130 return request_irq(dma->dma_irq, iomd_dma_handle,
131 131 IRQF_DISABLED, dma->device_id, dma);
132 132 }
133 133  
134   -static void iomd_free_dma(dmach_t channel, dma_t *dma)
  134 +static void iomd_free_dma(unsigned int chan, dma_t *dma)
135 135 {
136 136 free_irq(dma->dma_irq, dma);
137 137 }
138 138  
139   -static void iomd_enable_dma(dmach_t channel, dma_t *dma)
  139 +static void iomd_enable_dma(unsigned int chan, dma_t *dma)
140 140 {
141 141 unsigned long dma_base = dma->dma_base;
142 142 unsigned int ctrl = TRANSFER_SIZE | DMA_CR_E;
... ... @@ -169,7 +169,7 @@
169 169 enable_irq(dma->dma_irq);
170 170 }
171 171  
172   -static void iomd_disable_dma(dmach_t channel, dma_t *dma)
  172 +static void iomd_disable_dma(unsigned int chan, dma_t *dma)
173 173 {
174 174 unsigned long dma_base = dma->dma_base;
175 175 unsigned long flags;
... ... @@ -181,7 +181,7 @@
181 181 local_irq_restore(flags);
182 182 }
183 183  
184   -static int iomd_set_dma_speed(dmach_t channel, dma_t *dma, int cycle)
  184 +static int iomd_set_dma_speed(unsigned int chan, dma_t *dma, int cycle)
185 185 {
186 186 int tcr, speed;
187 187  
... ... @@ -197,7 +197,7 @@
197 197 tcr = iomd_readb(IOMD_DMATCR);
198 198 speed &= 3;
199 199  
200   - switch (channel) {
  200 + switch (chan) {
201 201 case DMA_0:
202 202 tcr = (tcr & ~0x03) | speed;
203 203 break;
... ... @@ -236,7 +236,7 @@
236 236 .name = "floppydma"
237 237 };
238 238  
239   -static void floppy_enable_dma(dmach_t channel, dma_t *dma)
  239 +static void floppy_enable_dma(unsigned int chan, dma_t *dma)
240 240 {
241 241 void *fiqhandler_start;
242 242 unsigned int fiqhandler_length;
243 243  
... ... @@ -269,13 +269,13 @@
269 269 enable_fiq(dma->dma_irq);
270 270 }
271 271  
272   -static void floppy_disable_dma(dmach_t channel, dma_t *dma)
  272 +static void floppy_disable_dma(unsigned int chan, dma_t *dma)
273 273 {
274 274 disable_fiq(dma->dma_irq);
275 275 release_fiq(&fh);
276 276 }
277 277  
278   -static int floppy_get_residue(dmach_t channel, dma_t *dma)
  278 +static int floppy_get_residue(unsigned int chan, dma_t *dma)
279 279 {
280 280 struct pt_regs regs;
281 281 get_fiq_regs(&regs);
... ... @@ -292,7 +292,7 @@
292 292 /*
293 293 * This is virtual DMA - we don't need anything here.
294 294 */
295   -static void sound_enable_disable_dma(dmach_t channel, dma_t *dma)
  295 +static void sound_enable_disable_dma(unsigned int chan, dma_t *dma)
296 296 {
297 297 }
298 298