1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/clk.h>
17#include <linux/err.h>
18#include <linux/io.h>
19#include <linux/interrupt.h>
20#include <linux/completion.h>
21#include <mach/dma.h>
22
23#define MSM_DMOV_CHANNEL_COUNT 16
24
25enum {
26 MSM_DMOV_PRINT_ERRORS = 1,
27 MSM_DMOV_PRINT_IO = 2,
28 MSM_DMOV_PRINT_FLOW = 4
29};
30
31static DEFINE_SPINLOCK(msm_dmov_lock);
32static struct clk *msm_dmov_clk;
33static unsigned int channel_active;
34static struct list_head ready_commands[MSM_DMOV_CHANNEL_COUNT];
35static struct list_head active_commands[MSM_DMOV_CHANNEL_COUNT];
36unsigned int msm_dmov_print_mask = MSM_DMOV_PRINT_ERRORS;
37
38#define MSM_DMOV_DPRINTF(mask, format, args...) \
39 do { \
40 if ((mask) & msm_dmov_print_mask) \
41 printk(KERN_ERR format, args); \
42 } while (0)
43#define PRINT_ERROR(format, args...) \
44 MSM_DMOV_DPRINTF(MSM_DMOV_PRINT_ERRORS, format, args);
45#define PRINT_IO(format, args...) \
46 MSM_DMOV_DPRINTF(MSM_DMOV_PRINT_IO, format, args);
47#define PRINT_FLOW(format, args...) \
48 MSM_DMOV_DPRINTF(MSM_DMOV_PRINT_FLOW, format, args);
49
50void msm_dmov_stop_cmd(unsigned id, struct msm_dmov_cmd *cmd, int graceful)
51{
52 writel((graceful << 31), DMOV_FLUSH0(id));
53}
54
55void msm_dmov_enqueue_cmd(unsigned id, struct msm_dmov_cmd *cmd)
56{
57 unsigned long irq_flags;
58 unsigned int status;
59
60 spin_lock_irqsave(&msm_dmov_lock, irq_flags);
61 if (!channel_active)
62 clk_enable(msm_dmov_clk);
63 dsb();
64 status = readl(DMOV_STATUS(id));
65 if (list_empty(&ready_commands[id]) &&
66 (status & DMOV_STATUS_CMD_PTR_RDY)) {
67#if 0
68 if (list_empty(&active_commands[id])) {
69 PRINT_FLOW("msm_dmov_enqueue_cmd(%d), enable interrupt\n", id);
70 writel(DMOV_CONFIG_IRQ_EN, DMOV_CONFIG(id));
71 }
72#endif
73 if (cmd->execute_func)
74 cmd->execute_func(cmd);
75 PRINT_IO("msm_dmov_enqueue_cmd(%d), start command, status %x\n", id, status);
76 list_add_tail(&cmd->list, &active_commands[id]);
77 if (!channel_active)
78 enable_irq(INT_ADM_AARM);
79 channel_active |= 1U << id;
80 writel(cmd->cmdptr, DMOV_CMD_PTR(id));
81 } else {
82 if (!channel_active)
83 clk_disable(msm_dmov_clk);
84 if (list_empty(&active_commands[id]))
85 PRINT_ERROR("msm_dmov_enqueue_cmd(%d), error datamover stalled, status %x\n", id, status);
86
87 PRINT_IO("msm_dmov_enqueue_cmd(%d), enqueue command, status %x\n", id, status);
88 list_add_tail(&cmd->list, &ready_commands[id]);
89 }
90 spin_unlock_irqrestore(&msm_dmov_lock, irq_flags);
91}
92
93struct msm_dmov_exec_cmdptr_cmd {
94 struct msm_dmov_cmd dmov_cmd;
95 struct completion complete;
96 unsigned id;
97 unsigned int result;
98 struct msm_dmov_errdata err;
99};
100
101static void
102dmov_exec_cmdptr_complete_func(struct msm_dmov_cmd *_cmd,
103 unsigned int result,
104 struct msm_dmov_errdata *err)
105{
106 struct msm_dmov_exec_cmdptr_cmd *cmd = container_of(_cmd, struct msm_dmov_exec_cmdptr_cmd, dmov_cmd);
107 cmd->result = result;
108 if (result != 0x80000002 && err)
109 memcpy(&cmd->err, err, sizeof(struct msm_dmov_errdata));
110
111 complete(&cmd->complete);
112}
113
114int msm_dmov_exec_cmd(unsigned id, unsigned int cmdptr)
115{
116 struct msm_dmov_exec_cmdptr_cmd cmd;
117
118 PRINT_FLOW("dmov_exec_cmdptr(%d, %x)\n", id, cmdptr);
119
120 cmd.dmov_cmd.cmdptr = cmdptr;
121 cmd.dmov_cmd.complete_func = dmov_exec_cmdptr_complete_func;
122 cmd.dmov_cmd.execute_func = NULL;
123 cmd.id = id;
124 init_completion(&cmd.complete);
125
126 msm_dmov_enqueue_cmd(id, &cmd.dmov_cmd);
127 wait_for_completion(&cmd.complete);
128
129 if (cmd.result != 0x80000002) {
130 PRINT_ERROR("dmov_exec_cmdptr(%d): ERROR, result: %x\n", id, cmd.result);
131 PRINT_ERROR("dmov_exec_cmdptr(%d): flush: %x %x %x %x\n",
132 id, cmd.err.flush[0], cmd.err.flush[1], cmd.err.flush[2], cmd.err.flush[3]);
133 return -EIO;
134 }
135 PRINT_FLOW("dmov_exec_cmdptr(%d, %x) done\n", id, cmdptr);
136 return 0;
137}
138
139
140static irqreturn_t msm_datamover_irq_handler(int irq, void *dev_id)
141{
142 unsigned int int_status, mask, id;
143 unsigned long irq_flags;
144 unsigned int ch_status;
145 unsigned int ch_result;
146 struct msm_dmov_cmd *cmd;
147
148 spin_lock_irqsave(&msm_dmov_lock, irq_flags);
149
150 int_status = readl(DMOV_ISR);
151 PRINT_FLOW("msm_datamover_irq_handler: DMOV_ISR %x\n", int_status);
152
153 while (int_status) {
154 mask = int_status & -int_status;
155 id = fls(mask) - 1;
156 PRINT_FLOW("msm_datamover_irq_handler %08x %08x id %d\n", int_status, mask, id);
157 int_status &= ~mask;
158 ch_status = readl(DMOV_STATUS(id));
159 if (!(ch_status & DMOV_STATUS_RSLT_VALID)) {
160 PRINT_FLOW("msm_datamover_irq_handler id %d, result not valid %x\n", id, ch_status);
161 continue;
162 }
163 do {
164 ch_result = readl(DMOV_RSLT(id));
165 if (list_empty(&active_commands[id])) {
166 PRINT_ERROR("msm_datamover_irq_handler id %d, got result "
167 "with no active command, status %x, result %x\n",
168 id, ch_status, ch_result);
169 cmd = NULL;
170 } else
171 cmd = list_entry(active_commands[id].next, typeof(*cmd), list);
172 PRINT_FLOW("msm_datamover_irq_handler id %d, status %x, result %x\n", id, ch_status, ch_result);
173 if (ch_result & DMOV_RSLT_DONE) {
174 PRINT_FLOW("msm_datamover_irq_handler id %d, status %x\n",
175 id, ch_status);
176 PRINT_IO("msm_datamover_irq_handler id %d, got result "
177 "for %p, result %x\n", id, cmd, ch_result);
178 if (cmd) {
179 list_del(&cmd->list);
180 dsb();
181 cmd->complete_func(cmd, ch_result, NULL);
182 }
183 }
184 if (ch_result & DMOV_RSLT_FLUSH) {
185 struct msm_dmov_errdata errdata;
186
187 errdata.flush[0] = readl(DMOV_FLUSH0(id));
188 errdata.flush[1] = readl(DMOV_FLUSH1(id));
189 errdata.flush[2] = readl(DMOV_FLUSH2(id));
190 errdata.flush[3] = readl(DMOV_FLUSH3(id));
191 errdata.flush[4] = readl(DMOV_FLUSH4(id));
192 errdata.flush[5] = readl(DMOV_FLUSH5(id));
193 PRINT_FLOW("msm_datamover_irq_handler id %d, status %x\n", id, ch_status);
194 PRINT_FLOW("msm_datamover_irq_handler id %d, flush, result %x, flush0 %x\n", id, ch_result, errdata.flush[0]);
195 if (cmd) {
196 list_del(&cmd->list);
197 dsb();
198 cmd->complete_func(cmd, ch_result, &errdata);
199 }
200 }
201 if (ch_result & DMOV_RSLT_ERROR) {
202 struct msm_dmov_errdata errdata;
203
204 errdata.flush[0] = readl(DMOV_FLUSH0(id));
205 errdata.flush[1] = readl(DMOV_FLUSH1(id));
206 errdata.flush[2] = readl(DMOV_FLUSH2(id));
207 errdata.flush[3] = readl(DMOV_FLUSH3(id));
208 errdata.flush[4] = readl(DMOV_FLUSH4(id));
209 errdata.flush[5] = readl(DMOV_FLUSH5(id));
210
211 PRINT_ERROR("msm_datamover_irq_handler id %d, status %x\n", id, ch_status);
212 PRINT_ERROR("msm_datamover_irq_handler id %d, error, result %x, flush0 %x\n", id, ch_result, errdata.flush[0]);
213 if (cmd) {
214 list_del(&cmd->list);
215 dsb();
216 cmd->complete_func(cmd, ch_result, &errdata);
217 }
218
219
220 writel(0, DMOV_FLUSH0(id));
221 }
222 ch_status = readl(DMOV_STATUS(id));
223 PRINT_FLOW("msm_datamover_irq_handler id %d, status %x\n", id, ch_status);
224 if ((ch_status & DMOV_STATUS_CMD_PTR_RDY) && !list_empty(&ready_commands[id])) {
225 cmd = list_entry(ready_commands[id].next, typeof(*cmd), list);
226 list_del(&cmd->list);
227 list_add_tail(&cmd->list, &active_commands[id]);
228 if (cmd->execute_func)
229 cmd->execute_func(cmd);
230 PRINT_FLOW("msm_datamover_irq_handler id %d, start command\n", id);
231 writel(cmd->cmdptr, DMOV_CMD_PTR(id));
232 }
233 } while (ch_status & DMOV_STATUS_RSLT_VALID);
234 if (list_empty(&active_commands[id]) && list_empty(&ready_commands[id]))
235 channel_active &= ~(1U << id);
236 PRINT_FLOW("msm_datamover_irq_handler id %d, status %x\n", id, ch_status);
237 }
238
239 if (!channel_active) {
240 disable_irq_nosync(INT_ADM_AARM);
241 clk_disable(msm_dmov_clk);
242 }
243
244 spin_unlock_irqrestore(&msm_dmov_lock, irq_flags);
245 return IRQ_HANDLED;
246}
247
248static int __init msm_init_datamover(void)
249{
250 int i;
251 int ret;
252 struct clk *clk;
253
254 for (i = 0; i < MSM_DMOV_CHANNEL_COUNT; i++) {
255 INIT_LIST_HEAD(&ready_commands[i]);
256 INIT_LIST_HEAD(&active_commands[i]);
257 writel(DMOV_CONFIG_IRQ_EN | DMOV_CONFIG_FORCE_TOP_PTR_RSLT | DMOV_CONFIG_FORCE_FLUSH_RSLT, DMOV_CONFIG(i));
258 }
259 clk = clk_get(NULL, "adm_clk");
260 if (IS_ERR(clk))
261 return PTR_ERR(clk);
262 msm_dmov_clk = clk;
263 ret = request_irq(INT_ADM_AARM, msm_datamover_irq_handler, 0, "msmdatamover", NULL);
264 if (ret)
265 return ret;
266 disable_irq(INT_ADM_AARM);
267 return 0;
268}
269
270arch_initcall(msm_init_datamover);
271
272
