Merge branch 'upstream'
[linux-2.6] / arch / arm / mach-imx / dma.c
1 /*
2  *  linux/arch/arm/mach-imx/dma.c
3  *
4  *  imx DMA registration and IRQ dispatching
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License version 2 as
8  *  published by the Free Software Foundation.
9  *
10  *  2004-03-03 Sascha Hauer <sascha@saschahauer.de>
11  *             initial version heavily inspired by
12  *             linux/arch/arm/mach-pxa/dma.c
13  *
14  *  2005-04-17 Pavel Pisa <pisa@cmp.felk.cvut.cz>
15  *             Changed to support scatter gather DMA
16  *             by taking Russell's code from RiscPC
17  *
18  */
19
20 #undef DEBUG
21
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/kernel.h>
25 #include <linux/interrupt.h>
26 #include <linux/errno.h>
27
28 #include <asm/system.h>
29 #include <asm/irq.h>
30 #include <asm/hardware.h>
31 #include <asm/dma.h>
32 #include <asm/arch/imx-dma.h>
33
34 struct imx_dma_channel imx_dma_channels[IMX_DMA_CHANNELS];
35
36 /*
37  * imx_dma_sg_next - prepare next chunk for scatter-gather DMA emulation
38  * @dma_ch: i.MX DMA channel number
39  * @lastcount: number of bytes transferred during last transfer
40  *
41  * Functions prepares DMA controller for next sg data chunk transfer.
42  * The @lastcount argument informs function about number of bytes transferred
43  * during last block. Zero value can be used for @lastcount to setup DMA
44  * for the first chunk.
45  */
46 static inline int imx_dma_sg_next(imx_dmach_t dma_ch, unsigned int lastcount)
47 {
48         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
49         unsigned int nextcount;
50         unsigned int nextaddr;
51
52         if (!imxdma->name) {
53                 printk(KERN_CRIT "%s: called for  not allocated channel %d\n",
54                        __FUNCTION__, dma_ch);
55                 return 0;
56         }
57
58         imxdma->resbytes -= lastcount;
59
60         if (!imxdma->sg) {
61                 pr_debug("imxdma%d: no sg data\n", dma_ch);
62                 return 0;
63         }
64
65         imxdma->sgbc += lastcount;
66         if ((imxdma->sgbc >= imxdma->sg->length) || !imxdma->resbytes) {
67                 if ((imxdma->sgcount <= 1) || !imxdma->resbytes) {
68                         pr_debug("imxdma%d: sg transfer limit reached\n",
69                                  dma_ch);
70                         imxdma->sgcount=0;
71                         imxdma->sg = NULL;
72                         return 0;
73                 } else {
74                         imxdma->sgcount--;
75                         imxdma->sg++;
76                         imxdma->sgbc = 0;
77                 }
78         }
79         nextcount = imxdma->sg->length - imxdma->sgbc;
80         nextaddr = imxdma->sg->dma_address + imxdma->sgbc;
81
82         if(imxdma->resbytes < nextcount)
83                 nextcount = imxdma->resbytes;
84
85         if ((imxdma->dma_mode & DMA_MODE_MASK) == DMA_MODE_READ)
86                 DAR(dma_ch) = nextaddr;
87         else
88                 SAR(dma_ch) = nextaddr;
89
90         CNTR(dma_ch) = nextcount;
91         pr_debug("imxdma%d: next sg chunk dst 0x%08x, src 0x%08x, size 0x%08x\n",
92                  dma_ch, DAR(dma_ch), SAR(dma_ch), CNTR(dma_ch));
93
94         return nextcount;
95 }
96
97 /*
98  * imx_dma_setup_sg_base - scatter-gather DMA emulation
99  * @dma_ch: i.MX DMA channel number
100  * @sg: pointer to the scatter-gather list/vector
101  * @sgcount: scatter-gather list hungs count
102  *
103  * Functions sets up i.MX DMA state for emulated scatter-gather transfer
104  * and sets up channel registers to be ready for the first chunk
105  */
106 static int
107 imx_dma_setup_sg_base(imx_dmach_t dma_ch,
108                       struct scatterlist *sg, unsigned int sgcount)
109 {
110         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
111
112         imxdma->sg = sg;
113         imxdma->sgcount = sgcount;
114         imxdma->sgbc = 0;
115         return imx_dma_sg_next(dma_ch, 0);
116 }
117
118 /**
119  * imx_dma_setup_single - setup i.MX DMA channel for linear memory to/from device transfer
120  * @dma_ch: i.MX DMA channel number
121  * @dma_address: the DMA/physical memory address of the linear data block
122  *              to transfer
123  * @dma_length: length of the data block in bytes
124  * @dev_addr: physical device port address
125  * @dmamode: DMA transfer mode, %DMA_MODE_READ from the device to the memory
126  *           or %DMA_MODE_WRITE from memory to the device
127  *
128  * The function setups DMA channel source and destination addresses for transfer
129  * specified by provided parameters. The scatter-gather emulation is disabled,
130  * because linear data block
131  * form the physical address range is transfered.
132  * Return value: if incorrect parameters are provided -%EINVAL.
133  *              Zero indicates success.
134  */
135 int
136 imx_dma_setup_single(imx_dmach_t dma_ch, dma_addr_t dma_address,
137                      unsigned int dma_length, unsigned int dev_addr,
138                      dmamode_t dmamode)
139 {
140         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
141
142         imxdma->sg = NULL;
143         imxdma->sgcount = 0;
144         imxdma->dma_mode = dmamode;
145         imxdma->resbytes = dma_length;
146
147         if (!dma_address) {
148                 printk(KERN_ERR "imxdma%d: imx_dma_setup_single null address\n",
149                        dma_ch);
150                 return -EINVAL;
151         }
152
153         if (!dma_length) {
154                 printk(KERN_ERR "imxdma%d: imx_dma_setup_single zero length\n",
155                        dma_ch);
156                 return -EINVAL;
157         }
158
159         if ((dmamode & DMA_MODE_MASK) == DMA_MODE_READ) {
160                 pr_debug("imxdma%d: mx_dma_setup_single2dev dma_addressg=0x%08x dma_length=%d dev_addr=0x%08x for read\n",
161                         dma_ch, (unsigned int)dma_address, dma_length,
162                         dev_addr);
163                 SAR(dma_ch) = dev_addr;
164                 DAR(dma_ch) = (unsigned int)dma_address;
165         } else if ((dmamode & DMA_MODE_MASK) == DMA_MODE_WRITE) {
166                 pr_debug("imxdma%d: mx_dma_setup_single2dev dma_addressg=0x%08x dma_length=%d dev_addr=0x%08x for write\n",
167                         dma_ch, (unsigned int)dma_address, dma_length,
168                         dev_addr);
169                 SAR(dma_ch) = (unsigned int)dma_address;
170                 DAR(dma_ch) = dev_addr;
171         } else {
172                 printk(KERN_ERR "imxdma%d: imx_dma_setup_single bad dmamode\n",
173                        dma_ch);
174                 return -EINVAL;
175         }
176
177         CNTR(dma_ch) = dma_length;
178
179         return 0;
180 }
181
182 /**
183  * imx_dma_setup_sg - setup i.MX DMA channel SG list to/from device transfer
184  * @dma_ch: i.MX DMA channel number
185  * @sg: pointer to the scatter-gather list/vector
186  * @sgcount: scatter-gather list hungs count
187  * @dma_length: total length of the transfer request in bytes
188  * @dev_addr: physical device port address
189  * @dmamode: DMA transfer mode, %DMA_MODE_READ from the device to the memory
190  *           or %DMA_MODE_WRITE from memory to the device
191  *
192  * The function setups DMA channel state and registers to be ready for transfer
193  * specified by provided parameters. The scatter-gather emulation is set up
194  * according to the parameters.
195  *
196  * The full preparation of the transfer requires setup of more register
197  * by the caller before imx_dma_enable() can be called.
198  *
199  * %BLR(dma_ch) holds transfer burst length in bytes, 0 means 64 bytes
200  *
201  * %RSSR(dma_ch) has to be set to the DMA request line source %DMA_REQ_xxx
202  *
203  * %CCR(dma_ch) has to specify transfer parameters, the next settings is typical
204  * for linear or simple scatter-gather transfers if %DMA_MODE_READ is specified
205  *
206  * %CCR_DMOD_LINEAR | %CCR_DSIZ_32 | %CCR_SMOD_FIFO | %CCR_SSIZ_x
207  *
208  * The typical setup for %DMA_MODE_WRITE is specified by next options combination
209  *
210  * %CCR_SMOD_LINEAR | %CCR_SSIZ_32 | %CCR_DMOD_FIFO | %CCR_DSIZ_x
211  *
212  * Be carefull there and do not mistakenly mix source and target device
213  * port sizes constants, they are really different:
214  * %CCR_SSIZ_8, %CCR_SSIZ_16, %CCR_SSIZ_32,
215  * %CCR_DSIZ_8, %CCR_DSIZ_16, %CCR_DSIZ_32
216  *
217  * Return value: if incorrect parameters are provided -%EINVAL.
218  * Zero indicates success.
219  */
220 int
221 imx_dma_setup_sg(imx_dmach_t dma_ch,
222                  struct scatterlist *sg, unsigned int sgcount, unsigned int dma_length,
223                  unsigned int dev_addr, dmamode_t dmamode)
224 {
225         int res;
226         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
227
228         imxdma->sg = NULL;
229         imxdma->sgcount = 0;
230         imxdma->dma_mode = dmamode;
231         imxdma->resbytes = dma_length;
232
233         if (!sg || !sgcount) {
234                 printk(KERN_ERR "imxdma%d: imx_dma_setup_sg epty sg list\n",
235                        dma_ch);
236                 return -EINVAL;
237         }
238
239         if (!sg->length) {
240                 printk(KERN_ERR "imxdma%d: imx_dma_setup_sg zero length\n",
241                        dma_ch);
242                 return -EINVAL;
243         }
244
245         if ((dmamode & DMA_MODE_MASK) == DMA_MODE_READ) {
246                 pr_debug("imxdma%d: mx_dma_setup_sg2dev sg=%p sgcount=%d total length=%d dev_addr=0x%08x for read\n",
247                         dma_ch, sg, sgcount, dma_length, dev_addr);
248                 SAR(dma_ch) = dev_addr;
249         } else if ((dmamode & DMA_MODE_MASK) == DMA_MODE_WRITE) {
250                 pr_debug("imxdma%d: mx_dma_setup_sg2dev sg=%p sgcount=%d total length=%d dev_addr=0x%08x for write\n",
251                         dma_ch, sg, sgcount, dma_length, dev_addr);
252                 DAR(dma_ch) = dev_addr;
253         } else {
254                 printk(KERN_ERR "imxdma%d: imx_dma_setup_sg bad dmamode\n",
255                        dma_ch);
256                 return -EINVAL;
257         }
258
259         res = imx_dma_setup_sg_base(dma_ch, sg, sgcount);
260         if (res <= 0) {
261                 printk(KERN_ERR "imxdma%d: no sg chunk ready\n", dma_ch);
262                 return -EINVAL;
263         }
264
265         return 0;
266 }
267
268 /**
269  * imx_dma_setup_handlers - setup i.MX DMA channel end and error notification handlers
270  * @dma_ch: i.MX DMA channel number
271  * @irq_handler: the pointer to the function called if the transfer
272  *              ends successfully
273  * @err_handler: the pointer to the function called if the premature
274  *              end caused by error occurs
275  * @data: user specified value to be passed to the handlers
276  */
277 int
278 imx_dma_setup_handlers(imx_dmach_t dma_ch,
279                        void (*irq_handler) (int, void *, struct pt_regs *),
280                        void (*err_handler) (int, void *, struct pt_regs *),
281                        void *data)
282 {
283         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
284         unsigned long flags;
285
286         if (!imxdma->name) {
287                 printk(KERN_CRIT "%s: called for  not allocated channel %d\n",
288                        __FUNCTION__, dma_ch);
289                 return -ENODEV;
290         }
291
292         local_irq_save(flags);
293         DISR = (1 << dma_ch);
294         imxdma->irq_handler = irq_handler;
295         imxdma->err_handler = err_handler;
296         imxdma->data = data;
297         local_irq_restore(flags);
298         return 0;
299 }
300
301 /**
302  * imx_dma_enable - function to start i.MX DMA channel operation
303  * @dma_ch: i.MX DMA channel number
304  *
305  * The channel has to be allocated by driver through imx_dma_request()
306  * or imx_dma_request_by_prio() function.
307  * The transfer parameters has to be set to the channel registers through
308  * call of the imx_dma_setup_single() or imx_dma_setup_sg() function
309  * and registers %BLR(dma_ch), %RSSR(dma_ch) and %CCR(dma_ch) has to
310  * be set prior this function call by the channel user.
311  */
312 void imx_dma_enable(imx_dmach_t dma_ch)
313 {
314         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
315         unsigned long flags;
316
317         pr_debug("imxdma%d: imx_dma_enable\n", dma_ch);
318
319         if (!imxdma->name) {
320                 printk(KERN_CRIT "%s: called for  not allocated channel %d\n",
321                        __FUNCTION__, dma_ch);
322                 return;
323         }
324
325         local_irq_save(flags);
326         DISR = (1 << dma_ch);
327         DIMR &= ~(1 << dma_ch);
328         CCR(dma_ch) |= CCR_CEN;
329         local_irq_restore(flags);
330 }
331
332 /**
333  * imx_dma_disable - stop, finish i.MX DMA channel operatin
334  * @dma_ch: i.MX DMA channel number
335  */
336 void imx_dma_disable(imx_dmach_t dma_ch)
337 {
338         unsigned long flags;
339
340         pr_debug("imxdma%d: imx_dma_disable\n", dma_ch);
341
342         local_irq_save(flags);
343         DIMR |= (1 << dma_ch);
344         CCR(dma_ch) &= ~CCR_CEN;
345         DISR = (1 << dma_ch);
346         local_irq_restore(flags);
347 }
348
349 /**
350  * imx_dma_request - request/allocate specified channel number
351  * @dma_ch: i.MX DMA channel number
352  * @name: the driver/caller own non-%NULL identification
353  */
354 int imx_dma_request(imx_dmach_t dma_ch, const char *name)
355 {
356         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
357         unsigned long flags;
358
359         /* basic sanity checks */
360         if (!name)
361                 return -EINVAL;
362
363         if (dma_ch >= IMX_DMA_CHANNELS) {
364                 printk(KERN_CRIT "%s: called for  non-existed channel %d\n",
365                        __FUNCTION__, dma_ch);
366                 return -EINVAL;
367         }
368
369         local_irq_save(flags);
370         if (imxdma->name) {
371                 local_irq_restore(flags);
372                 return -ENODEV;
373         }
374
375         imxdma->name = name;
376         imxdma->irq_handler = NULL;
377         imxdma->err_handler = NULL;
378         imxdma->data = NULL;
379         imxdma->sg = NULL;
380         local_irq_restore(flags);
381         return 0;
382 }
383
384 /**
385  * imx_dma_free - release previously acquired channel
386  * @dma_ch: i.MX DMA channel number
387  */
388 void imx_dma_free(imx_dmach_t dma_ch)
389 {
390         unsigned long flags;
391         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
392
393         if (!imxdma->name) {
394                 printk(KERN_CRIT
395                        "%s: trying to free channel %d which is already freed\n",
396                        __FUNCTION__, dma_ch);
397                 return;
398         }
399
400         local_irq_save(flags);
401         /* Disable interrupts */
402         DIMR |= (1 << dma_ch);
403         CCR(dma_ch) &= ~CCR_CEN;
404         imxdma->name = NULL;
405         local_irq_restore(flags);
406 }
407
408 /**
409  * imx_dma_request_by_prio - find and request some of free channels best suiting requested priority
410  * @dma_ch: i.MX DMA channel number
411  * @name: the driver/caller own non-%NULL identification
412  * @prio: one of the hardware distinguished priority level:
413  *        %DMA_PRIO_HIGH, %DMA_PRIO_MEDIUM, %DMA_PRIO_LOW
414  *
415  * This function tries to find free channel in the specified priority group
416  * if the priority cannot be achieved it tries to look for free channel
417  * in the higher and then even lower priority groups.
418  *
419  * Return value: If there is no free channel to allocate, -%ENODEV is returned.
420  *               Zero value indicates successful channel allocation.
421  */
422 int
423 imx_dma_request_by_prio(imx_dmach_t * pdma_ch, const char *name,
424                         imx_dma_prio prio)
425 {
426         int i;
427         int best;
428
429         switch (prio) {
430         case (DMA_PRIO_HIGH):
431                 best = 8;
432                 break;
433         case (DMA_PRIO_MEDIUM):
434                 best = 4;
435                 break;
436         case (DMA_PRIO_LOW):
437         default:
438                 best = 0;
439                 break;
440         }
441
442         for (i = best; i < IMX_DMA_CHANNELS; i++) {
443                 if (!imx_dma_request(i, name)) {
444                         *pdma_ch = i;
445                         return 0;
446                 }
447         }
448
449         for (i = best - 1; i >= 0; i--) {
450                 if (!imx_dma_request(i, name)) {
451                         *pdma_ch = i;
452                         return 0;
453                 }
454         }
455
456         printk(KERN_ERR "%s: no free DMA channel found\n", __FUNCTION__);
457
458         return -ENODEV;
459 }
460
461 static irqreturn_t dma_err_handler(int irq, void *dev_id, struct pt_regs *regs)
462 {
463         int i, disr = DISR;
464         struct imx_dma_channel *channel;
465         unsigned int err_mask = DBTOSR | DRTOSR | DSESR | DBOSR;
466
467         DISR = disr;
468         for (i = 0; i < IMX_DMA_CHANNELS; i++) {
469                 channel = &imx_dma_channels[i];
470
471                 if ((err_mask & 1 << i) && channel->name
472                     && channel->err_handler) {
473                         channel->err_handler(i, channel->data, regs);
474                         continue;
475                 }
476
477                 imx_dma_channels[i].sg = NULL;
478
479                 if (DBTOSR & (1 << i)) {
480                         printk(KERN_WARNING
481                                "Burst timeout on channel %d (%s)\n",
482                                i, channel->name);
483                         DBTOSR |= (1 << i);
484                 }
485                 if (DRTOSR & (1 << i)) {
486                         printk(KERN_WARNING
487                                "Request timeout on channel %d (%s)\n",
488                                i, channel->name);
489                         DRTOSR |= (1 << i);
490                 }
491                 if (DSESR & (1 << i)) {
492                         printk(KERN_WARNING
493                                "Transfer timeout on channel %d (%s)\n",
494                                i, channel->name);
495                         DSESR |= (1 << i);
496                 }
497                 if (DBOSR & (1 << i)) {
498                         printk(KERN_WARNING
499                                "Buffer overflow timeout on channel %d (%s)\n",
500                                i, channel->name);
501                         DBOSR |= (1 << i);
502                 }
503         }
504         return IRQ_HANDLED;
505 }
506
507 static irqreturn_t dma_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
508 {
509         int i, disr = DISR;
510
511         pr_debug("imxdma: dma_irq_handler called, disr=0x%08x\n",
512                      disr);
513
514         DISR = disr;
515         for (i = 0; i < IMX_DMA_CHANNELS; i++) {
516                 if (disr & (1 << i)) {
517                         struct imx_dma_channel *channel = &imx_dma_channels[i];
518                         if (channel->name) {
519                                 if (imx_dma_sg_next(i, CNTR(i))) {
520                                         CCR(i) &= ~CCR_CEN;
521                                         mb();
522                                         CCR(i) |= CCR_CEN;
523                                 } else {
524                                         if (channel->irq_handler)
525                                                 channel->irq_handler(i,
526                                                         channel->data, regs);
527                                 }
528                         } else {
529                                 /*
530                                  * IRQ for an unregistered DMA channel:
531                                  * let's clear the interrupts and disable it.
532                                  */
533                                 printk(KERN_WARNING
534                                        "spurious IRQ for DMA channel %d\n", i);
535                         }
536                 }
537         }
538         return IRQ_HANDLED;
539 }
540
541 static int __init imx_dma_init(void)
542 {
543         int ret;
544         int i;
545
546         /* reset DMA module */
547         DCR = DCR_DRST;
548
549         ret = request_irq(DMA_INT, dma_irq_handler, 0, "DMA", NULL);
550         if (ret) {
551                 printk(KERN_CRIT "Wow!  Can't register IRQ for DMA\n");
552                 return ret;
553         }
554
555         ret = request_irq(DMA_ERR, dma_err_handler, 0, "DMA", NULL);
556         if (ret) {
557                 printk(KERN_CRIT "Wow!  Can't register ERRIRQ for DMA\n");
558                 free_irq(DMA_INT, NULL);
559         }
560
561         /* enable DMA module */
562         DCR = DCR_DEN;
563
564         /* clear all interrupts */
565         DISR = (1 << IMX_DMA_CHANNELS) - 1;
566
567         /* enable interrupts */
568         DIMR = (1 << IMX_DMA_CHANNELS) - 1;
569
570         for (i = 0; i < IMX_DMA_CHANNELS; i++) {
571                 imx_dma_channels[i].sg = NULL;
572                 imx_dma_channels[i].dma_num = i;
573         }
574
575         return ret;
576 }
577
578 arch_initcall(imx_dma_init);
579
580 EXPORT_SYMBOL(imx_dma_setup_single);
581 EXPORT_SYMBOL(imx_dma_setup_sg);
582 EXPORT_SYMBOL(imx_dma_setup_handlers);
583 EXPORT_SYMBOL(imx_dma_enable);
584 EXPORT_SYMBOL(imx_dma_disable);
585 EXPORT_SYMBOL(imx_dma_request);
586 EXPORT_SYMBOL(imx_dma_free);
587 EXPORT_SYMBOL(imx_dma_request_by_prio);
588 EXPORT_SYMBOL(imx_dma_channels);