2
* EDMA3 support for DaVinci
4
* Copyright (C) 2006-2009 Texas Instruments.
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.
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.
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.
20
#include <linux/kernel.h>
21
#include <linux/init.h>
22
#include <linux/module.h>
23
#include <linux/interrupt.h>
24
#include <linux/platform_device.h>
26
#include <linux/slab.h>
28
#include <mach/edma.h>
30
/* Offsets matching "struct edmacc_param" */
33
#define PARM_A_B_CNT 0x08
35
#define PARM_SRC_DST_BIDX 0x10
36
#define PARM_LINK_BCNTRLD 0x14
37
#define PARM_SRC_DST_CIDX 0x18
38
#define PARM_CCNT 0x1c
40
#define PARM_SIZE 0x20
42
/* Offsets for EDMA CC global channel registers and their shadows */
43
#define SH_ER 0x00 /* 64 bits */
44
#define SH_ECR 0x08 /* 64 bits */
45
#define SH_ESR 0x10 /* 64 bits */
46
#define SH_CER 0x18 /* 64 bits */
47
#define SH_EER 0x20 /* 64 bits */
48
#define SH_EECR 0x28 /* 64 bits */
49
#define SH_EESR 0x30 /* 64 bits */
50
#define SH_SER 0x38 /* 64 bits */
51
#define SH_SECR 0x40 /* 64 bits */
52
#define SH_IER 0x50 /* 64 bits */
53
#define SH_IECR 0x58 /* 64 bits */
54
#define SH_IESR 0x60 /* 64 bits */
55
#define SH_IPR 0x68 /* 64 bits */
56
#define SH_ICR 0x70 /* 64 bits */
66
/* Offsets for EDMA CC global registers */
67
#define EDMA_REV 0x0000
68
#define EDMA_CCCFG 0x0004
69
#define EDMA_QCHMAP 0x0200 /* 8 registers */
70
#define EDMA_DMAQNUM 0x0240 /* 8 registers (4 on OMAP-L1xx) */
71
#define EDMA_QDMAQNUM 0x0260
72
#define EDMA_QUETCMAP 0x0280
73
#define EDMA_QUEPRI 0x0284
74
#define EDMA_EMR 0x0300 /* 64 bits */
75
#define EDMA_EMCR 0x0308 /* 64 bits */
76
#define EDMA_QEMR 0x0310
77
#define EDMA_QEMCR 0x0314
78
#define EDMA_CCERR 0x0318
79
#define EDMA_CCERRCLR 0x031c
80
#define EDMA_EEVAL 0x0320
81
#define EDMA_DRAE 0x0340 /* 4 x 64 bits*/
82
#define EDMA_QRAE 0x0380 /* 4 registers */
83
#define EDMA_QUEEVTENTRY 0x0400 /* 2 x 16 registers */
84
#define EDMA_QSTAT 0x0600 /* 2 registers */
85
#define EDMA_QWMTHRA 0x0620
86
#define EDMA_QWMTHRB 0x0624
87
#define EDMA_CCSTAT 0x0640
89
#define EDMA_M 0x1000 /* global channel registers */
90
#define EDMA_ECR 0x1008
91
#define EDMA_ECRH 0x100C
92
#define EDMA_SHADOW0 0x2000 /* 4 regions shadowing global channels */
93
#define EDMA_PARM 0x4000 /* 128 param entries */
95
#define PARM_OFFSET(param_no) (EDMA_PARM + ((param_no) << 5))
97
#define EDMA_DCHMAP 0x0100 /* 64 registers */
98
#define CHMAP_EXIST BIT(24)
100
#define EDMA_MAX_DMACH 64
101
#define EDMA_MAX_PARAMENTRY 512
103
/*****************************************************************************/
105
static void __iomem *edmacc_regs_base[EDMA_MAX_CC];
107
static inline unsigned int edma_read(unsigned ctlr, int offset)
109
return (unsigned int)__raw_readl(edmacc_regs_base[ctlr] + offset);
112
static inline void edma_write(unsigned ctlr, int offset, int val)
114
__raw_writel(val, edmacc_regs_base[ctlr] + offset);
116
static inline void edma_modify(unsigned ctlr, int offset, unsigned and,
119
unsigned val = edma_read(ctlr, offset);
122
edma_write(ctlr, offset, val);
124
static inline void edma_and(unsigned ctlr, int offset, unsigned and)
126
unsigned val = edma_read(ctlr, offset);
128
edma_write(ctlr, offset, val);
130
static inline void edma_or(unsigned ctlr, int offset, unsigned or)
132
unsigned val = edma_read(ctlr, offset);
134
edma_write(ctlr, offset, val);
136
static inline unsigned int edma_read_array(unsigned ctlr, int offset, int i)
138
return edma_read(ctlr, offset + (i << 2));
140
static inline void edma_write_array(unsigned ctlr, int offset, int i,
143
edma_write(ctlr, offset + (i << 2), val);
145
static inline void edma_modify_array(unsigned ctlr, int offset, int i,
146
unsigned and, unsigned or)
148
edma_modify(ctlr, offset + (i << 2), and, or);
150
static inline void edma_or_array(unsigned ctlr, int offset, int i, unsigned or)
152
edma_or(ctlr, offset + (i << 2), or);
154
static inline void edma_or_array2(unsigned ctlr, int offset, int i, int j,
157
edma_or(ctlr, offset + ((i*2 + j) << 2), or);
159
static inline void edma_write_array2(unsigned ctlr, int offset, int i, int j,
162
edma_write(ctlr, offset + ((i*2 + j) << 2), val);
164
static inline unsigned int edma_shadow0_read(unsigned ctlr, int offset)
166
return edma_read(ctlr, EDMA_SHADOW0 + offset);
168
static inline unsigned int edma_shadow0_read_array(unsigned ctlr, int offset,
171
return edma_read(ctlr, EDMA_SHADOW0 + offset + (i << 2));
173
static inline void edma_shadow0_write(unsigned ctlr, int offset, unsigned val)
175
edma_write(ctlr, EDMA_SHADOW0 + offset, val);
177
static inline void edma_shadow0_write_array(unsigned ctlr, int offset, int i,
180
edma_write(ctlr, EDMA_SHADOW0 + offset + (i << 2), val);
182
static inline unsigned int edma_parm_read(unsigned ctlr, int offset,
185
return edma_read(ctlr, EDMA_PARM + offset + (param_no << 5));
187
static inline void edma_parm_write(unsigned ctlr, int offset, int param_no,
190
edma_write(ctlr, EDMA_PARM + offset + (param_no << 5), val);
192
static inline void edma_parm_modify(unsigned ctlr, int offset, int param_no,
193
unsigned and, unsigned or)
195
edma_modify(ctlr, EDMA_PARM + offset + (param_no << 5), and, or);
197
static inline void edma_parm_and(unsigned ctlr, int offset, int param_no,
200
edma_and(ctlr, EDMA_PARM + offset + (param_no << 5), and);
202
static inline void edma_parm_or(unsigned ctlr, int offset, int param_no,
205
edma_or(ctlr, EDMA_PARM + offset + (param_no << 5), or);
208
static inline void set_bits(int offset, int len, unsigned long *p)
210
for (; len > 0; len--)
211
set_bit(offset + (len - 1), p);
214
static inline void clear_bits(int offset, int len, unsigned long *p)
216
for (; len > 0; len--)
217
clear_bit(offset + (len - 1), p);
220
/*****************************************************************************/
222
/* actual number of DMA channels and slots on this silicon */
224
/* how many dma resources of each type */
225
unsigned num_channels;
230
enum dma_event_q default_queue;
232
/* list of channels with no even trigger; terminated by "-1" */
235
/* The edma_inuse bit for each PaRAM slot is clear unless the
236
* channel is in use ... by ARM or DSP, for QDMA, or whatever.
238
DECLARE_BITMAP(edma_inuse, EDMA_MAX_PARAMENTRY);
240
/* The edma_unused bit for each channel is clear unless
241
* it is not being used on this platform. It uses a bit
242
* of SOC-specific initialization code.
244
DECLARE_BITMAP(edma_unused, EDMA_MAX_DMACH);
246
unsigned irq_res_start;
247
unsigned irq_res_end;
249
struct dma_interrupt_data {
250
void (*callback)(unsigned channel, unsigned short ch_status,
253
} intr_data[EDMA_MAX_DMACH];
256
static struct edma *edma_cc[EDMA_MAX_CC];
257
static int arch_num_cc;
259
/* dummy param set used to (re)initialize parameter RAM slots */
260
static const struct edmacc_param dummy_paramset = {
261
.link_bcntrld = 0xffff,
265
/*****************************************************************************/
267
static void map_dmach_queue(unsigned ctlr, unsigned ch_no,
268
enum dma_event_q queue_no)
270
int bit = (ch_no & 0x7) * 4;
272
/* default to low priority queue */
273
if (queue_no == EVENTQ_DEFAULT)
274
queue_no = edma_cc[ctlr]->default_queue;
277
edma_modify_array(ctlr, EDMA_DMAQNUM, (ch_no >> 3),
278
~(0x7 << bit), queue_no << bit);
281
static void __init map_queue_tc(unsigned ctlr, int queue_no, int tc_no)
283
int bit = queue_no * 4;
284
edma_modify(ctlr, EDMA_QUETCMAP, ~(0x7 << bit), ((tc_no & 0x7) << bit));
287
static void __init assign_priority_to_queue(unsigned ctlr, int queue_no,
290
int bit = queue_no * 4;
291
edma_modify(ctlr, EDMA_QUEPRI, ~(0x7 << bit),
292
((priority & 0x7) << bit));
296
* map_dmach_param - Maps channel number to param entry number
298
* This maps the dma channel number to param entry numberter. In
299
* other words using the DMA channel mapping registers a param entry
300
* can be mapped to any channel
302
* Callers are responsible for ensuring the channel mapping logic is
303
* included in that particular EDMA variant (Eg : dm646x)
306
static void __init map_dmach_param(unsigned ctlr)
309
for (i = 0; i < EDMA_MAX_DMACH; i++)
310
edma_write_array(ctlr, EDMA_DCHMAP , i , (i << 5));
314
setup_dma_interrupt(unsigned lch,
315
void (*callback)(unsigned channel, u16 ch_status, void *data),
320
ctlr = EDMA_CTLR(lch);
321
lch = EDMA_CHAN_SLOT(lch);
324
edma_shadow0_write_array(ctlr, SH_IECR, lch >> 5,
327
edma_cc[ctlr]->intr_data[lch].callback = callback;
328
edma_cc[ctlr]->intr_data[lch].data = data;
331
edma_shadow0_write_array(ctlr, SH_ICR, lch >> 5,
333
edma_shadow0_write_array(ctlr, SH_IESR, lch >> 5,
338
static int irq2ctlr(int irq)
340
if (irq >= edma_cc[0]->irq_res_start && irq <= edma_cc[0]->irq_res_end)
342
else if (irq >= edma_cc[1]->irq_res_start &&
343
irq <= edma_cc[1]->irq_res_end)
349
/******************************************************************************
351
* DMA interrupt handler
353
*****************************************************************************/
354
static irqreturn_t dma_irq_handler(int irq, void *data)
358
unsigned int cnt = 0;
360
ctlr = irq2ctlr(irq);
364
dev_dbg(data, "dma_irq_handler\n");
366
if ((edma_shadow0_read_array(ctlr, SH_IPR, 0) == 0) &&
367
(edma_shadow0_read_array(ctlr, SH_IPR, 1) == 0))
372
if (edma_shadow0_read_array(ctlr, SH_IPR, 0) &
373
edma_shadow0_read_array(ctlr, SH_IER, 0))
375
else if (edma_shadow0_read_array(ctlr, SH_IPR, 1) &
376
edma_shadow0_read_array(ctlr, SH_IER, 1))
380
dev_dbg(data, "IPR%d %08x\n", j,
381
edma_shadow0_read_array(ctlr, SH_IPR, j));
382
for (i = 0; i < 32; i++) {
383
int k = (j << 5) + i;
384
if ((edma_shadow0_read_array(ctlr, SH_IPR, j) & BIT(i))
385
&& (edma_shadow0_read_array(ctlr,
386
SH_IER, j) & BIT(i))) {
387
/* Clear the corresponding IPR bits */
388
edma_shadow0_write_array(ctlr, SH_ICR, j,
390
if (edma_cc[ctlr]->intr_data[k].callback)
391
edma_cc[ctlr]->intr_data[k].callback(
393
edma_cc[ctlr]->intr_data[k].
401
edma_shadow0_write(ctlr, SH_IEVAL, 1);
405
/******************************************************************************
407
* DMA error interrupt handler
409
*****************************************************************************/
410
static irqreturn_t dma_ccerr_handler(int irq, void *data)
414
unsigned int cnt = 0;
416
ctlr = irq2ctlr(irq);
420
dev_dbg(data, "dma_ccerr_handler\n");
422
if ((edma_read_array(ctlr, EDMA_EMR, 0) == 0) &&
423
(edma_read_array(ctlr, EDMA_EMR, 1) == 0) &&
424
(edma_read(ctlr, EDMA_QEMR) == 0) &&
425
(edma_read(ctlr, EDMA_CCERR) == 0))
430
if (edma_read_array(ctlr, EDMA_EMR, 0))
432
else if (edma_read_array(ctlr, EDMA_EMR, 1))
435
dev_dbg(data, "EMR%d %08x\n", j,
436
edma_read_array(ctlr, EDMA_EMR, j));
437
for (i = 0; i < 32; i++) {
438
int k = (j << 5) + i;
439
if (edma_read_array(ctlr, EDMA_EMR, j) &
441
/* Clear the corresponding EMR bits */
442
edma_write_array(ctlr, EDMA_EMCR, j,
445
edma_shadow0_write_array(ctlr, SH_SECR,
447
if (edma_cc[ctlr]->intr_data[k].
449
edma_cc[ctlr]->intr_data[k].
452
edma_cc[ctlr]->intr_data
457
} else if (edma_read(ctlr, EDMA_QEMR)) {
458
dev_dbg(data, "QEMR %02x\n",
459
edma_read(ctlr, EDMA_QEMR));
460
for (i = 0; i < 8; i++) {
461
if (edma_read(ctlr, EDMA_QEMR) & BIT(i)) {
462
/* Clear the corresponding IPR bits */
463
edma_write(ctlr, EDMA_QEMCR, BIT(i));
464
edma_shadow0_write(ctlr, SH_QSECR,
467
/* NOTE: not reported!! */
470
} else if (edma_read(ctlr, EDMA_CCERR)) {
471
dev_dbg(data, "CCERR %08x\n",
472
edma_read(ctlr, EDMA_CCERR));
473
/* FIXME: CCERR.BIT(16) ignored! much better
474
* to just write CCERRCLR with CCERR value...
476
for (i = 0; i < 8; i++) {
477
if (edma_read(ctlr, EDMA_CCERR) & BIT(i)) {
478
/* Clear the corresponding IPR bits */
479
edma_write(ctlr, EDMA_CCERRCLR, BIT(i));
481
/* NOTE: not reported!! */
485
if ((edma_read_array(ctlr, EDMA_EMR, 0) == 0) &&
486
(edma_read_array(ctlr, EDMA_EMR, 1) == 0) &&
487
(edma_read(ctlr, EDMA_QEMR) == 0) &&
488
(edma_read(ctlr, EDMA_CCERR) == 0))
494
edma_write(ctlr, EDMA_EEVAL, 1);
498
/******************************************************************************
500
* Transfer controller error interrupt handlers
502
*****************************************************************************/
504
#define tc_errs_handled false /* disabled as long as they're NOPs */
506
static irqreturn_t dma_tc0err_handler(int irq, void *data)
508
dev_dbg(data, "dma_tc0err_handler\n");
512
static irqreturn_t dma_tc1err_handler(int irq, void *data)
514
dev_dbg(data, "dma_tc1err_handler\n");
518
static int reserve_contiguous_slots(int ctlr, unsigned int id,
519
unsigned int num_slots,
520
unsigned int start_slot)
523
unsigned int count = num_slots;
524
int stop_slot = start_slot;
525
DECLARE_BITMAP(tmp_inuse, EDMA_MAX_PARAMENTRY);
527
for (i = start_slot; i < edma_cc[ctlr]->num_slots; ++i) {
528
j = EDMA_CHAN_SLOT(i);
529
if (!test_and_set_bit(j, edma_cc[ctlr]->edma_inuse)) {
530
/* Record our current beginning slot */
531
if (count == num_slots)
535
set_bit(j, tmp_inuse);
540
clear_bit(j, tmp_inuse);
542
if (id == EDMA_CONT_PARAMS_FIXED_EXACT) {
552
* We have to clear any bits that we set
553
* if we run out parameter RAM slots, i.e we do find a set
554
* of contiguous parameter RAM slots but do not find the exact number
555
* requested as we may reach the total number of parameter RAM slots
557
if (i == edma_cc[ctlr]->num_slots)
560
for (j = start_slot; j < stop_slot; j++)
561
if (test_bit(j, tmp_inuse))
562
clear_bit(j, edma_cc[ctlr]->edma_inuse);
567
for (j = i - num_slots + 1; j <= i; ++j)
568
memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(j),
569
&dummy_paramset, PARM_SIZE);
571
return EDMA_CTLR_CHAN(ctlr, i - num_slots + 1);
574
static int prepare_unused_channel_list(struct device *dev, void *data)
576
struct platform_device *pdev = to_platform_device(dev);
579
for (i = 0; i < pdev->num_resources; i++) {
580
if ((pdev->resource[i].flags & IORESOURCE_DMA) &&
581
(int)pdev->resource[i].start >= 0) {
582
ctlr = EDMA_CTLR(pdev->resource[i].start);
583
clear_bit(EDMA_CHAN_SLOT(pdev->resource[i].start),
584
edma_cc[ctlr]->edma_unused);
591
/*-----------------------------------------------------------------------*/
593
static bool unused_chan_list_done;
595
/* Resource alloc/free: dma channels, parameter RAM slots */
598
* edma_alloc_channel - allocate DMA channel and paired parameter RAM
599
* @channel: specific channel to allocate; negative for "any unmapped channel"
600
* @callback: optional; to be issued on DMA completion or errors
601
* @data: passed to callback
602
* @eventq_no: an EVENTQ_* constant, used to choose which Transfer
603
* Controller (TC) executes requests using this channel. Use
604
* EVENTQ_DEFAULT unless you really need a high priority queue.
606
* This allocates a DMA channel and its associated parameter RAM slot.
607
* The parameter RAM is initialized to hold a dummy transfer.
609
* Normal use is to pass a specific channel number as @channel, to make
610
* use of hardware events mapped to that channel. When the channel will
611
* be used only for software triggering or event chaining, channels not
612
* mapped to hardware events (or mapped to unused events) are preferable.
614
* DMA transfers start from a channel using edma_start(), or by
615
* chaining. When the transfer described in that channel's parameter RAM
616
* slot completes, that slot's data may be reloaded through a link.
618
* DMA errors are only reported to the @callback associated with the
619
* channel driving that transfer, but transfer completion callbacks can
620
* be sent to another channel under control of the TCC field in
621
* the option word of the transfer's parameter RAM set. Drivers must not
622
* use DMA transfer completion callbacks for channels they did not allocate.
623
* (The same applies to TCC codes used in transfer chaining.)
625
* Returns the number of the channel, else negative errno.
627
int edma_alloc_channel(int channel,
628
void (*callback)(unsigned channel, u16 ch_status, void *data),
630
enum dma_event_q eventq_no)
632
unsigned i, done = 0, ctlr = 0;
635
if (!unused_chan_list_done) {
637
* Scan all the platform devices to find out the EDMA channels
638
* used and clear them in the unused list, making the rest
639
* available for ARM usage.
641
ret = bus_for_each_dev(&platform_bus_type, NULL, NULL,
642
prepare_unused_channel_list);
646
unused_chan_list_done = true;
650
ctlr = EDMA_CTLR(channel);
651
channel = EDMA_CHAN_SLOT(channel);
655
for (i = 0; i < arch_num_cc; i++) {
658
channel = find_next_bit(edma_cc[i]->edma_unused,
659
edma_cc[i]->num_channels,
661
if (channel == edma_cc[i]->num_channels)
663
if (!test_and_set_bit(channel,
664
edma_cc[i]->edma_inuse)) {
676
} else if (channel >= edma_cc[ctlr]->num_channels) {
678
} else if (test_and_set_bit(channel, edma_cc[ctlr]->edma_inuse)) {
682
/* ensure access through shadow region 0 */
683
edma_or_array2(ctlr, EDMA_DRAE, 0, channel >> 5, BIT(channel & 0x1f));
685
/* ensure no events are pending */
686
edma_stop(EDMA_CTLR_CHAN(ctlr, channel));
687
memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(channel),
688
&dummy_paramset, PARM_SIZE);
691
setup_dma_interrupt(EDMA_CTLR_CHAN(ctlr, channel),
694
map_dmach_queue(ctlr, channel, eventq_no);
696
return EDMA_CTLR_CHAN(ctlr, channel);
698
EXPORT_SYMBOL(edma_alloc_channel);
702
* edma_free_channel - deallocate DMA channel
703
* @channel: dma channel returned from edma_alloc_channel()
705
* This deallocates the DMA channel and associated parameter RAM slot
706
* allocated by edma_alloc_channel().
708
* Callers are responsible for ensuring the channel is inactive, and
709
* will not be reactivated by linking, chaining, or software calls to
712
void edma_free_channel(unsigned channel)
716
ctlr = EDMA_CTLR(channel);
717
channel = EDMA_CHAN_SLOT(channel);
719
if (channel >= edma_cc[ctlr]->num_channels)
722
setup_dma_interrupt(channel, NULL, NULL);
723
/* REVISIT should probably take out of shadow region 0 */
725
memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(channel),
726
&dummy_paramset, PARM_SIZE);
727
clear_bit(channel, edma_cc[ctlr]->edma_inuse);
729
EXPORT_SYMBOL(edma_free_channel);
732
* edma_alloc_slot - allocate DMA parameter RAM
733
* @slot: specific slot to allocate; negative for "any unused slot"
735
* This allocates a parameter RAM slot, initializing it to hold a
736
* dummy transfer. Slots allocated using this routine have not been
737
* mapped to a hardware DMA channel, and will normally be used by
738
* linking to them from a slot associated with a DMA channel.
740
* Normal use is to pass EDMA_SLOT_ANY as the @slot, but specific
741
* slots may be allocated on behalf of DSP firmware.
743
* Returns the number of the slot, else negative errno.
745
int edma_alloc_slot(unsigned ctlr, int slot)
748
slot = EDMA_CHAN_SLOT(slot);
751
slot = edma_cc[ctlr]->num_channels;
753
slot = find_next_zero_bit(edma_cc[ctlr]->edma_inuse,
754
edma_cc[ctlr]->num_slots, slot);
755
if (slot == edma_cc[ctlr]->num_slots)
757
if (!test_and_set_bit(slot, edma_cc[ctlr]->edma_inuse))
760
} else if (slot < edma_cc[ctlr]->num_channels ||
761
slot >= edma_cc[ctlr]->num_slots) {
763
} else if (test_and_set_bit(slot, edma_cc[ctlr]->edma_inuse)) {
767
memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(slot),
768
&dummy_paramset, PARM_SIZE);
770
return EDMA_CTLR_CHAN(ctlr, slot);
772
EXPORT_SYMBOL(edma_alloc_slot);
775
* edma_free_slot - deallocate DMA parameter RAM
776
* @slot: parameter RAM slot returned from edma_alloc_slot()
778
* This deallocates the parameter RAM slot allocated by edma_alloc_slot().
779
* Callers are responsible for ensuring the slot is inactive, and will
782
void edma_free_slot(unsigned slot)
786
ctlr = EDMA_CTLR(slot);
787
slot = EDMA_CHAN_SLOT(slot);
789
if (slot < edma_cc[ctlr]->num_channels ||
790
slot >= edma_cc[ctlr]->num_slots)
793
memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(slot),
794
&dummy_paramset, PARM_SIZE);
795
clear_bit(slot, edma_cc[ctlr]->edma_inuse);
797
EXPORT_SYMBOL(edma_free_slot);
801
* edma_alloc_cont_slots- alloc contiguous parameter RAM slots
802
* The API will return the starting point of a set of
803
* contiguous parameter RAM slots that have been requested
805
* @id: can only be EDMA_CONT_PARAMS_ANY or EDMA_CONT_PARAMS_FIXED_EXACT
806
* or EDMA_CONT_PARAMS_FIXED_NOT_EXACT
807
* @count: number of contiguous Paramter RAM slots
808
* @slot - the start value of Parameter RAM slot that should be passed if id
809
* is EDMA_CONT_PARAMS_FIXED_EXACT or EDMA_CONT_PARAMS_FIXED_NOT_EXACT
811
* If id is EDMA_CONT_PARAMS_ANY then the API starts looking for a set of
812
* contiguous Parameter RAM slots from parameter RAM 64 in the case of
813
* DaVinci SOCs and 32 in the case of DA8xx SOCs.
815
* If id is EDMA_CONT_PARAMS_FIXED_EXACT then the API starts looking for a
816
* set of contiguous parameter RAM slots from the "slot" that is passed as an
817
* argument to the API.
819
* If id is EDMA_CONT_PARAMS_FIXED_NOT_EXACT then the API initially tries
820
* starts looking for a set of contiguous parameter RAMs from the "slot"
821
* that is passed as an argument to the API. On failure the API will try to
822
* find a set of contiguous Parameter RAM slots from the remaining Parameter
825
int edma_alloc_cont_slots(unsigned ctlr, unsigned int id, int slot, int count)
828
* The start slot requested should be greater than
829
* the number of channels and lesser than the total number
832
if ((id != EDMA_CONT_PARAMS_ANY) &&
833
(slot < edma_cc[ctlr]->num_channels ||
834
slot >= edma_cc[ctlr]->num_slots))
838
* The number of parameter RAM slots requested cannot be less than 1
839
* and cannot be more than the number of slots minus the number of
842
if (count < 1 || count >
843
(edma_cc[ctlr]->num_slots - edma_cc[ctlr]->num_channels))
847
case EDMA_CONT_PARAMS_ANY:
848
return reserve_contiguous_slots(ctlr, id, count,
849
edma_cc[ctlr]->num_channels);
850
case EDMA_CONT_PARAMS_FIXED_EXACT:
851
case EDMA_CONT_PARAMS_FIXED_NOT_EXACT:
852
return reserve_contiguous_slots(ctlr, id, count, slot);
858
EXPORT_SYMBOL(edma_alloc_cont_slots);
861
* edma_free_cont_slots - deallocate DMA parameter RAM slots
862
* @slot: first parameter RAM of a set of parameter RAM slots to be freed
863
* @count: the number of contiguous parameter RAM slots to be freed
865
* This deallocates the parameter RAM slots allocated by
866
* edma_alloc_cont_slots.
867
* Callers/applications need to keep track of sets of contiguous
868
* parameter RAM slots that have been allocated using the edma_alloc_cont_slots
870
* Callers are responsible for ensuring the slots are inactive, and will
873
int edma_free_cont_slots(unsigned slot, int count)
875
unsigned ctlr, slot_to_free;
878
ctlr = EDMA_CTLR(slot);
879
slot = EDMA_CHAN_SLOT(slot);
881
if (slot < edma_cc[ctlr]->num_channels ||
882
slot >= edma_cc[ctlr]->num_slots ||
886
for (i = slot; i < slot + count; ++i) {
888
slot_to_free = EDMA_CHAN_SLOT(i);
890
memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(slot_to_free),
891
&dummy_paramset, PARM_SIZE);
892
clear_bit(slot_to_free, edma_cc[ctlr]->edma_inuse);
897
EXPORT_SYMBOL(edma_free_cont_slots);
899
/*-----------------------------------------------------------------------*/
901
/* Parameter RAM operations (i) -- read/write partial slots */
904
* edma_set_src - set initial DMA source address in parameter RAM slot
905
* @slot: parameter RAM slot being configured
906
* @src_port: physical address of source (memory, controller FIFO, etc)
907
* @addressMode: INCR, except in very rare cases
908
* @fifoWidth: ignored unless @addressMode is FIFO, else specifies the
909
* width to use when addressing the fifo (e.g. W8BIT, W32BIT)
911
* Note that the source address is modified during the DMA transfer
912
* according to edma_set_src_index().
914
void edma_set_src(unsigned slot, dma_addr_t src_port,
915
enum address_mode mode, enum fifo_width width)
919
ctlr = EDMA_CTLR(slot);
920
slot = EDMA_CHAN_SLOT(slot);
922
if (slot < edma_cc[ctlr]->num_slots) {
923
unsigned int i = edma_parm_read(ctlr, PARM_OPT, slot);
926
/* set SAM and program FWID */
927
i = (i & ~(EDMA_FWID)) | (SAM | ((width & 0x7) << 8));
932
edma_parm_write(ctlr, PARM_OPT, slot, i);
934
/* set the source port address
935
in source register of param structure */
936
edma_parm_write(ctlr, PARM_SRC, slot, src_port);
939
EXPORT_SYMBOL(edma_set_src);
942
* edma_set_dest - set initial DMA destination address in parameter RAM slot
943
* @slot: parameter RAM slot being configured
944
* @dest_port: physical address of destination (memory, controller FIFO, etc)
945
* @addressMode: INCR, except in very rare cases
946
* @fifoWidth: ignored unless @addressMode is FIFO, else specifies the
947
* width to use when addressing the fifo (e.g. W8BIT, W32BIT)
949
* Note that the destination address is modified during the DMA transfer
950
* according to edma_set_dest_index().
952
void edma_set_dest(unsigned slot, dma_addr_t dest_port,
953
enum address_mode mode, enum fifo_width width)
957
ctlr = EDMA_CTLR(slot);
958
slot = EDMA_CHAN_SLOT(slot);
960
if (slot < edma_cc[ctlr]->num_slots) {
961
unsigned int i = edma_parm_read(ctlr, PARM_OPT, slot);
964
/* set DAM and program FWID */
965
i = (i & ~(EDMA_FWID)) | (DAM | ((width & 0x7) << 8));
970
edma_parm_write(ctlr, PARM_OPT, slot, i);
971
/* set the destination port address
972
in dest register of param structure */
973
edma_parm_write(ctlr, PARM_DST, slot, dest_port);
976
EXPORT_SYMBOL(edma_set_dest);
979
* edma_get_position - returns the current transfer points
980
* @slot: parameter RAM slot being examined
981
* @src: pointer to source port position
982
* @dst: pointer to destination port position
984
* Returns current source and destination addresses for a particular
985
* parameter RAM slot. Its channel should not be active when this is called.
987
void edma_get_position(unsigned slot, dma_addr_t *src, dma_addr_t *dst)
989
struct edmacc_param temp;
992
ctlr = EDMA_CTLR(slot);
993
slot = EDMA_CHAN_SLOT(slot);
995
edma_read_slot(EDMA_CTLR_CHAN(ctlr, slot), &temp);
1001
EXPORT_SYMBOL(edma_get_position);
1004
* edma_set_src_index - configure DMA source address indexing
1005
* @slot: parameter RAM slot being configured
1006
* @src_bidx: byte offset between source arrays in a frame
1007
* @src_cidx: byte offset between source frames in a block
1009
* Offsets are specified to support either contiguous or discontiguous
1010
* memory transfers, or repeated access to a hardware register, as needed.
1011
* When accessing hardware registers, both offsets are normally zero.
1013
void edma_set_src_index(unsigned slot, s16 src_bidx, s16 src_cidx)
1017
ctlr = EDMA_CTLR(slot);
1018
slot = EDMA_CHAN_SLOT(slot);
1020
if (slot < edma_cc[ctlr]->num_slots) {
1021
edma_parm_modify(ctlr, PARM_SRC_DST_BIDX, slot,
1022
0xffff0000, src_bidx);
1023
edma_parm_modify(ctlr, PARM_SRC_DST_CIDX, slot,
1024
0xffff0000, src_cidx);
1027
EXPORT_SYMBOL(edma_set_src_index);
1030
* edma_set_dest_index - configure DMA destination address indexing
1031
* @slot: parameter RAM slot being configured
1032
* @dest_bidx: byte offset between destination arrays in a frame
1033
* @dest_cidx: byte offset between destination frames in a block
1035
* Offsets are specified to support either contiguous or discontiguous
1036
* memory transfers, or repeated access to a hardware register, as needed.
1037
* When accessing hardware registers, both offsets are normally zero.
1039
void edma_set_dest_index(unsigned slot, s16 dest_bidx, s16 dest_cidx)
1043
ctlr = EDMA_CTLR(slot);
1044
slot = EDMA_CHAN_SLOT(slot);
1046
if (slot < edma_cc[ctlr]->num_slots) {
1047
edma_parm_modify(ctlr, PARM_SRC_DST_BIDX, slot,
1048
0x0000ffff, dest_bidx << 16);
1049
edma_parm_modify(ctlr, PARM_SRC_DST_CIDX, slot,
1050
0x0000ffff, dest_cidx << 16);
1053
EXPORT_SYMBOL(edma_set_dest_index);
1056
* edma_set_transfer_params - configure DMA transfer parameters
1057
* @slot: parameter RAM slot being configured
1058
* @acnt: how many bytes per array (at least one)
1059
* @bcnt: how many arrays per frame (at least one)
1060
* @ccnt: how many frames per block (at least one)
1061
* @bcnt_rld: used only for A-Synchronized transfers; this specifies
1062
* the value to reload into bcnt when it decrements to zero
1063
* @sync_mode: ASYNC or ABSYNC
1065
* See the EDMA3 documentation to understand how to configure and link
1066
* transfers using the fields in PaRAM slots. If you are not doing it
1067
* all at once with edma_write_slot(), you will use this routine
1068
* plus two calls each for source and destination, setting the initial
1069
* address and saying how to index that address.
1071
* An example of an A-Synchronized transfer is a serial link using a
1072
* single word shift register. In that case, @acnt would be equal to
1073
* that word size; the serial controller issues a DMA synchronization
1074
* event to transfer each word, and memory access by the DMA transfer
1075
* controller will be word-at-a-time.
1077
* An example of an AB-Synchronized transfer is a device using a FIFO.
1078
* In that case, @acnt equals the FIFO width and @bcnt equals its depth.
1079
* The controller with the FIFO issues DMA synchronization events when
1080
* the FIFO threshold is reached, and the DMA transfer controller will
1081
* transfer one frame to (or from) the FIFO. It will probably use
1082
* efficient burst modes to access memory.
1084
void edma_set_transfer_params(unsigned slot,
1085
u16 acnt, u16 bcnt, u16 ccnt,
1086
u16 bcnt_rld, enum sync_dimension sync_mode)
1090
ctlr = EDMA_CTLR(slot);
1091
slot = EDMA_CHAN_SLOT(slot);
1093
if (slot < edma_cc[ctlr]->num_slots) {
1094
edma_parm_modify(ctlr, PARM_LINK_BCNTRLD, slot,
1095
0x0000ffff, bcnt_rld << 16);
1096
if (sync_mode == ASYNC)
1097
edma_parm_and(ctlr, PARM_OPT, slot, ~SYNCDIM);
1099
edma_parm_or(ctlr, PARM_OPT, slot, SYNCDIM);
1100
/* Set the acount, bcount, ccount registers */
1101
edma_parm_write(ctlr, PARM_A_B_CNT, slot, (bcnt << 16) | acnt);
1102
edma_parm_write(ctlr, PARM_CCNT, slot, ccnt);
1105
EXPORT_SYMBOL(edma_set_transfer_params);
1108
* edma_link - link one parameter RAM slot to another
1109
* @from: parameter RAM slot originating the link
1110
* @to: parameter RAM slot which is the link target
1112
* The originating slot should not be part of any active DMA transfer.
1114
void edma_link(unsigned from, unsigned to)
1116
unsigned ctlr_from, ctlr_to;
1118
ctlr_from = EDMA_CTLR(from);
1119
from = EDMA_CHAN_SLOT(from);
1120
ctlr_to = EDMA_CTLR(to);
1121
to = EDMA_CHAN_SLOT(to);
1123
if (from >= edma_cc[ctlr_from]->num_slots)
1125
if (to >= edma_cc[ctlr_to]->num_slots)
1127
edma_parm_modify(ctlr_from, PARM_LINK_BCNTRLD, from, 0xffff0000,
1130
EXPORT_SYMBOL(edma_link);
1133
* edma_unlink - cut link from one parameter RAM slot
1134
* @from: parameter RAM slot originating the link
1136
* The originating slot should not be part of any active DMA transfer.
1137
* Its link is set to 0xffff.
1139
void edma_unlink(unsigned from)
1143
ctlr = EDMA_CTLR(from);
1144
from = EDMA_CHAN_SLOT(from);
1146
if (from >= edma_cc[ctlr]->num_slots)
1148
edma_parm_or(ctlr, PARM_LINK_BCNTRLD, from, 0xffff);
1150
EXPORT_SYMBOL(edma_unlink);
1152
/*-----------------------------------------------------------------------*/
1154
/* Parameter RAM operations (ii) -- read/write whole parameter sets */
1157
* edma_write_slot - write parameter RAM data for slot
1158
* @slot: number of parameter RAM slot being modified
1159
* @param: data to be written into parameter RAM slot
1161
* Use this to assign all parameters of a transfer at once. This
1162
* allows more efficient setup of transfers than issuing multiple
1163
* calls to set up those parameters in small pieces, and provides
1164
* complete control over all transfer options.
1166
void edma_write_slot(unsigned slot, const struct edmacc_param *param)
1170
ctlr = EDMA_CTLR(slot);
1171
slot = EDMA_CHAN_SLOT(slot);
1173
if (slot >= edma_cc[ctlr]->num_slots)
1175
memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(slot), param,
1178
EXPORT_SYMBOL(edma_write_slot);
1181
* edma_read_slot - read parameter RAM data from slot
1182
* @slot: number of parameter RAM slot being copied
1183
* @param: where to store copy of parameter RAM data
1185
* Use this to read data from a parameter RAM slot, perhaps to
1186
* save them as a template for later reuse.
1188
void edma_read_slot(unsigned slot, struct edmacc_param *param)
1192
ctlr = EDMA_CTLR(slot);
1193
slot = EDMA_CHAN_SLOT(slot);
1195
if (slot >= edma_cc[ctlr]->num_slots)
1197
memcpy_fromio(param, edmacc_regs_base[ctlr] + PARM_OFFSET(slot),
1200
EXPORT_SYMBOL(edma_read_slot);
1202
/*-----------------------------------------------------------------------*/
1204
/* Various EDMA channel control operations */
1207
* edma_pause - pause dma on a channel
1208
* @channel: on which edma_start() has been called
1210
* This temporarily disables EDMA hardware events on the specified channel,
1211
* preventing them from triggering new transfers on its behalf
1213
void edma_pause(unsigned channel)
1217
ctlr = EDMA_CTLR(channel);
1218
channel = EDMA_CHAN_SLOT(channel);
1220
if (channel < edma_cc[ctlr]->num_channels) {
1221
unsigned int mask = BIT(channel & 0x1f);
1223
edma_shadow0_write_array(ctlr, SH_EECR, channel >> 5, mask);
1226
EXPORT_SYMBOL(edma_pause);
1229
* edma_resume - resumes dma on a paused channel
1230
* @channel: on which edma_pause() has been called
1232
* This re-enables EDMA hardware events on the specified channel.
1234
void edma_resume(unsigned channel)
1238
ctlr = EDMA_CTLR(channel);
1239
channel = EDMA_CHAN_SLOT(channel);
1241
if (channel < edma_cc[ctlr]->num_channels) {
1242
unsigned int mask = BIT(channel & 0x1f);
1244
edma_shadow0_write_array(ctlr, SH_EESR, channel >> 5, mask);
1247
EXPORT_SYMBOL(edma_resume);
1250
* edma_start - start dma on a channel
1251
* @channel: channel being activated
1253
* Channels with event associations will be triggered by their hardware
1254
* events, and channels without such associations will be triggered by
1255
* software. (At this writing there is no interface for using software
1256
* triggers except with channels that don't support hardware triggers.)
1258
* Returns zero on success, else negative errno.
1260
int edma_start(unsigned channel)
1264
ctlr = EDMA_CTLR(channel);
1265
channel = EDMA_CHAN_SLOT(channel);
1267
if (channel < edma_cc[ctlr]->num_channels) {
1268
int j = channel >> 5;
1269
unsigned int mask = BIT(channel & 0x1f);
1271
/* EDMA channels without event association */
1272
if (test_bit(channel, edma_cc[ctlr]->edma_unused)) {
1273
pr_debug("EDMA: ESR%d %08x\n", j,
1274
edma_shadow0_read_array(ctlr, SH_ESR, j));
1275
edma_shadow0_write_array(ctlr, SH_ESR, j, mask);
1279
/* EDMA channel with event association */
1280
pr_debug("EDMA: ER%d %08x\n", j,
1281
edma_shadow0_read_array(ctlr, SH_ER, j));
1282
/* Clear any pending event or error */
1283
edma_write_array(ctlr, EDMA_ECR, j, mask);
1284
edma_write_array(ctlr, EDMA_EMCR, j, mask);
1286
edma_shadow0_write_array(ctlr, SH_SECR, j, mask);
1287
edma_shadow0_write_array(ctlr, SH_EESR, j, mask);
1288
pr_debug("EDMA: EER%d %08x\n", j,
1289
edma_shadow0_read_array(ctlr, SH_EER, j));
1295
EXPORT_SYMBOL(edma_start);
1298
* edma_stop - stops dma on the channel passed
1299
* @channel: channel being deactivated
1301
* When @lch is a channel, any active transfer is paused and
1302
* all pending hardware events are cleared. The current transfer
1303
* may not be resumed, and the channel's Parameter RAM should be
1304
* reinitialized before being reused.
1306
void edma_stop(unsigned channel)
1310
ctlr = EDMA_CTLR(channel);
1311
channel = EDMA_CHAN_SLOT(channel);
1313
if (channel < edma_cc[ctlr]->num_channels) {
1314
int j = channel >> 5;
1315
unsigned int mask = BIT(channel & 0x1f);
1317
edma_shadow0_write_array(ctlr, SH_EECR, j, mask);
1318
edma_shadow0_write_array(ctlr, SH_ECR, j, mask);
1319
edma_shadow0_write_array(ctlr, SH_SECR, j, mask);
1320
edma_write_array(ctlr, EDMA_EMCR, j, mask);
1322
pr_debug("EDMA: EER%d %08x\n", j,
1323
edma_shadow0_read_array(ctlr, SH_EER, j));
1325
/* REVISIT: consider guarding against inappropriate event
1326
* chaining by overwriting with dummy_paramset.
1330
EXPORT_SYMBOL(edma_stop);
1332
/******************************************************************************
1334
* It cleans ParamEntry qand bring back EDMA to initial state if media has
1335
* been removed before EDMA has finished.It is usedful for removable media.
1337
* ch_no - channel no
1339
* Return: zero on success, or corresponding error no on failure
1341
* FIXME this should not be needed ... edma_stop() should suffice.
1343
*****************************************************************************/
1345
void edma_clean_channel(unsigned channel)
1349
ctlr = EDMA_CTLR(channel);
1350
channel = EDMA_CHAN_SLOT(channel);
1352
if (channel < edma_cc[ctlr]->num_channels) {
1353
int j = (channel >> 5);
1354
unsigned int mask = BIT(channel & 0x1f);
1356
pr_debug("EDMA: EMR%d %08x\n", j,
1357
edma_read_array(ctlr, EDMA_EMR, j));
1358
edma_shadow0_write_array(ctlr, SH_ECR, j, mask);
1359
/* Clear the corresponding EMR bits */
1360
edma_write_array(ctlr, EDMA_EMCR, j, mask);
1362
edma_shadow0_write_array(ctlr, SH_SECR, j, mask);
1363
edma_write(ctlr, EDMA_CCERRCLR, BIT(16) | BIT(1) | BIT(0));
1366
EXPORT_SYMBOL(edma_clean_channel);
1369
* edma_clear_event - clear an outstanding event on the DMA channel
1371
* channel - channel number
1373
void edma_clear_event(unsigned channel)
1377
ctlr = EDMA_CTLR(channel);
1378
channel = EDMA_CHAN_SLOT(channel);
1380
if (channel >= edma_cc[ctlr]->num_channels)
1383
edma_write(ctlr, EDMA_ECR, BIT(channel));
1385
edma_write(ctlr, EDMA_ECRH, BIT(channel - 32));
1387
EXPORT_SYMBOL(edma_clear_event);
1389
/*-----------------------------------------------------------------------*/
1391
static int __init edma_probe(struct platform_device *pdev)
1393
struct edma_soc_info **info = pdev->dev.platform_data;
1394
const s8 (*queue_priority_mapping)[2];
1395
const s8 (*queue_tc_mapping)[2];
1396
int i, j, off, ln, found = 0;
1398
const s16 (*rsv_chans)[2];
1399
const s16 (*rsv_slots)[2];
1400
int irq[EDMA_MAX_CC] = {0, 0};
1401
int err_irq[EDMA_MAX_CC] = {0, 0};
1402
struct resource *r[EDMA_MAX_CC] = {NULL};
1403
resource_size_t len[EDMA_MAX_CC];
1410
for (j = 0; j < EDMA_MAX_CC; j++) {
1411
sprintf(res_name, "edma_cc%d", j);
1412
r[j] = platform_get_resource_byname(pdev, IORESOURCE_MEM,
1414
if (!r[j] || !info[j]) {
1423
len[j] = resource_size(r[j]);
1425
r[j] = request_mem_region(r[j]->start, len[j],
1426
dev_name(&pdev->dev));
1432
edmacc_regs_base[j] = ioremap(r[j]->start, len[j]);
1433
if (!edmacc_regs_base[j]) {
1438
edma_cc[j] = kzalloc(sizeof(struct edma), GFP_KERNEL);
1444
edma_cc[j]->num_channels = min_t(unsigned, info[j]->n_channel,
1446
edma_cc[j]->num_slots = min_t(unsigned, info[j]->n_slot,
1447
EDMA_MAX_PARAMENTRY);
1448
edma_cc[j]->num_cc = min_t(unsigned, info[j]->n_cc,
1451
edma_cc[j]->default_queue = info[j]->default_queue;
1453
dev_dbg(&pdev->dev, "DMA REG BASE ADDR=%p\n",
1454
edmacc_regs_base[j]);
1456
for (i = 0; i < edma_cc[j]->num_slots; i++)
1457
memcpy_toio(edmacc_regs_base[j] + PARM_OFFSET(i),
1458
&dummy_paramset, PARM_SIZE);
1460
/* Mark all channels as unused */
1461
memset(edma_cc[j]->edma_unused, 0xff,
1462
sizeof(edma_cc[j]->edma_unused));
1466
/* Clear the reserved channels in unused list */
1467
rsv_chans = info[j]->rsv->rsv_chans;
1469
for (i = 0; rsv_chans[i][0] != -1; i++) {
1470
off = rsv_chans[i][0];
1471
ln = rsv_chans[i][1];
1473
edma_cc[j]->edma_unused);
1477
/* Set the reserved slots in inuse list */
1478
rsv_slots = info[j]->rsv->rsv_slots;
1480
for (i = 0; rsv_slots[i][0] != -1; i++) {
1481
off = rsv_slots[i][0];
1482
ln = rsv_slots[i][1];
1484
edma_cc[j]->edma_inuse);
1489
sprintf(irq_name, "edma%d", j);
1490
irq[j] = platform_get_irq_byname(pdev, irq_name);
1491
edma_cc[j]->irq_res_start = irq[j];
1492
status = request_irq(irq[j], dma_irq_handler, 0, "edma",
1495
dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1500
sprintf(irq_name, "edma%d_err", j);
1501
err_irq[j] = platform_get_irq_byname(pdev, irq_name);
1502
edma_cc[j]->irq_res_end = err_irq[j];
1503
status = request_irq(err_irq[j], dma_ccerr_handler, 0,
1504
"edma_error", &pdev->dev);
1506
dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1507
err_irq[j], status);
1511
/* Everything lives on transfer controller 1 until otherwise
1512
* specified. This way, long transfers on the low priority queue
1513
* started by the codec engine will not cause audio defects.
1515
for (i = 0; i < edma_cc[j]->num_channels; i++)
1516
map_dmach_queue(j, i, EVENTQ_1);
1518
queue_tc_mapping = info[j]->queue_tc_mapping;
1519
queue_priority_mapping = info[j]->queue_priority_mapping;
1521
/* Event queue to TC mapping */
1522
for (i = 0; queue_tc_mapping[i][0] != -1; i++)
1523
map_queue_tc(j, queue_tc_mapping[i][0],
1524
queue_tc_mapping[i][1]);
1526
/* Event queue priority mapping */
1527
for (i = 0; queue_priority_mapping[i][0] != -1; i++)
1528
assign_priority_to_queue(j,
1529
queue_priority_mapping[i][0],
1530
queue_priority_mapping[i][1]);
1532
/* Map the channel to param entry if channel mapping logic
1535
if (edma_read(j, EDMA_CCCFG) & CHMAP_EXIST)
1538
for (i = 0; i < info[j]->n_region; i++) {
1539
edma_write_array2(j, EDMA_DRAE, i, 0, 0x0);
1540
edma_write_array2(j, EDMA_DRAE, i, 1, 0x0);
1541
edma_write_array(j, EDMA_QRAE, i, 0x0);
1546
if (tc_errs_handled) {
1547
status = request_irq(IRQ_TCERRINT0, dma_tc0err_handler, 0,
1548
"edma_tc0", &pdev->dev);
1550
dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1551
IRQ_TCERRINT0, status);
1554
status = request_irq(IRQ_TCERRINT, dma_tc1err_handler, 0,
1555
"edma_tc1", &pdev->dev);
1557
dev_dbg(&pdev->dev, "request_irq %d --> %d\n",
1558
IRQ_TCERRINT, status);
1566
for (i = 0; i < EDMA_MAX_CC; i++) {
1568
free_irq(err_irq[i], &pdev->dev);
1570
free_irq(irq[i], &pdev->dev);
1573
for (i = 0; i < EDMA_MAX_CC; i++) {
1575
release_mem_region(r[i]->start, len[i]);
1576
if (edmacc_regs_base[i])
1577
iounmap(edmacc_regs_base[i]);
1584
static struct platform_driver edma_driver = {
1585
.driver.name = "edma",
1588
static int __init edma_init(void)
1590
return platform_driver_probe(&edma_driver, edma_probe);
1592
arch_initcall(edma_init);