f15e64285f9628e25465a55426cc3e88d3d5d737
[linux-2.6.git] / arch / ppc / syslib / ppc4xx_dma.c
1 /*
2  * arch/ppc/kernel/ppc4xx_dma.c
3  *
4  * IBM PPC4xx DMA engine core library
5  *
6  * Copyright 2000-2004 MontaVista Software Inc.
7  *
8  * Cleaned up and converted to new DCR access
9  * Matt Porter <mporter@kernel.crashing.org>
10  *
11  * Original code by Armin Kuster <akuster@mvista.com>
12  * and Pete Popov <ppopov@mvista.com>
13  *
14  * This program is free software; you can redistribute  it and/or modify it
15  * under  the terms of  the GNU General  Public License as published by the
16  * Free Software Foundation;  either version 2 of the  License, or (at your
17  * option) any later version.
18  *
19  * You should have received a copy of the  GNU General Public License along
20  * with this program; if not, write  to the Free Software Foundation, Inc.,
21  * 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23
24 #include <linux/config.h>
25 #include <linux/kernel.h>
26 #include <linux/mm.h>
27 #include <linux/miscdevice.h>
28 #include <linux/init.h>
29 #include <linux/module.h>
30
31 #include <asm/system.h>
32 #include <asm/io.h>
33 #include <asm/ppc4xx_dma.h>
34
35 ppc_dma_ch_t dma_channels[MAX_PPC4xx_DMA_CHANNELS];
36
37 int
38 ppc4xx_get_dma_status(void)
39 {
40         return (mfdcr(DCRN_DMASR));
41 }
42
43 void
44 ppc4xx_set_src_addr(int dmanr, phys_addr_t src_addr)
45 {
46         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
47                 printk("set_src_addr: bad channel: %d\n", dmanr);
48                 return;
49         }
50
51 #ifdef PPC4xx_DMA_64BIT
52         mtdcr(DCRN_DMASAH0 + dmanr*2, (u32)(src_addr >> 32));
53 #else
54         mtdcr(DCRN_DMASA0 + dmanr*2, (u32)src_addr);
55 #endif
56 }
57
58 void
59 ppc4xx_set_dst_addr(int dmanr, phys_addr_t dst_addr)
60 {
61         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
62                 printk("set_dst_addr: bad channel: %d\n", dmanr);
63                 return;
64         }
65
66 #ifdef PPC4xx_DMA_64BIT
67         mtdcr(DCRN_DMADAH0 + dmanr*2, (u32)(dst_addr >> 32));
68 #else
69         mtdcr(DCRN_DMADA0 + dmanr*2, (u32)dst_addr);
70 #endif
71 }
72
73 void
74 ppc4xx_enable_dma(unsigned int dmanr)
75 {
76         unsigned int control;
77         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
78         unsigned int status_bits[] = { DMA_CS0 | DMA_TS0 | DMA_CH0_ERR,
79                                        DMA_CS1 | DMA_TS1 | DMA_CH1_ERR,
80                                        DMA_CS2 | DMA_TS2 | DMA_CH2_ERR,
81                                        DMA_CS3 | DMA_TS3 | DMA_CH3_ERR};
82
83         if (p_dma_ch->in_use) {
84                 printk("enable_dma: channel %d in use\n", dmanr);
85                 return;
86         }
87
88         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
89                 printk("enable_dma: bad channel: %d\n", dmanr);
90                 return;
91         }
92
93         if (p_dma_ch->mode == DMA_MODE_READ) {
94                 /* peripheral to memory */
95                 ppc4xx_set_src_addr(dmanr, 0);
96                 ppc4xx_set_dst_addr(dmanr, p_dma_ch->addr);
97         } else if (p_dma_ch->mode == DMA_MODE_WRITE) {
98                 /* memory to peripheral */
99                 ppc4xx_set_src_addr(dmanr, p_dma_ch->addr);
100                 ppc4xx_set_dst_addr(dmanr, 0);
101         }
102
103         /* for other xfer modes, the addresses are already set */
104         control = mfdcr(DCRN_DMACR0 + (dmanr * 0x8));
105
106         control &= ~(DMA_TM_MASK | DMA_TD);     /* clear all mode bits */
107         if (p_dma_ch->mode == DMA_MODE_MM) {
108                 /* software initiated memory to memory */
109                 control |= DMA_ETD_OUTPUT | DMA_TCE_ENABLE;
110         }
111
112         mtdcr(DCRN_DMACR0 + (dmanr * 0x8), control);
113
114         /*
115          * Clear the CS, TS, RI bits for the channel from DMASR.  This
116          * has been observed to happen correctly only after the mode and
117          * ETD/DCE bits in DMACRx are set above.  Must do this before
118          * enabling the channel.
119          */
120
121         mtdcr(DCRN_DMASR, status_bits[dmanr]);
122
123         /*
124          * For device-paced transfers, Terminal Count Enable apparently
125          * must be on, and this must be turned on after the mode, etc.
126          * bits are cleared above (at least on Redwood-6).
127          */
128
129         if ((p_dma_ch->mode == DMA_MODE_MM_DEVATDST) ||
130             (p_dma_ch->mode == DMA_MODE_MM_DEVATSRC))
131                 control |= DMA_TCE_ENABLE;
132
133         /*
134          * Now enable the channel.
135          */
136
137         control |= (p_dma_ch->mode | DMA_CE_ENABLE);
138
139         mtdcr(DCRN_DMACR0 + (dmanr * 0x8), control);
140
141         p_dma_ch->in_use = 1;
142 }
143
144 void
145 ppc4xx_disable_dma(unsigned int dmanr)
146 {
147         unsigned int control;
148         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
149
150         if (!p_dma_ch->in_use) {
151                 printk("disable_dma: channel %d not in use\n", dmanr);
152                 return;
153         }
154
155         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
156                 printk("disable_dma: bad channel: %d\n", dmanr);
157                 return;
158         }
159
160         control = mfdcr(DCRN_DMACR0 + (dmanr * 0x8));
161         control &= ~DMA_CE_ENABLE;
162         mtdcr(DCRN_DMACR0 + (dmanr * 0x8), control);
163
164         p_dma_ch->in_use = 0;
165 }
166
167 /*
168  * Sets the dma mode for single DMA transfers only.
169  * For scatter/gather transfers, the mode is passed to the
170  * alloc_dma_handle() function as one of the parameters.
171  *
172  * The mode is simply saved and used later.  This allows
173  * the driver to call set_dma_mode() and set_dma_addr() in
174  * any order.
175  *
176  * Valid mode values are:
177  *
178  * DMA_MODE_READ          peripheral to memory
179  * DMA_MODE_WRITE         memory to peripheral
180  * DMA_MODE_MM            memory to memory
181  * DMA_MODE_MM_DEVATSRC   device-paced memory to memory, device at src
182  * DMA_MODE_MM_DEVATDST   device-paced memory to memory, device at dst
183  */
184 int
185 ppc4xx_set_dma_mode(unsigned int dmanr, unsigned int mode)
186 {
187         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
188
189         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
190                 printk("set_dma_mode: bad channel 0x%x\n", dmanr);
191                 return DMA_STATUS_BAD_CHANNEL;
192         }
193
194         p_dma_ch->mode = mode;
195
196         return DMA_STATUS_GOOD;
197 }
198
199 /*
200  * Sets the DMA Count register. Note that 'count' is in bytes.
201  * However, the DMA Count register counts the number of "transfers",
202  * where each transfer is equal to the bus width.  Thus, count
203  * MUST be a multiple of the bus width.
204  */
205 void
206 ppc4xx_set_dma_count(unsigned int dmanr, unsigned int count)
207 {
208         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
209
210 #ifdef DEBUG_4xxDMA
211         {
212                 int error = 0;
213                 switch (p_dma_ch->pwidth) {
214                 case PW_8:
215                         break;
216                 case PW_16:
217                         if (count & 0x1)
218                                 error = 1;
219                         break;
220                 case PW_32:
221                         if (count & 0x3)
222                                 error = 1;
223                         break;
224                 case PW_64:
225                         if (count & 0x7)
226                                 error = 1;
227                         break;
228                 default:
229                         printk("set_dma_count: invalid bus width: 0x%x\n",
230                                p_dma_ch->pwidth);
231                         return;
232                 }
233                 if (error)
234                         printk
235                             ("Warning: set_dma_count count 0x%x bus width %d\n",
236                              count, p_dma_ch->pwidth);
237         }
238 #endif
239
240         count = count >> p_dma_ch->shift;
241
242         mtdcr(DCRN_DMACT0 + (dmanr * 0x8), count);
243 }
244
245 /*
246  *   Returns the number of bytes left to be transfered.
247  *   After a DMA transfer, this should return zero.
248  *   Reading this while a DMA transfer is still in progress will return
249  *   unpredictable results.
250  */
251 int
252 ppc4xx_get_dma_residue(unsigned int dmanr)
253 {
254         unsigned int count;
255         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
256
257         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
258                 printk("ppc4xx_get_dma_residue: bad channel 0x%x\n", dmanr);
259                 return DMA_STATUS_BAD_CHANNEL;
260         }
261
262         count = mfdcr(DCRN_DMACT0 + (dmanr * 0x8));
263
264         return (count << p_dma_ch->shift);
265 }
266
267 /*
268  * Sets the DMA address for a memory to peripheral or peripheral
269  * to memory transfer.  The address is just saved in the channel
270  * structure for now and used later in enable_dma().
271  */
272 void
273 ppc4xx_set_dma_addr(unsigned int dmanr, phys_addr_t addr)
274 {
275         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
276
277         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
278                 printk("ppc4xx_set_dma_addr: bad channel: %d\n", dmanr);
279                 return;
280         }
281
282 #ifdef DEBUG_4xxDMA
283         {
284                 int error = 0;
285                 switch (p_dma_ch->pwidth) {
286                 case PW_8:
287                         break;
288                 case PW_16:
289                         if ((unsigned) addr & 0x1)
290                                 error = 1;
291                         break;
292                 case PW_32:
293                         if ((unsigned) addr & 0x3)
294                                 error = 1;
295                         break;
296                 case PW_64:
297                         if ((unsigned) addr & 0x7)
298                                 error = 1;
299                         break;
300                 default:
301                         printk("ppc4xx_set_dma_addr: invalid bus width: 0x%x\n",
302                                p_dma_ch->pwidth);
303                         return;
304                 }
305                 if (error)
306                         printk("Warning: ppc4xx_set_dma_addr addr 0x%x bus width %d\n",
307                                addr, p_dma_ch->pwidth);
308         }
309 #endif
310
311         /* save dma address and program it later after we know the xfer mode */
312         p_dma_ch->addr = addr;
313 }
314
315 /*
316  * Sets both DMA addresses for a memory to memory transfer.
317  * For memory to peripheral or peripheral to memory transfers
318  * the function set_dma_addr() should be used instead.
319  */
320 void
321 ppc4xx_set_dma_addr2(unsigned int dmanr, phys_addr_t src_dma_addr,
322                      phys_addr_t dst_dma_addr)
323 {
324         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
325                 printk("ppc4xx_set_dma_addr2: bad channel: %d\n", dmanr);
326                 return;
327         }
328
329 #ifdef DEBUG_4xxDMA
330         {
331                 ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
332                 int error = 0;
333                 switch (p_dma_ch->pwidth) {
334                         case PW_8:
335                                 break;
336                         case PW_16:
337                                 if (((unsigned) src_dma_addr & 0x1) ||
338                                                 ((unsigned) dst_dma_addr & 0x1)
339                                    )
340                                         error = 1;
341                                 break;
342                         case PW_32:
343                                 if (((unsigned) src_dma_addr & 0x3) ||
344                                                 ((unsigned) dst_dma_addr & 0x3)
345                                    )
346                                         error = 1;
347                                 break;
348                         case PW_64:
349                                 if (((unsigned) src_dma_addr & 0x7) ||
350                                                 ((unsigned) dst_dma_addr & 0x7)
351                                    )
352                                         error = 1;
353                                 break;
354                         default:
355                                 printk("ppc4xx_set_dma_addr2: invalid bus width: 0x%x\n",
356                                                 p_dma_ch->pwidth);
357                                 return;
358                 }
359                 if (error)
360                         printk
361                                 ("Warning: ppc4xx_set_dma_addr2 src 0x%x dst 0x%x bus width %d\n",
362                                  src_dma_addr, dst_dma_addr, p_dma_ch->pwidth);
363         }
364 #endif
365
366         ppc4xx_set_src_addr(dmanr, src_dma_addr);
367         ppc4xx_set_dst_addr(dmanr, dst_dma_addr);
368 }
369
370 /*
371  * Enables the channel interrupt.
372  *
373  * If performing a scatter/gatter transfer, this function
374  * MUST be called before calling alloc_dma_handle() and building
375  * the sgl list.  Otherwise, interrupts will not be enabled, if
376  * they were previously disabled.
377  */
378 int
379 ppc4xx_enable_dma_interrupt(unsigned int dmanr)
380 {
381         unsigned int control;
382         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
383
384         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
385                 printk("ppc4xx_enable_dma_interrupt: bad channel: %d\n", dmanr);
386                 return DMA_STATUS_BAD_CHANNEL;
387         }
388
389         p_dma_ch->int_enable = 1;
390
391         control = mfdcr(DCRN_DMACR0 + (dmanr * 0x8));
392         control |= DMA_CIE_ENABLE;      /* Channel Interrupt Enable */
393         mtdcr(DCRN_DMACR0 + (dmanr * 0x8), control);
394
395         return DMA_STATUS_GOOD;
396 }
397
398 /*
399  * Disables the channel interrupt.
400  *
401  * If performing a scatter/gatter transfer, this function
402  * MUST be called before calling alloc_dma_handle() and building
403  * the sgl list.  Otherwise, interrupts will not be disabled, if
404  * they were previously enabled.
405  */
406 int
407 ppc4xx_disable_dma_interrupt(unsigned int dmanr)
408 {
409         unsigned int control;
410         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
411
412         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
413                 printk("ppc4xx_disable_dma_interrupt: bad channel: %d\n", dmanr);
414                 return DMA_STATUS_BAD_CHANNEL;
415         }
416
417         p_dma_ch->int_enable = 0;
418
419         control = mfdcr(DCRN_DMACR0 + (dmanr * 0x8));
420         control &= ~DMA_CIE_ENABLE;     /* Channel Interrupt Enable */
421         mtdcr(DCRN_DMACR0 + (dmanr * 0x8), control);
422
423         return DMA_STATUS_GOOD;
424 }
425
426 /*
427  * Configures a DMA channel, including the peripheral bus width, if a
428  * peripheral is attached to the channel, the polarity of the DMAReq and
429  * DMAAck signals, etc.  This information should really be setup by the boot
430  * code, since most likely the configuration won't change dynamically.
431  * If the kernel has to call this function, it's recommended that it's
432  * called from platform specific init code.  The driver should not need to
433  * call this function.
434  */
435 int
436 ppc4xx_init_dma_channel(unsigned int dmanr, ppc_dma_ch_t * p_init)
437 {
438         unsigned int polarity;
439         uint32_t control = 0;
440         ppc_dma_ch_t *p_dma_ch = &dma_channels[dmanr];
441
442         DMA_MODE_READ = (unsigned long) DMA_TD; /* Peripheral to Memory */
443         DMA_MODE_WRITE = 0;     /* Memory to Peripheral */
444
445         if (!p_init) {
446                 printk("ppc4xx_init_dma_channel: NULL p_init\n");
447                 return DMA_STATUS_NULL_POINTER;
448         }
449
450         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
451                 printk("ppc4xx_init_dma_channel: bad channel %d\n", dmanr);
452                 return DMA_STATUS_BAD_CHANNEL;
453         }
454
455 #if DCRN_POL > 0
456         polarity = mfdcr(DCRN_POL);
457 #else
458         polarity = 0;
459 #endif
460
461         /* Setup the control register based on the values passed to
462          * us in p_init.  Then, over-write the control register with this
463          * new value.
464          */
465         control |= SET_DMA_CONTROL;
466
467         /* clear all polarity signals and then "or" in new signal levels */
468         polarity &= ~GET_DMA_POLARITY(dmanr);
469         polarity |= p_init->polarity;
470 #if DCRN_POL > 0
471         mtdcr(DCRN_POL, polarity);
472 #endif
473         mtdcr(DCRN_DMACR0 + (dmanr * 0x8), control);
474
475         /* save these values in our dma channel structure */
476         memcpy(p_dma_ch, p_init, sizeof (ppc_dma_ch_t));
477
478         /*
479          * The peripheral width values written in the control register are:
480          *   PW_8                 0
481          *   PW_16                1
482          *   PW_32                2
483          *   PW_64                3
484          *
485          *   Since the DMA count register takes the number of "transfers",
486          *   we need to divide the count sent to us in certain
487          *   functions by the appropriate number.  It so happens that our
488          *   right shift value is equal to the peripheral width value.
489          */
490         p_dma_ch->shift = p_init->pwidth;
491
492         /*
493          * Save the control word for easy access.
494          */
495         p_dma_ch->control = control;
496
497         mtdcr(DCRN_DMASR, 0xffffffff);  /* clear status register */
498         return DMA_STATUS_GOOD;
499 }
500
501 /*
502  * This function returns the channel configuration.
503  */
504 int
505 ppc4xx_get_channel_config(unsigned int dmanr, ppc_dma_ch_t * p_dma_ch)
506 {
507         unsigned int polarity;
508         unsigned int control;
509
510         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
511                 printk("ppc4xx_get_channel_config: bad channel %d\n", dmanr);
512                 return DMA_STATUS_BAD_CHANNEL;
513         }
514
515         memcpy(p_dma_ch, &dma_channels[dmanr], sizeof (ppc_dma_ch_t));
516
517 #if DCRN_POL > 0
518         polarity = mfdcr(DCRN_POL);
519 #else
520         polarity = 0;
521 #endif
522
523         p_dma_ch->polarity = polarity & GET_DMA_POLARITY(dmanr);
524         control = mfdcr(DCRN_DMACR0 + (dmanr * 0x8));
525
526         p_dma_ch->cp = GET_DMA_PRIORITY(control);
527         p_dma_ch->pwidth = GET_DMA_PW(control);
528         p_dma_ch->psc = GET_DMA_PSC(control);
529         p_dma_ch->pwc = GET_DMA_PWC(control);
530         p_dma_ch->phc = GET_DMA_PHC(control);
531         p_dma_ch->ce = GET_DMA_CE_ENABLE(control);
532         p_dma_ch->int_enable = GET_DMA_CIE_ENABLE(control);
533         p_dma_ch->shift = GET_DMA_PW(control);
534
535 #ifdef CONFIG_PPC4xx_EDMA
536         p_dma_ch->pf = GET_DMA_PREFETCH(control);
537 #else
538         p_dma_ch->ch_enable = GET_DMA_CH(control);
539         p_dma_ch->ece_enable = GET_DMA_ECE(control);
540         p_dma_ch->tcd_disable = GET_DMA_TCD(control);
541 #endif
542         return DMA_STATUS_GOOD;
543 }
544
545 /*
546  * Sets the priority for the DMA channel dmanr.
547  * Since this is setup by the hardware init function, this function
548  * can be used to dynamically change the priority of a channel.
549  *
550  * Acceptable priorities:
551  *
552  * PRIORITY_LOW
553  * PRIORITY_MID_LOW
554  * PRIORITY_MID_HIGH
555  * PRIORITY_HIGH
556  *
557  */
558 int
559 ppc4xx_set_channel_priority(unsigned int dmanr, unsigned int priority)
560 {
561         unsigned int control;
562
563         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
564                 printk("ppc4xx_set_channel_priority: bad channel %d\n", dmanr);
565                 return DMA_STATUS_BAD_CHANNEL;
566         }
567
568         if ((priority != PRIORITY_LOW) &&
569             (priority != PRIORITY_MID_LOW) &&
570             (priority != PRIORITY_MID_HIGH) && (priority != PRIORITY_HIGH)) {
571                 printk("ppc4xx_set_channel_priority: bad priority: 0x%x\n", priority);
572         }
573
574         control = mfdcr(DCRN_DMACR0 + (dmanr * 0x8));
575         control |= SET_DMA_PRIORITY(priority);
576         mtdcr(DCRN_DMACR0 + (dmanr * 0x8), control);
577
578         return DMA_STATUS_GOOD;
579 }
580
581 /*
582  * Returns the width of the peripheral attached to this channel. This assumes
583  * that someone who knows the hardware configuration, boot code or some other
584  * init code, already set the width.
585  *
586  * The return value is one of:
587  *   PW_8
588  *   PW_16
589  *   PW_32
590  *   PW_64
591  *
592  *   The function returns 0 on error.
593  */
594 unsigned int
595 ppc4xx_get_peripheral_width(unsigned int dmanr)
596 {
597         unsigned int control;
598
599         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
600                 printk("ppc4xx_get_peripheral_width: bad channel %d\n", dmanr);
601                 return DMA_STATUS_BAD_CHANNEL;
602         }
603
604         control = mfdcr(DCRN_DMACR0 + (dmanr * 0x8));
605
606         return (GET_DMA_PW(control));
607 }
608
609 /*
610  * Clears the channel status bits
611  */
612 int
613 ppc4xx_clr_dma_status(unsigned int dmanr)
614 {
615         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
616                 printk(KERN_ERR "ppc4xx_clr_dma_status: bad channel: %d\n", dmanr);
617                 return DMA_STATUS_BAD_CHANNEL;
618         }
619         mtdcr(DCRN_DMASR, ((u32)DMA_CH0_ERR | (u32)DMA_CS0 | (u32)DMA_TS0) >> dmanr);
620         return DMA_STATUS_GOOD;
621 }
622
623 #ifdef CONFIG_PPC4xx_EDMA
624 /*
625  * Enables the burst on the channel (BTEN bit in the control/count register)
626  * Note:
627  * For scatter/gather dma, this function MUST be called before the
628  * ppc4xx_alloc_dma_handle() func as the chan count register is copied into the
629  * sgl list and used as each sgl element is added.
630  */
631 int
632 ppc4xx_enable_burst(unsigned int dmanr)
633 {
634         unsigned int ctc;
635         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
636                 printk(KERN_ERR "ppc4xx_enable_burst: bad channel: %d\n", dmanr);
637                 return DMA_STATUS_BAD_CHANNEL;
638         }
639         ctc = mfdcr(DCRN_DMACT0 + (dmanr * 0x8)) | DMA_CTC_BTEN;
640         mtdcr(DCRN_DMACT0 + (dmanr * 0x8), ctc);
641         return DMA_STATUS_GOOD;
642 }
643 /*
644  * Disables the burst on the channel (BTEN bit in the control/count register)
645  * Note:
646  * For scatter/gather dma, this function MUST be called before the
647  * ppc4xx_alloc_dma_handle() func as the chan count register is copied into the
648  * sgl list and used as each sgl element is added.
649  */
650 int
651 ppc4xx_disable_burst(unsigned int dmanr)
652 {
653         unsigned int ctc;
654         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
655                 printk(KERN_ERR "ppc4xx_disable_burst: bad channel: %d\n", dmanr);
656                 return DMA_STATUS_BAD_CHANNEL;
657         }
658         ctc = mfdcr(DCRN_DMACT0 + (dmanr * 0x8)) &~ DMA_CTC_BTEN;
659         mtdcr(DCRN_DMACT0 + (dmanr * 0x8), ctc);
660         return DMA_STATUS_GOOD;
661 }
662 /*
663  * Sets the burst size (number of peripheral widths) for the channel
664  * (BSIZ bits in the control/count register))
665  * must be one of:
666  *    DMA_CTC_BSIZ_2
667  *    DMA_CTC_BSIZ_4
668  *    DMA_CTC_BSIZ_8
669  *    DMA_CTC_BSIZ_16
670  * Note:
671  * For scatter/gather dma, this function MUST be called before the
672  * ppc4xx_alloc_dma_handle() func as the chan count register is copied into the
673  * sgl list and used as each sgl element is added.
674  */
675 int
676 ppc4xx_set_burst_size(unsigned int dmanr, unsigned int bsize)
677 {
678         unsigned int ctc;
679         if (dmanr >= MAX_PPC4xx_DMA_CHANNELS) {
680                 printk(KERN_ERR "ppc4xx_set_burst_size: bad channel: %d\n", dmanr);
681                 return DMA_STATUS_BAD_CHANNEL;
682         }
683         ctc = mfdcr(DCRN_DMACT0 + (dmanr * 0x8)) &~ DMA_CTC_BSIZ_MSK;
684         ctc |= (bsize & DMA_CTC_BSIZ_MSK);
685         mtdcr(DCRN_DMACT0 + (dmanr * 0x8), ctc);
686         return DMA_STATUS_GOOD;
687 }
688
689 EXPORT_SYMBOL(ppc4xx_enable_burst);
690 EXPORT_SYMBOL(ppc4xx_disable_burst);
691 EXPORT_SYMBOL(ppc4xx_set_burst_size);
692 #endif /* CONFIG_PPC4xx_EDMA */
693
694 EXPORT_SYMBOL(ppc4xx_init_dma_channel);
695 EXPORT_SYMBOL(ppc4xx_get_channel_config);
696 EXPORT_SYMBOL(ppc4xx_set_channel_priority);
697 EXPORT_SYMBOL(ppc4xx_get_peripheral_width);
698 EXPORT_SYMBOL(dma_channels);
699 EXPORT_SYMBOL(ppc4xx_set_src_addr);
700 EXPORT_SYMBOL(ppc4xx_set_dst_addr);
701 EXPORT_SYMBOL(ppc4xx_set_dma_addr);
702 EXPORT_SYMBOL(ppc4xx_set_dma_addr2);
703 EXPORT_SYMBOL(ppc4xx_enable_dma);
704 EXPORT_SYMBOL(ppc4xx_disable_dma);
705 EXPORT_SYMBOL(ppc4xx_set_dma_mode);
706 EXPORT_SYMBOL(ppc4xx_set_dma_count);
707 EXPORT_SYMBOL(ppc4xx_get_dma_residue);
708 EXPORT_SYMBOL(ppc4xx_enable_dma_interrupt);
709 EXPORT_SYMBOL(ppc4xx_disable_dma_interrupt);
710 EXPORT_SYMBOL(ppc4xx_get_dma_status);
711 EXPORT_SYMBOL(ppc4xx_clr_dma_status);
712