davinci: DM644x: NAND: update partitioning
[linux-2.6] / arch / arm / mach-davinci / dma.c
1 /*
2  * EDMA3 support for DaVinci
3  *
4  * Copyright (C) 2006-2009 Texas Instruments.
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 as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/interrupt.h>
25 #include <linux/platform_device.h>
26 #include <linux/spinlock.h>
27 #include <linux/compiler.h>
28 #include <linux/io.h>
29
30 #include <mach/cputype.h>
31 #include <mach/memory.h>
32 #include <mach/hardware.h>
33 #include <mach/irqs.h>
34 #include <mach/edma.h>
35 #include <mach/mux.h>
36
37
38 /* Offsets matching "struct edmacc_param" */
39 #define PARM_OPT                0x00
40 #define PARM_SRC                0x04
41 #define PARM_A_B_CNT            0x08
42 #define PARM_DST                0x0c
43 #define PARM_SRC_DST_BIDX       0x10
44 #define PARM_LINK_BCNTRLD       0x14
45 #define PARM_SRC_DST_CIDX       0x18
46 #define PARM_CCNT               0x1c
47
48 #define PARM_SIZE               0x20
49
50 /* Offsets for EDMA CC global channel registers and their shadows */
51 #define SH_ER           0x00    /* 64 bits */
52 #define SH_ECR          0x08    /* 64 bits */
53 #define SH_ESR          0x10    /* 64 bits */
54 #define SH_CER          0x18    /* 64 bits */
55 #define SH_EER          0x20    /* 64 bits */
56 #define SH_EECR         0x28    /* 64 bits */
57 #define SH_EESR         0x30    /* 64 bits */
58 #define SH_SER          0x38    /* 64 bits */
59 #define SH_SECR         0x40    /* 64 bits */
60 #define SH_IER          0x50    /* 64 bits */
61 #define SH_IECR         0x58    /* 64 bits */
62 #define SH_IESR         0x60    /* 64 bits */
63 #define SH_IPR          0x68    /* 64 bits */
64 #define SH_ICR          0x70    /* 64 bits */
65 #define SH_IEVAL        0x78
66 #define SH_QER          0x80
67 #define SH_QEER         0x84
68 #define SH_QEECR        0x88
69 #define SH_QEESR        0x8c
70 #define SH_QSER         0x90
71 #define SH_QSECR        0x94
72 #define SH_SIZE         0x200
73
74 /* Offsets for EDMA CC global registers */
75 #define EDMA_REV        0x0000
76 #define EDMA_CCCFG      0x0004
77 #define EDMA_QCHMAP     0x0200  /* 8 registers */
78 #define EDMA_DMAQNUM    0x0240  /* 8 registers (4 on OMAP-L1xx) */
79 #define EDMA_QDMAQNUM   0x0260
80 #define EDMA_QUETCMAP   0x0280
81 #define EDMA_QUEPRI     0x0284
82 #define EDMA_EMR        0x0300  /* 64 bits */
83 #define EDMA_EMCR       0x0308  /* 64 bits */
84 #define EDMA_QEMR       0x0310
85 #define EDMA_QEMCR      0x0314
86 #define EDMA_CCERR      0x0318
87 #define EDMA_CCERRCLR   0x031c
88 #define EDMA_EEVAL      0x0320
89 #define EDMA_DRAE       0x0340  /* 4 x 64 bits*/
90 #define EDMA_QRAE       0x0380  /* 4 registers */
91 #define EDMA_QUEEVTENTRY        0x0400  /* 2 x 16 registers */
92 #define EDMA_QSTAT      0x0600  /* 2 registers */
93 #define EDMA_QWMTHRA    0x0620
94 #define EDMA_QWMTHRB    0x0624
95 #define EDMA_CCSTAT     0x0640
96
97 #define EDMA_M          0x1000  /* global channel registers */
98 #define EDMA_ECR        0x1008
99 #define EDMA_ECRH       0x100C
100 #define EDMA_SHADOW0    0x2000  /* 4 regions shadowing global channels */
101 #define EDMA_PARM       0x4000  /* 128 param entries */
102
103 #define DAVINCI_DMA_3PCC_BASE   0x01C00000
104
105 #define PARM_OFFSET(param_no)   (EDMA_PARM + ((param_no) << 5))
106
107 #define EDMA_MAX_DMACH           64
108 #define EDMA_MAX_PARAMENTRY     512
109 #define EDMA_MAX_EVQUE            2     /* FIXME too small */
110
111
112 /*****************************************************************************/
113
114 static void __iomem *edmacc_regs_base;
115
116 static inline unsigned int edma_read(int offset)
117 {
118         return (unsigned int)__raw_readl(edmacc_regs_base + offset);
119 }
120
121 static inline void edma_write(int offset, int val)
122 {
123         __raw_writel(val, edmacc_regs_base + offset);
124 }
125 static inline void edma_modify(int offset, unsigned and, unsigned or)
126 {
127         unsigned val = edma_read(offset);
128         val &= and;
129         val |= or;
130         edma_write(offset, val);
131 }
132 static inline void edma_and(int offset, unsigned and)
133 {
134         unsigned val = edma_read(offset);
135         val &= and;
136         edma_write(offset, val);
137 }
138 static inline void edma_or(int offset, unsigned or)
139 {
140         unsigned val = edma_read(offset);
141         val |= or;
142         edma_write(offset, val);
143 }
144 static inline unsigned int edma_read_array(int offset, int i)
145 {
146         return edma_read(offset + (i << 2));
147 }
148 static inline void edma_write_array(int offset, int i, unsigned val)
149 {
150         edma_write(offset + (i << 2), val);
151 }
152 static inline void edma_modify_array(int offset, int i,
153                 unsigned and, unsigned or)
154 {
155         edma_modify(offset + (i << 2), and, or);
156 }
157 static inline void edma_or_array(int offset, int i, unsigned or)
158 {
159         edma_or(offset + (i << 2), or);
160 }
161 static inline void edma_or_array2(int offset, int i, int j, unsigned or)
162 {
163         edma_or(offset + ((i*2 + j) << 2), or);
164 }
165 static inline void edma_write_array2(int offset, int i, int j, unsigned val)
166 {
167         edma_write(offset + ((i*2 + j) << 2), val);
168 }
169 static inline unsigned int edma_shadow0_read(int offset)
170 {
171         return edma_read(EDMA_SHADOW0 + offset);
172 }
173 static inline unsigned int edma_shadow0_read_array(int offset, int i)
174 {
175         return edma_read(EDMA_SHADOW0 + offset + (i << 2));
176 }
177 static inline void edma_shadow0_write(int offset, unsigned val)
178 {
179         edma_write(EDMA_SHADOW0 + offset, val);
180 }
181 static inline void edma_shadow0_write_array(int offset, int i, unsigned val)
182 {
183         edma_write(EDMA_SHADOW0 + offset + (i << 2), val);
184 }
185 static inline unsigned int edma_parm_read(int offset, int param_no)
186 {
187         return edma_read(EDMA_PARM + offset + (param_no << 5));
188 }
189 static inline void edma_parm_write(int offset, int param_no, unsigned val)
190 {
191         edma_write(EDMA_PARM + offset + (param_no << 5), val);
192 }
193 static inline void edma_parm_modify(int offset, int param_no,
194                 unsigned and, unsigned or)
195 {
196         edma_modify(EDMA_PARM + offset + (param_no << 5), and, or);
197 }
198 static inline void edma_parm_and(int offset, int param_no, unsigned and)
199 {
200         edma_and(EDMA_PARM + offset + (param_no << 5), and);
201 }
202 static inline void edma_parm_or(int offset, int param_no, unsigned or)
203 {
204         edma_or(EDMA_PARM + offset + (param_no << 5), or);
205 }
206
207 /*****************************************************************************/
208
209 /* actual number of DMA channels and slots on this silicon */
210 static unsigned num_channels;
211 static unsigned num_slots;
212
213 static struct dma_interrupt_data {
214         void (*callback)(unsigned channel, unsigned short ch_status,
215                          void *data);
216         void *data;
217 } intr_data[EDMA_MAX_DMACH];
218
219 /* The edma_inuse bit for each PaRAM slot is clear unless the
220  * channel is in use ... by ARM or DSP, for QDMA, or whatever.
221  */
222 static DECLARE_BITMAP(edma_inuse, EDMA_MAX_PARAMENTRY);
223
224 /* The edma_noevent bit for each channel is clear unless
225  * it doesn't trigger DMA events on this platform.  It uses a
226  * bit of SOC-specific initialization code.
227  */
228 static DECLARE_BITMAP(edma_noevent, EDMA_MAX_DMACH);
229
230 /* dummy param set used to (re)initialize parameter RAM slots */
231 static const struct edmacc_param dummy_paramset = {
232         .link_bcntrld = 0xffff,
233         .ccnt = 1,
234 };
235
236 static const int __initconst
237 queue_tc_mapping[EDMA_MAX_EVQUE + 1][2] = {
238 /* {event queue no, TC no} */
239         {0, 0},
240         {1, 1},
241         {-1, -1}
242 };
243
244 static const int __initconst
245 queue_priority_mapping[EDMA_MAX_EVQUE + 1][2] = {
246         /* {event queue no, Priority} */
247         {0, 3},
248         {1, 7},
249         {-1, -1}
250 };
251
252 /*****************************************************************************/
253
254 static void map_dmach_queue(unsigned ch_no, enum dma_event_q queue_no)
255 {
256         int bit = (ch_no & 0x7) * 4;
257
258         /* default to low priority queue */
259         if (queue_no == EVENTQ_DEFAULT)
260                 queue_no = EVENTQ_1;
261
262         queue_no &= 7;
263         edma_modify_array(EDMA_DMAQNUM, (ch_no >> 3),
264                         ~(0x7 << bit), queue_no << bit);
265 }
266
267 static void __init map_queue_tc(int queue_no, int tc_no)
268 {
269         int bit = queue_no * 4;
270         edma_modify(EDMA_QUETCMAP, ~(0x7 << bit), ((tc_no & 0x7) << bit));
271 }
272
273 static void __init assign_priority_to_queue(int queue_no, int priority)
274 {
275         int bit = queue_no * 4;
276         edma_modify(EDMA_QUEPRI, ~(0x7 << bit), ((priority & 0x7) << bit));
277 }
278
279 static inline void
280 setup_dma_interrupt(unsigned lch,
281         void (*callback)(unsigned channel, u16 ch_status, void *data),
282         void *data)
283 {
284         if (!callback) {
285                 edma_shadow0_write_array(SH_IECR, lch >> 5,
286                                 (1 << (lch & 0x1f)));
287         }
288
289         intr_data[lch].callback = callback;
290         intr_data[lch].data = data;
291
292         if (callback) {
293                 edma_shadow0_write_array(SH_ICR, lch >> 5,
294                                 (1 << (lch & 0x1f)));
295                 edma_shadow0_write_array(SH_IESR, lch >> 5,
296                                 (1 << (lch & 0x1f)));
297         }
298 }
299
300 /******************************************************************************
301  *
302  * DMA interrupt handler
303  *
304  *****************************************************************************/
305 static irqreturn_t dma_irq_handler(int irq, void *data)
306 {
307         int i;
308         unsigned int cnt = 0;
309
310         dev_dbg(data, "dma_irq_handler\n");
311
312         if ((edma_shadow0_read_array(SH_IPR, 0) == 0)
313             && (edma_shadow0_read_array(SH_IPR, 1) == 0))
314                 return IRQ_NONE;
315
316         while (1) {
317                 int j;
318                 if (edma_shadow0_read_array(SH_IPR, 0))
319                         j = 0;
320                 else if (edma_shadow0_read_array(SH_IPR, 1))
321                         j = 1;
322                 else
323                         break;
324                 dev_dbg(data, "IPR%d %08x\n", j,
325                                 edma_shadow0_read_array(SH_IPR, j));
326                 for (i = 0; i < 32; i++) {
327                         int k = (j << 5) + i;
328                         if (edma_shadow0_read_array(SH_IPR, j) & (1 << i)) {
329                                 /* Clear the corresponding IPR bits */
330                                 edma_shadow0_write_array(SH_ICR, j, (1 << i));
331                                 if (intr_data[k].callback) {
332                                         intr_data[k].callback(k, DMA_COMPLETE,
333                                                 intr_data[k].data);
334                                 }
335                         }
336                 }
337                 cnt++;
338                 if (cnt > 10)
339                         break;
340         }
341         edma_shadow0_write(SH_IEVAL, 1);
342         return IRQ_HANDLED;
343 }
344
345 /******************************************************************************
346  *
347  * DMA error interrupt handler
348  *
349  *****************************************************************************/
350 static irqreturn_t dma_ccerr_handler(int irq, void *data)
351 {
352         int i;
353         unsigned int cnt = 0;
354
355         dev_dbg(data, "dma_ccerr_handler\n");
356
357         if ((edma_read_array(EDMA_EMR, 0) == 0) &&
358             (edma_read_array(EDMA_EMR, 1) == 0) &&
359             (edma_read(EDMA_QEMR) == 0) && (edma_read(EDMA_CCERR) == 0))
360                 return IRQ_NONE;
361
362         while (1) {
363                 int j = -1;
364                 if (edma_read_array(EDMA_EMR, 0))
365                         j = 0;
366                 else if (edma_read_array(EDMA_EMR, 1))
367                         j = 1;
368                 if (j >= 0) {
369                         dev_dbg(data, "EMR%d %08x\n", j,
370                                         edma_read_array(EDMA_EMR, j));
371                         for (i = 0; i < 32; i++) {
372                                 int k = (j << 5) + i;
373                                 if (edma_read_array(EDMA_EMR, j) & (1 << i)) {
374                                         /* Clear the corresponding EMR bits */
375                                         edma_write_array(EDMA_EMCR, j, 1 << i);
376                                         /* Clear any SER */
377                                         edma_shadow0_write_array(SH_SECR, j,
378                                                         (1 << i));
379                                         if (intr_data[k].callback) {
380                                                 intr_data[k].callback(k,
381                                                                 DMA_CC_ERROR,
382                                                                 intr_data
383                                                                 [k].data);
384                                         }
385                                 }
386                         }
387                 } else if (edma_read(EDMA_QEMR)) {
388                         dev_dbg(data, "QEMR %02x\n",
389                                 edma_read(EDMA_QEMR));
390                         for (i = 0; i < 8; i++) {
391                                 if (edma_read(EDMA_QEMR) & (1 << i)) {
392                                         /* Clear the corresponding IPR bits */
393                                         edma_write(EDMA_QEMCR, 1 << i);
394                                         edma_shadow0_write(SH_QSECR, (1 << i));
395
396                                         /* NOTE:  not reported!! */
397                                 }
398                         }
399                 } else if (edma_read(EDMA_CCERR)) {
400                         dev_dbg(data, "CCERR %08x\n",
401                                 edma_read(EDMA_CCERR));
402                         /* FIXME:  CCERR.BIT(16) ignored!  much better
403                          * to just write CCERRCLR with CCERR value...
404                          */
405                         for (i = 0; i < 8; i++) {
406                                 if (edma_read(EDMA_CCERR) & (1 << i)) {
407                                         /* Clear the corresponding IPR bits */
408                                         edma_write(EDMA_CCERRCLR, 1 << i);
409
410                                         /* NOTE:  not reported!! */
411                                 }
412                         }
413                 }
414                 if ((edma_read_array(EDMA_EMR, 0) == 0)
415                     && (edma_read_array(EDMA_EMR, 1) == 0)
416                     && (edma_read(EDMA_QEMR) == 0)
417                     && (edma_read(EDMA_CCERR) == 0)) {
418                         break;
419                 }
420                 cnt++;
421                 if (cnt > 10)
422                         break;
423         }
424         edma_write(EDMA_EEVAL, 1);
425         return IRQ_HANDLED;
426 }
427
428 /******************************************************************************
429  *
430  * Transfer controller error interrupt handlers
431  *
432  *****************************************************************************/
433
434 #define tc_errs_handled false   /* disabled as long as they're NOPs */
435
436 static irqreturn_t dma_tc0err_handler(int irq, void *data)
437 {
438         dev_dbg(data, "dma_tc0err_handler\n");
439         return IRQ_HANDLED;
440 }
441
442 static irqreturn_t dma_tc1err_handler(int irq, void *data)
443 {
444         dev_dbg(data, "dma_tc1err_handler\n");
445         return IRQ_HANDLED;
446 }
447
448 /*-----------------------------------------------------------------------*/
449
450 /* Resource alloc/free:  dma channels, parameter RAM slots */
451
452 /**
453  * edma_alloc_channel - allocate DMA channel and paired parameter RAM
454  * @channel: specific channel to allocate; negative for "any unmapped channel"
455  * @callback: optional; to be issued on DMA completion or errors
456  * @data: passed to callback
457  * @eventq_no: an EVENTQ_* constant, used to choose which Transfer
458  *      Controller (TC) executes requests using this channel.  Use
459  *      EVENTQ_DEFAULT unless you really need a high priority queue.
460  *
461  * This allocates a DMA channel and its associated parameter RAM slot.
462  * The parameter RAM is initialized to hold a dummy transfer.
463  *
464  * Normal use is to pass a specific channel number as @channel, to make
465  * use of hardware events mapped to that channel.  When the channel will
466  * be used only for software triggering or event chaining, channels not
467  * mapped to hardware events (or mapped to unused events) are preferable.
468  *
469  * DMA transfers start from a channel using edma_start(), or by
470  * chaining.  When the transfer described in that channel's parameter RAM
471  * slot completes, that slot's data may be reloaded through a link.
472  *
473  * DMA errors are only reported to the @callback associated with the
474  * channel driving that transfer, but transfer completion callbacks can
475  * be sent to another channel under control of the TCC field in
476  * the option word of the transfer's parameter RAM set.  Drivers must not
477  * use DMA transfer completion callbacks for channels they did not allocate.
478  * (The same applies to TCC codes used in transfer chaining.)
479  *
480  * Returns the number of the channel, else negative errno.
481  */
482 int edma_alloc_channel(int channel,
483                 void (*callback)(unsigned channel, u16 ch_status, void *data),
484                 void *data,
485                 enum dma_event_q eventq_no)
486 {
487         if (channel < 0) {
488                 channel = 0;
489                 for (;;) {
490                         channel = find_next_bit(edma_noevent,
491                                         num_channels, channel);
492                         if (channel == num_channels)
493                                 return -ENOMEM;
494                         if (!test_and_set_bit(channel, edma_inuse))
495                                 break;
496                         channel++;
497                 }
498         } else if (channel >= num_channels) {
499                 return -EINVAL;
500         } else if (test_and_set_bit(channel, edma_inuse)) {
501                 return -EBUSY;
502         }
503
504         /* ensure access through shadow region 0 */
505         edma_or_array2(EDMA_DRAE, 0, channel >> 5, 1 << (channel & 0x1f));
506
507         /* ensure no events are pending */
508         edma_stop(channel);
509         memcpy_toio(edmacc_regs_base + PARM_OFFSET(channel),
510                         &dummy_paramset, PARM_SIZE);
511
512         if (callback)
513                 setup_dma_interrupt(channel, callback, data);
514
515         map_dmach_queue(channel, eventq_no);
516
517         return channel;
518 }
519 EXPORT_SYMBOL(edma_alloc_channel);
520
521
522 /**
523  * edma_free_channel - deallocate DMA channel
524  * @channel: dma channel returned from edma_alloc_channel()
525  *
526  * This deallocates the DMA channel and associated parameter RAM slot
527  * allocated by edma_alloc_channel().
528  *
529  * Callers are responsible for ensuring the channel is inactive, and
530  * will not be reactivated by linking, chaining, or software calls to
531  * edma_start().
532  */
533 void edma_free_channel(unsigned channel)
534 {
535         if (channel >= num_channels)
536                 return;
537
538         setup_dma_interrupt(channel, NULL, NULL);
539         /* REVISIT should probably take out of shadow region 0 */
540
541         memcpy_toio(edmacc_regs_base + PARM_OFFSET(channel),
542                         &dummy_paramset, PARM_SIZE);
543         clear_bit(channel, edma_inuse);
544 }
545 EXPORT_SYMBOL(edma_free_channel);
546
547 /**
548  * edma_alloc_slot - allocate DMA parameter RAM
549  * @slot: specific slot to allocate; negative for "any unused slot"
550  *
551  * This allocates a parameter RAM slot, initializing it to hold a
552  * dummy transfer.  Slots allocated using this routine have not been
553  * mapped to a hardware DMA channel, and will normally be used by
554  * linking to them from a slot associated with a DMA channel.
555  *
556  * Normal use is to pass EDMA_SLOT_ANY as the @slot, but specific
557  * slots may be allocated on behalf of DSP firmware.
558  *
559  * Returns the number of the slot, else negative errno.
560  */
561 int edma_alloc_slot(int slot)
562 {
563         if (slot < 0) {
564                 slot = num_channels;
565                 for (;;) {
566                         slot = find_next_zero_bit(edma_inuse,
567                                         num_slots, slot);
568                         if (slot == num_slots)
569                                 return -ENOMEM;
570                         if (!test_and_set_bit(slot, edma_inuse))
571                                 break;
572                 }
573         } else if (slot < num_channels || slot >= num_slots) {
574                 return -EINVAL;
575         } else if (test_and_set_bit(slot, edma_inuse)) {
576                 return -EBUSY;
577         }
578
579         memcpy_toio(edmacc_regs_base + PARM_OFFSET(slot),
580                         &dummy_paramset, PARM_SIZE);
581
582         return slot;
583 }
584 EXPORT_SYMBOL(edma_alloc_slot);
585
586 /**
587  * edma_free_slot - deallocate DMA parameter RAM
588  * @slot: parameter RAM slot returned from edma_alloc_slot()
589  *
590  * This deallocates the parameter RAM slot allocated by edma_alloc_slot().
591  * Callers are responsible for ensuring the slot is inactive, and will
592  * not be activated.
593  */
594 void edma_free_slot(unsigned slot)
595 {
596         if (slot < num_channels || slot >= num_slots)
597                 return;
598
599         memcpy_toio(edmacc_regs_base + PARM_OFFSET(slot),
600                         &dummy_paramset, PARM_SIZE);
601         clear_bit(slot, edma_inuse);
602 }
603 EXPORT_SYMBOL(edma_free_slot);
604
605 /*-----------------------------------------------------------------------*/
606
607 /* Parameter RAM operations (i) -- read/write partial slots */
608
609 /**
610  * edma_set_src - set initial DMA source address in parameter RAM slot
611  * @slot: parameter RAM slot being configured
612  * @src_port: physical address of source (memory, controller FIFO, etc)
613  * @addressMode: INCR, except in very rare cases
614  * @fifoWidth: ignored unless @addressMode is FIFO, else specifies the
615  *      width to use when addressing the fifo (e.g. W8BIT, W32BIT)
616  *
617  * Note that the source address is modified during the DMA transfer
618  * according to edma_set_src_index().
619  */
620 void edma_set_src(unsigned slot, dma_addr_t src_port,
621                                 enum address_mode mode, enum fifo_width width)
622 {
623         if (slot < num_slots) {
624                 unsigned int i = edma_parm_read(PARM_OPT, slot);
625
626                 if (mode) {
627                         /* set SAM and program FWID */
628                         i = (i & ~(EDMA_FWID)) | (SAM | ((width & 0x7) << 8));
629                 } else {
630                         /* clear SAM */
631                         i &= ~SAM;
632                 }
633                 edma_parm_write(PARM_OPT, slot, i);
634
635                 /* set the source port address
636                    in source register of param structure */
637                 edma_parm_write(PARM_SRC, slot, src_port);
638         }
639 }
640 EXPORT_SYMBOL(edma_set_src);
641
642 /**
643  * edma_set_dest - set initial DMA destination address in parameter RAM slot
644  * @slot: parameter RAM slot being configured
645  * @dest_port: physical address of destination (memory, controller FIFO, etc)
646  * @addressMode: INCR, except in very rare cases
647  * @fifoWidth: ignored unless @addressMode is FIFO, else specifies the
648  *      width to use when addressing the fifo (e.g. W8BIT, W32BIT)
649  *
650  * Note that the destination address is modified during the DMA transfer
651  * according to edma_set_dest_index().
652  */
653 void edma_set_dest(unsigned slot, dma_addr_t dest_port,
654                                  enum address_mode mode, enum fifo_width width)
655 {
656         if (slot < num_slots) {
657                 unsigned int i = edma_parm_read(PARM_OPT, slot);
658
659                 if (mode) {
660                         /* set DAM and program FWID */
661                         i = (i & ~(EDMA_FWID)) | (DAM | ((width & 0x7) << 8));
662                 } else {
663                         /* clear DAM */
664                         i &= ~DAM;
665                 }
666                 edma_parm_write(PARM_OPT, slot, i);
667                 /* set the destination port address
668                    in dest register of param structure */
669                 edma_parm_write(PARM_DST, slot, dest_port);
670         }
671 }
672 EXPORT_SYMBOL(edma_set_dest);
673
674 /**
675  * edma_get_position - returns the current transfer points
676  * @slot: parameter RAM slot being examined
677  * @src: pointer to source port position
678  * @dst: pointer to destination port position
679  *
680  * Returns current source and destination addresses for a particular
681  * parameter RAM slot.  Its channel should not be active when this is called.
682  */
683 void edma_get_position(unsigned slot, dma_addr_t *src, dma_addr_t *dst)
684 {
685         struct edmacc_param temp;
686
687         edma_read_slot(slot, &temp);
688         if (src != NULL)
689                 *src = temp.src;
690         if (dst != NULL)
691                 *dst = temp.dst;
692 }
693 EXPORT_SYMBOL(edma_get_position);
694
695 /**
696  * edma_set_src_index - configure DMA source address indexing
697  * @slot: parameter RAM slot being configured
698  * @src_bidx: byte offset between source arrays in a frame
699  * @src_cidx: byte offset between source frames in a block
700  *
701  * Offsets are specified to support either contiguous or discontiguous
702  * memory transfers, or repeated access to a hardware register, as needed.
703  * When accessing hardware registers, both offsets are normally zero.
704  */
705 void edma_set_src_index(unsigned slot, s16 src_bidx, s16 src_cidx)
706 {
707         if (slot < num_slots) {
708                 edma_parm_modify(PARM_SRC_DST_BIDX, slot,
709                                 0xffff0000, src_bidx);
710                 edma_parm_modify(PARM_SRC_DST_CIDX, slot,
711                                 0xffff0000, src_cidx);
712         }
713 }
714 EXPORT_SYMBOL(edma_set_src_index);
715
716 /**
717  * edma_set_dest_index - configure DMA destination address indexing
718  * @slot: parameter RAM slot being configured
719  * @dest_bidx: byte offset between destination arrays in a frame
720  * @dest_cidx: byte offset between destination frames in a block
721  *
722  * Offsets are specified to support either contiguous or discontiguous
723  * memory transfers, or repeated access to a hardware register, as needed.
724  * When accessing hardware registers, both offsets are normally zero.
725  */
726 void edma_set_dest_index(unsigned slot, s16 dest_bidx, s16 dest_cidx)
727 {
728         if (slot < num_slots) {
729                 edma_parm_modify(PARM_SRC_DST_BIDX, slot,
730                                 0x0000ffff, dest_bidx << 16);
731                 edma_parm_modify(PARM_SRC_DST_CIDX, slot,
732                                 0x0000ffff, dest_cidx << 16);
733         }
734 }
735 EXPORT_SYMBOL(edma_set_dest_index);
736
737 /**
738  * edma_set_transfer_params - configure DMA transfer parameters
739  * @slot: parameter RAM slot being configured
740  * @acnt: how many bytes per array (at least one)
741  * @bcnt: how many arrays per frame (at least one)
742  * @ccnt: how many frames per block (at least one)
743  * @bcnt_rld: used only for A-Synchronized transfers; this specifies
744  *      the value to reload into bcnt when it decrements to zero
745  * @sync_mode: ASYNC or ABSYNC
746  *
747  * See the EDMA3 documentation to understand how to configure and link
748  * transfers using the fields in PaRAM slots.  If you are not doing it
749  * all at once with edma_write_slot(), you will use this routine
750  * plus two calls each for source and destination, setting the initial
751  * address and saying how to index that address.
752  *
753  * An example of an A-Synchronized transfer is a serial link using a
754  * single word shift register.  In that case, @acnt would be equal to
755  * that word size; the serial controller issues a DMA synchronization
756  * event to transfer each word, and memory access by the DMA transfer
757  * controller will be word-at-a-time.
758  *
759  * An example of an AB-Synchronized transfer is a device using a FIFO.
760  * In that case, @acnt equals the FIFO width and @bcnt equals its depth.
761  * The controller with the FIFO issues DMA synchronization events when
762  * the FIFO threshold is reached, and the DMA transfer controller will
763  * transfer one frame to (or from) the FIFO.  It will probably use
764  * efficient burst modes to access memory.
765  */
766 void edma_set_transfer_params(unsigned slot,
767                 u16 acnt, u16 bcnt, u16 ccnt,
768                 u16 bcnt_rld, enum sync_dimension sync_mode)
769 {
770         if (slot < num_slots) {
771                 edma_parm_modify(PARM_LINK_BCNTRLD, slot,
772                                 0x0000ffff, bcnt_rld << 16);
773                 if (sync_mode == ASYNC)
774                         edma_parm_and(PARM_OPT, slot, ~SYNCDIM);
775                 else
776                         edma_parm_or(PARM_OPT, slot, SYNCDIM);
777                 /* Set the acount, bcount, ccount registers */
778                 edma_parm_write(PARM_A_B_CNT, slot, (bcnt << 16) | acnt);
779                 edma_parm_write(PARM_CCNT, slot, ccnt);
780         }
781 }
782 EXPORT_SYMBOL(edma_set_transfer_params);
783
784 /**
785  * edma_link - link one parameter RAM slot to another
786  * @from: parameter RAM slot originating the link
787  * @to: parameter RAM slot which is the link target
788  *
789  * The originating slot should not be part of any active DMA transfer.
790  */
791 void edma_link(unsigned from, unsigned to)
792 {
793         if (from >= num_slots)
794                 return;
795         if (to >= num_slots)
796                 return;
797         edma_parm_modify(PARM_LINK_BCNTRLD, from, 0xffff0000, PARM_OFFSET(to));
798 }
799 EXPORT_SYMBOL(edma_link);
800
801 /**
802  * edma_unlink - cut link from one parameter RAM slot
803  * @from: parameter RAM slot originating the link
804  *
805  * The originating slot should not be part of any active DMA transfer.
806  * Its link is set to 0xffff.
807  */
808 void edma_unlink(unsigned from)
809 {
810         if (from >= num_slots)
811                 return;
812         edma_parm_or(PARM_LINK_BCNTRLD, from, 0xffff);
813 }
814 EXPORT_SYMBOL(edma_unlink);
815
816 /*-----------------------------------------------------------------------*/
817
818 /* Parameter RAM operations (ii) -- read/write whole parameter sets */
819
820 /**
821  * edma_write_slot - write parameter RAM data for slot
822  * @slot: number of parameter RAM slot being modified
823  * @param: data to be written into parameter RAM slot
824  *
825  * Use this to assign all parameters of a transfer at once.  This
826  * allows more efficient setup of transfers than issuing multiple
827  * calls to set up those parameters in small pieces, and provides
828  * complete control over all transfer options.
829  */
830 void edma_write_slot(unsigned slot, const struct edmacc_param *param)
831 {
832         if (slot >= num_slots)
833                 return;
834         memcpy_toio(edmacc_regs_base + PARM_OFFSET(slot), param, PARM_SIZE);
835 }
836 EXPORT_SYMBOL(edma_write_slot);
837
838 /**
839  * edma_read_slot - read parameter RAM data from slot
840  * @slot: number of parameter RAM slot being copied
841  * @param: where to store copy of parameter RAM data
842  *
843  * Use this to read data from a parameter RAM slot, perhaps to
844  * save them as a template for later reuse.
845  */
846 void edma_read_slot(unsigned slot, struct edmacc_param *param)
847 {
848         if (slot >= num_slots)
849                 return;
850         memcpy_fromio(param, edmacc_regs_base + PARM_OFFSET(slot), PARM_SIZE);
851 }
852 EXPORT_SYMBOL(edma_read_slot);
853
854 /*-----------------------------------------------------------------------*/
855
856 /* Various EDMA channel control operations */
857
858 /**
859  * edma_pause - pause dma on a channel
860  * @channel: on which edma_start() has been called
861  *
862  * This temporarily disables EDMA hardware events on the specified channel,
863  * preventing them from triggering new transfers on its behalf
864  */
865 void edma_pause(unsigned channel)
866 {
867         if (channel < num_channels) {
868                 unsigned int mask = (1 << (channel & 0x1f));
869
870                 edma_shadow0_write_array(SH_EECR, channel >> 5, mask);
871         }
872 }
873 EXPORT_SYMBOL(edma_pause);
874
875 /**
876  * edma_resume - resumes dma on a paused channel
877  * @channel: on which edma_pause() has been called
878  *
879  * This re-enables EDMA hardware events on the specified channel.
880  */
881 void edma_resume(unsigned channel)
882 {
883         if (channel < num_channels) {
884                 unsigned int mask = (1 << (channel & 0x1f));
885
886                 edma_shadow0_write_array(SH_EESR, channel >> 5, mask);
887         }
888 }
889 EXPORT_SYMBOL(edma_resume);
890
891 /**
892  * edma_start - start dma on a channel
893  * @channel: channel being activated
894  *
895  * Channels with event associations will be triggered by their hardware
896  * events, and channels without such associations will be triggered by
897  * software.  (At this writing there is no interface for using software
898  * triggers except with channels that don't support hardware triggers.)
899  *
900  * Returns zero on success, else negative errno.
901  */
902 int edma_start(unsigned channel)
903 {
904         if (channel < num_channels) {
905                 int j = channel >> 5;
906                 unsigned int mask = (1 << (channel & 0x1f));
907
908                 /* EDMA channels without event association */
909                 if (test_bit(channel, edma_noevent)) {
910                         pr_debug("EDMA: ESR%d %08x\n", j,
911                                 edma_shadow0_read_array(SH_ESR, j));
912                         edma_shadow0_write_array(SH_ESR, j, mask);
913                         return 0;
914                 }
915
916                 /* EDMA channel with event association */
917                 pr_debug("EDMA: ER%d %08x\n", j,
918                         edma_shadow0_read_array(SH_ER, j));
919                 /* Clear any pending error */
920                 edma_write_array(EDMA_EMCR, j, mask);
921                 /* Clear any SER */
922                 edma_shadow0_write_array(SH_SECR, j, mask);
923                 edma_shadow0_write_array(SH_EESR, j, mask);
924                 pr_debug("EDMA: EER%d %08x\n", j,
925                         edma_shadow0_read_array(SH_EER, j));
926                 return 0;
927         }
928
929         return -EINVAL;
930 }
931 EXPORT_SYMBOL(edma_start);
932
933 /**
934  * edma_stop - stops dma on the channel passed
935  * @channel: channel being deactivated
936  *
937  * When @lch is a channel, any active transfer is paused and
938  * all pending hardware events are cleared.  The current transfer
939  * may not be resumed, and the channel's Parameter RAM should be
940  * reinitialized before being reused.
941  */
942 void edma_stop(unsigned channel)
943 {
944         if (channel < num_channels) {
945                 int j = channel >> 5;
946                 unsigned int mask = (1 << (channel & 0x1f));
947
948                 edma_shadow0_write_array(SH_EECR, j, mask);
949                 edma_shadow0_write_array(SH_ECR, j, mask);
950                 edma_shadow0_write_array(SH_SECR, j, mask);
951                 edma_write_array(EDMA_EMCR, j, mask);
952
953                 pr_debug("EDMA: EER%d %08x\n", j,
954                                 edma_shadow0_read_array(SH_EER, j));
955
956                 /* REVISIT:  consider guarding against inappropriate event
957                  * chaining by overwriting with dummy_paramset.
958                  */
959         }
960 }
961 EXPORT_SYMBOL(edma_stop);
962
963 /******************************************************************************
964  *
965  * It cleans ParamEntry qand bring back EDMA to initial state if media has
966  * been removed before EDMA has finished.It is usedful for removable media.
967  * Arguments:
968  *      ch_no     - channel no
969  *
970  * Return: zero on success, or corresponding error no on failure
971  *
972  * FIXME this should not be needed ... edma_stop() should suffice.
973  *
974  *****************************************************************************/
975
976 void edma_clean_channel(unsigned channel)
977 {
978         if (channel < num_channels) {
979                 int j = (channel >> 5);
980                 unsigned int mask = 1 << (channel & 0x1f);
981
982                 pr_debug("EDMA: EMR%d %08x\n", j,
983                                 edma_read_array(EDMA_EMR, j));
984                 edma_shadow0_write_array(SH_ECR, j, mask);
985                 /* Clear the corresponding EMR bits */
986                 edma_write_array(EDMA_EMCR, j, mask);
987                 /* Clear any SER */
988                 edma_shadow0_write_array(SH_SECR, j, mask);
989                 edma_write(EDMA_CCERRCLR, (1 << 16) | 0x3);
990         }
991 }
992 EXPORT_SYMBOL(edma_clean_channel);
993
994 /*
995  * edma_clear_event - clear an outstanding event on the DMA channel
996  * Arguments:
997  *      channel - channel number
998  */
999 void edma_clear_event(unsigned channel)
1000 {
1001         if (channel >= num_channels)
1002                 return;
1003         if (channel < 32)
1004                 edma_write(EDMA_ECR, 1 << channel);
1005         else
1006                 edma_write(EDMA_ECRH, 1 << (channel - 32));
1007 }
1008 EXPORT_SYMBOL(edma_clear_event);
1009
1010 /*-----------------------------------------------------------------------*/
1011
1012 static int __init edma_probe(struct platform_device *pdev)
1013 {
1014         struct edma_soc_info    *info = pdev->dev.platform_data;
1015         int                     i;
1016         int                     status;
1017         const s8                *noevent;
1018         int                     irq = 0, err_irq = 0;
1019         struct resource         *r;
1020         resource_size_t         len;
1021
1022         if (!info)
1023                 return -ENODEV;
1024
1025         r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "edma_cc");
1026         if (!r)
1027                 return -ENODEV;
1028
1029         len = r->end - r->start + 1;
1030
1031         r = request_mem_region(r->start, len, r->name);
1032         if (!r)
1033                 return -EBUSY;
1034
1035         edmacc_regs_base = ioremap(r->start, len);
1036         if (!edmacc_regs_base) {
1037                 status = -EBUSY;
1038                 goto fail1;
1039         }
1040
1041         num_channels = min_t(unsigned, info->n_channel, EDMA_MAX_DMACH);
1042         num_slots = min_t(unsigned, info->n_slot, EDMA_MAX_PARAMENTRY);
1043
1044         dev_dbg(&pdev->dev, "DMA REG BASE ADDR=%p\n", edmacc_regs_base);
1045
1046         for (i = 0; i < num_slots; i++)
1047                 memcpy_toio(edmacc_regs_base + PARM_OFFSET(i),
1048                                 &dummy_paramset, PARM_SIZE);
1049
1050         noevent = info->noevent;
1051         if (noevent) {
1052                 while (*noevent != -1)
1053                         set_bit(*noevent++, edma_noevent);
1054         }
1055
1056         irq = platform_get_irq(pdev, 0);
1057         status = request_irq(irq, dma_irq_handler, 0, "edma", &pdev->dev);
1058         if (status < 0) {
1059                 dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1060                         irq, status);
1061                 goto fail;
1062         }
1063
1064         err_irq = platform_get_irq(pdev, 1);
1065         status = request_irq(err_irq, dma_ccerr_handler, 0,
1066                                 "edma_error", &pdev->dev);
1067         if (status < 0) {
1068                 dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1069                         err_irq, status);
1070                 goto fail;
1071         }
1072
1073         if (tc_errs_handled) {
1074                 status = request_irq(IRQ_TCERRINT0, dma_tc0err_handler, 0,
1075                                         "edma_tc0", &pdev->dev);
1076                 if (status < 0) {
1077                         dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1078                                 IRQ_TCERRINT0, status);
1079                         return status;
1080                 }
1081                 status = request_irq(IRQ_TCERRINT, dma_tc1err_handler, 0,
1082                                         "edma_tc1", &pdev->dev);
1083                 if (status < 0) {
1084                         dev_dbg(&pdev->dev, "request_irq %d --> %d\n",
1085                                 IRQ_TCERRINT, status);
1086                         return status;
1087                 }
1088         }
1089
1090         /* Everything lives on transfer controller 1 until otherwise specified.
1091          * This way, long transfers on the low priority queue
1092          * started by the codec engine will not cause audio defects.
1093          */
1094         for (i = 0; i < num_channels; i++)
1095                 map_dmach_queue(i, EVENTQ_1);
1096
1097         /* Event queue to TC mapping */
1098         for (i = 0; queue_tc_mapping[i][0] != -1; i++)
1099                 map_queue_tc(queue_tc_mapping[i][0], queue_tc_mapping[i][1]);
1100
1101         /* Event queue priority mapping */
1102         for (i = 0; queue_priority_mapping[i][0] != -1; i++)
1103                 assign_priority_to_queue(queue_priority_mapping[i][0],
1104                                          queue_priority_mapping[i][1]);
1105
1106         for (i = 0; i < info->n_region; i++) {
1107                 edma_write_array2(EDMA_DRAE, i, 0, 0x0);
1108                 edma_write_array2(EDMA_DRAE, i, 1, 0x0);
1109                 edma_write_array(EDMA_QRAE, i, 0x0);
1110         }
1111
1112         return 0;
1113
1114 fail:
1115         if (err_irq)
1116                 free_irq(err_irq, NULL);
1117         if (irq)
1118                 free_irq(irq, NULL);
1119         iounmap(edmacc_regs_base);
1120 fail1:
1121         release_mem_region(r->start, len);
1122         return status;
1123 }
1124
1125
1126 static struct platform_driver edma_driver = {
1127         .driver.name    = "edma",
1128 };
1129
1130 static int __init edma_init(void)
1131 {
1132         return platform_driver_probe(&edma_driver, edma_probe);
1133 }
1134 arch_initcall(edma_init);
1135