blob: 71a59e196166cc00c4d9d31821f1f1aa3a16f44c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 * 03/03/2004 Sascha Hauer <sascha@saschahauer.de>
11 * initial version heavily inspired by
12 * linux/arch/arm/mach-pxa/dma.c
13 */
14
15#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/kernel.h>
18#include <linux/interrupt.h>
19#include <linux/errno.h>
20
21#include <asm/system.h>
22#include <asm/irq.h>
23#include <asm/hardware.h>
24#include <asm/dma.h>
25
26static struct dma_channel {
27 char *name;
28 void (*irq_handler) (int, void *, struct pt_regs *);
29 void (*err_handler) (int, void *, struct pt_regs *);
30 void *data;
31} dma_channels[11];
32
33/* set err_handler to NULL to have the standard info-only error handler */
34int
35imx_request_dma(char *name, imx_dma_prio prio,
36 void (*irq_handler) (int, void *, struct pt_regs *),
37 void (*err_handler) (int, void *, struct pt_regs *), void *data)
38{
39 unsigned long flags;
40 int i, found = 0;
41
42 /* basic sanity checks */
43 if (!name || !irq_handler)
44 return -EINVAL;
45
46 local_irq_save(flags);
47
48 /* try grabbing a DMA channel with the requested priority */
49 for (i = prio; i < prio + (prio == DMA_PRIO_LOW) ? 8 : 4; i++) {
50 if (!dma_channels[i].name) {
51 found = 1;
52 break;
53 }
54 }
55
56 if (!found) {
57 /* requested prio group is full, try hier priorities */
58 for (i = prio - 1; i >= 0; i--) {
59 if (!dma_channels[i].name) {
60 found = 1;
61 break;
62 }
63 }
64 }
65
66 if (found) {
67 DIMR &= ~(1 << i);
68 dma_channels[i].name = name;
69 dma_channels[i].irq_handler = irq_handler;
70 dma_channels[i].err_handler = err_handler;
71 dma_channels[i].data = data;
72 } else {
73 printk(KERN_WARNING "No more available DMA channels for %s\n",
74 name);
75 i = -ENODEV;
76 }
77
78 local_irq_restore(flags);
79 return i;
80}
81
82void
83imx_free_dma(int dma_ch)
84{
85 unsigned long flags;
86
87 if (!dma_channels[dma_ch].name) {
88 printk(KERN_CRIT
89 "%s: trying to free channel %d which is already freed\n",
90 __FUNCTION__, dma_ch);
91 return;
92 }
93
94 local_irq_save(flags);
95 DIMR &= ~(1 << dma_ch);
96 dma_channels[dma_ch].name = NULL;
97 local_irq_restore(flags);
98}
99
100static irqreturn_t
101dma_err_handler(int irq, void *dev_id, struct pt_regs *regs)
102{
103 int i, disr = DISR;
104 struct dma_channel *channel;
105 unsigned int err_mask = DBTOSR | DRTOSR | DSESR | DBOSR;
106
107 DISR = disr;
108 for (i = 0; i < 11; i++) {
109 channel = &dma_channels[i];
110
111 if ( (err_mask & 1<<i) && channel->name && channel->err_handler) {
112 channel->err_handler(i, channel->data, regs);
113 continue;
114 }
115
116 if (DBTOSR & (1 << i)) {
117 printk(KERN_WARNING
118 "Burst timeout on channel %d (%s)\n",
119 i, channel->name);
120 DBTOSR |= (1 << i);
121 }
122 if (DRTOSR & (1 << i)) {
123 printk(KERN_WARNING
124 "Request timeout on channel %d (%s)\n",
125 i, channel->name);
126 DRTOSR |= (1 << i);
127 }
128 if (DSESR & (1 << i)) {
129 printk(KERN_WARNING
130 "Transfer timeout on channel %d (%s)\n",
131 i, channel->name);
132 DSESR |= (1 << i);
133 }
134 if (DBOSR & (1 << i)) {
135 printk(KERN_WARNING
136 "Buffer overflow timeout on channel %d (%s)\n",
137 i, channel->name);
138 DBOSR |= (1 << i);
139 }
140 }
141 return IRQ_HANDLED;
142}
143
144static irqreturn_t
145dma_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
146{
147 int i, disr = DISR;
148
149 DISR = disr;
150 for (i = 0; i < 11; i++) {
151 if (disr & (1 << i)) {
152 struct dma_channel *channel = &dma_channels[i];
153 if (channel->name && channel->irq_handler) {
154 channel->irq_handler(i, channel->data, regs);
155 } else {
156 /*
157 * IRQ for an unregistered DMA channel:
158 * let's clear the interrupts and disable it.
159 */
160 printk(KERN_WARNING
161 "spurious IRQ for DMA channel %d\n", i);
162 }
163 }
164 }
165 return IRQ_HANDLED;
166}
167
168static int __init
169imx_dma_init(void)
170{
171 int ret;
172
173 /* reset DMA module */
174 DCR = DCR_DRST;
175
176 ret = request_irq(DMA_INT, dma_irq_handler, 0, "DMA", NULL);
177 if (ret) {
178 printk(KERN_CRIT "Wow! Can't register IRQ for DMA\n");
179 return ret;
180 }
181
182 ret = request_irq(DMA_ERR, dma_err_handler, 0, "DMA", NULL);
183 if (ret) {
184 printk(KERN_CRIT "Wow! Can't register ERRIRQ for DMA\n");
185 free_irq(DMA_INT, NULL);
186 }
187
188 /* enable DMA module */
189 DCR = DCR_DEN;
190
191 /* clear all interrupts */
192 DISR = 0x3ff;
193
194 /* enable interrupts */
195 DIMR = 0;
196
197 return ret;
198}
199
200arch_initcall(imx_dma_init);
201
202EXPORT_SYMBOL(imx_request_dma);
203EXPORT_SYMBOL(imx_free_dma);