1 // SPDX-License-Identifier: GPL-2.0
3 // Renesas R-Car Audio DMAC support
5 // Copyright (C) 2015 Renesas Electronics Corp.
6 // Copyright (c) 2015 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
8 #include <linux/delay.h>
9 #include <linux/of_dma.h>
13 * Audio DMAC peri peri register
20 #define PDMACHCR_DE (1 << 0)
24 struct dma_chan *chan;
36 struct rsnd_mod *mod_from;
37 struct rsnd_mod *mod_to;
46 struct rsnd_dma_ctrl {
52 #define rsnd_priv_to_dmac(p) ((struct rsnd_dma_ctrl *)(p)->dma)
53 #define rsnd_mod_to_dma(_mod) container_of((_mod), struct rsnd_dma, mod)
54 #define rsnd_dma_to_dmaen(dma) (&(dma)->dma.en)
55 #define rsnd_dma_to_dmapp(dma) (&(dma)->dma.pp)
58 static struct rsnd_mod_ops mem_ops = {
62 static struct rsnd_mod mem = {
68 static void __rsnd_dmaen_complete(struct rsnd_mod *mod,
69 struct rsnd_dai_stream *io)
71 if (rsnd_io_is_working(io))
72 rsnd_dai_period_elapsed(io);
75 static void rsnd_dmaen_complete(void *data)
77 struct rsnd_mod *mod = data;
79 rsnd_mod_interrupt(mod, __rsnd_dmaen_complete);
82 static struct dma_chan *rsnd_dmaen_request_channel(struct rsnd_dai_stream *io,
83 struct rsnd_mod *mod_from,
84 struct rsnd_mod *mod_to)
86 if ((!mod_from && !mod_to) ||
91 return rsnd_mod_dma_req(io, mod_from);
93 return rsnd_mod_dma_req(io, mod_to);
96 static int rsnd_dmaen_stop(struct rsnd_mod *mod,
97 struct rsnd_dai_stream *io,
98 struct rsnd_priv *priv)
100 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
101 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
104 dmaengine_terminate_all(dmaen->chan);
109 static int rsnd_dmaen_cleanup(struct rsnd_mod *mod,
110 struct rsnd_dai_stream *io,
111 struct rsnd_priv *priv)
113 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
114 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
117 * DMAEngine release uses mutex lock.
118 * Thus, it shouldn't be called under spinlock.
119 * Let's call it under prepare
122 dma_release_channel(dmaen->chan);
129 static int rsnd_dmaen_prepare(struct rsnd_mod *mod,
130 struct rsnd_dai_stream *io,
131 struct rsnd_priv *priv)
133 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
134 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
135 struct device *dev = rsnd_priv_to_dev(priv);
138 dev_err(dev, "it already has dma channel\n");
143 * DMAEngine request uses mutex lock.
144 * Thus, it shouldn't be called under spinlock.
145 * Let's call it under prepare
147 dmaen->chan = rsnd_dmaen_request_channel(io,
150 if (IS_ERR_OR_NULL(dmaen->chan)) {
152 dev_err(dev, "can't get dma channel\n");
159 static int rsnd_dmaen_start(struct rsnd_mod *mod,
160 struct rsnd_dai_stream *io,
161 struct rsnd_priv *priv)
163 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
164 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
165 struct snd_pcm_substream *substream = io->substream;
166 struct device *dev = rsnd_priv_to_dev(priv);
167 struct dma_async_tx_descriptor *desc;
168 struct dma_slave_config cfg = {};
169 int is_play = rsnd_io_is_play(io);
172 cfg.direction = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
173 cfg.src_addr = dma->src_addr;
174 cfg.dst_addr = dma->dst_addr;
175 cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
176 cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
178 dev_dbg(dev, "%s[%d] %pad -> %pad\n",
179 rsnd_mod_name(mod), rsnd_mod_id(mod),
180 &cfg.src_addr, &cfg.dst_addr);
182 ret = dmaengine_slave_config(dmaen->chan, &cfg);
186 desc = dmaengine_prep_dma_cyclic(dmaen->chan,
187 substream->runtime->dma_addr,
188 snd_pcm_lib_buffer_bytes(substream),
189 snd_pcm_lib_period_bytes(substream),
190 is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM,
191 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
194 dev_err(dev, "dmaengine_prep_slave_sg() fail\n");
198 desc->callback = rsnd_dmaen_complete;
199 desc->callback_param = rsnd_mod_get(dma);
201 dmaen->dma_len = snd_pcm_lib_buffer_bytes(substream);
203 dmaen->cookie = dmaengine_submit(desc);
204 if (dmaen->cookie < 0) {
205 dev_err(dev, "dmaengine_submit() fail\n");
209 dma_async_issue_pending(dmaen->chan);
214 struct dma_chan *rsnd_dma_request_channel(struct device_node *of_node,
215 struct rsnd_mod *mod, char *name)
217 struct dma_chan *chan = NULL;
218 struct device_node *np;
221 for_each_child_of_node(of_node, np) {
222 if (i == rsnd_mod_id(mod) && (!chan))
223 chan = of_dma_request_slave_channel(np, name);
227 /* It should call of_node_put(), since, it is rsnd_xxx_of_node() */
228 of_node_put(of_node);
233 static int rsnd_dmaen_attach(struct rsnd_dai_stream *io,
234 struct rsnd_dma *dma,
235 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
237 struct rsnd_priv *priv = rsnd_io_to_priv(io);
238 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
239 struct dma_chan *chan;
241 /* try to get DMAEngine channel */
242 chan = rsnd_dmaen_request_channel(io, mod_from, mod_to);
243 if (IS_ERR_OR_NULL(chan)) {
244 /* Let's follow when -EPROBE_DEFER case */
245 if (PTR_ERR(chan) == -EPROBE_DEFER)
246 return PTR_ERR(chan);
249 * DMA failed. try to PIO mode
251 * rsnd_ssi_fallback()
252 * rsnd_rdai_continuance_probe()
258 * use it for IPMMU if needed
260 * rsnd_preallocate_pages()
262 io->dmac_dev = chan->device->dev;
264 dma_release_channel(chan);
271 static int rsnd_dmaen_pointer(struct rsnd_mod *mod,
272 struct rsnd_dai_stream *io,
273 snd_pcm_uframes_t *pointer)
275 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
276 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
277 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
278 struct dma_tx_state state;
279 enum dma_status status;
280 unsigned int pos = 0;
282 status = dmaengine_tx_status(dmaen->chan, dmaen->cookie, &state);
283 if (status == DMA_IN_PROGRESS || status == DMA_PAUSED) {
284 if (state.residue > 0 && state.residue <= dmaen->dma_len)
285 pos = dmaen->dma_len - state.residue;
287 *pointer = bytes_to_frames(runtime, pos);
292 static struct rsnd_mod_ops rsnd_dmaen_ops = {
294 .prepare = rsnd_dmaen_prepare,
295 .cleanup = rsnd_dmaen_cleanup,
296 .start = rsnd_dmaen_start,
297 .stop = rsnd_dmaen_stop,
298 .pointer= rsnd_dmaen_pointer,
302 * Audio DMAC peri peri
304 static const u8 gen2_id_table_ssiu[] = {
306 0x00, 0x01, 0x02, 0x03, 0x39, 0x3a, 0x3b, 0x3c,
308 0x04, 0x05, 0x06, 0x07, 0x3d, 0x3e, 0x3f, 0x40,
310 0x08, 0x09, 0x0a, 0x0b, 0x41, 0x42, 0x43, 0x44,
312 0x0c, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b,
314 0x0d, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52,
316 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x12, 0x13, 0x14, 0x15, 0x53, 0x54, 0x55, 0x56,
326 static const u8 gen2_id_table_scu[] = {
327 0x2d, /* SCU_SRCI0 */
328 0x2e, /* SCU_SRCI1 */
329 0x2f, /* SCU_SRCI2 */
330 0x30, /* SCU_SRCI3 */
331 0x31, /* SCU_SRCI4 */
332 0x32, /* SCU_SRCI5 */
333 0x33, /* SCU_SRCI6 */
334 0x34, /* SCU_SRCI7 */
335 0x35, /* SCU_SRCI8 */
336 0x36, /* SCU_SRCI9 */
338 static const u8 gen2_id_table_cmd[] = {
343 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io,
344 struct rsnd_mod *mod)
346 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
347 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
348 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
349 const u8 *entry = NULL;
354 int busif = rsnd_ssi_get_busif(io);
356 entry = gen2_id_table_ssiu;
357 size = ARRAY_SIZE(gen2_id_table_ssiu);
358 id = (rsnd_mod_id(mod) * 8) + busif;
359 } else if (mod == src) {
360 entry = gen2_id_table_scu;
361 size = ARRAY_SIZE(gen2_id_table_scu);
362 id = rsnd_mod_id(mod);
363 } else if (mod == dvc) {
364 entry = gen2_id_table_cmd;
365 size = ARRAY_SIZE(gen2_id_table_cmd);
366 id = rsnd_mod_id(mod);
369 if ((!entry) || (size <= id)) {
370 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io));
372 dev_err(dev, "unknown connection (%s[%d])\n",
373 rsnd_mod_name(mod), rsnd_mod_id(mod));
375 /* use non-prohibited SRS number as error */
376 return 0x00; /* SSI00 */
382 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io,
383 struct rsnd_mod *mod_from,
384 struct rsnd_mod *mod_to)
386 return (rsnd_dmapp_get_id(io, mod_from) << 24) +
387 (rsnd_dmapp_get_id(io, mod_to) << 16);
390 #define rsnd_dmapp_addr(dmac, dma, reg) \
391 (dmac->base + 0x20 + reg + \
392 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id))
393 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg)
395 struct rsnd_mod *mod = rsnd_mod_get(dma);
396 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
397 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
398 struct device *dev = rsnd_priv_to_dev(priv);
400 dev_dbg(dev, "w 0x%px : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data);
402 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg));
405 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg)
407 struct rsnd_mod *mod = rsnd_mod_get(dma);
408 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
409 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
411 return ioread32(rsnd_dmapp_addr(dmac, dma, reg));
414 static void rsnd_dmapp_bset(struct rsnd_dma *dma, u32 data, u32 mask, u32 reg)
416 struct rsnd_mod *mod = rsnd_mod_get(dma);
417 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
418 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
419 void __iomem *addr = rsnd_dmapp_addr(dmac, dma, reg);
420 u32 val = ioread32(addr);
423 val |= (data & mask);
425 iowrite32(val, addr);
428 static int rsnd_dmapp_stop(struct rsnd_mod *mod,
429 struct rsnd_dai_stream *io,
430 struct rsnd_priv *priv)
432 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
435 rsnd_dmapp_bset(dma, 0, PDMACHCR_DE, PDMACHCR);
437 for (i = 0; i < 1024; i++) {
438 if (0 == (rsnd_dmapp_read(dma, PDMACHCR) & PDMACHCR_DE))
446 static int rsnd_dmapp_start(struct rsnd_mod *mod,
447 struct rsnd_dai_stream *io,
448 struct rsnd_priv *priv)
450 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
451 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
453 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR);
454 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR);
455 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR);
460 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io,
461 struct rsnd_dma *dma,
462 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
464 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
465 struct rsnd_priv *priv = rsnd_io_to_priv(io);
466 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
467 struct device *dev = rsnd_priv_to_dev(priv);
469 dmapp->dmapp_id = dmac->dmapp_num;
470 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE;
474 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n",
475 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr);
480 static struct rsnd_mod_ops rsnd_dmapp_ops = {
482 .start = rsnd_dmapp_start,
483 .stop = rsnd_dmapp_stop,
484 .quit = rsnd_dmapp_stop,
488 * Common DMAC Interface
492 * DMA read/write register offset
494 * RSND_xxx_I_N for Audio DMAC input
495 * RSND_xxx_O_N for Audio DMAC output
496 * RSND_xxx_I_P for Audio DMAC peri peri input
497 * RSND_xxx_O_P for Audio DMAC peri peri output
500 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out
501 * SSI : 0xec541000 / 0xec241008 / 0xec24100c
502 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000
503 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000
504 * CMD : 0xec500000 / / 0xec008000 0xec308000
506 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8)
507 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc)
509 #define RDMA_SSIU_I_N(addr, i, j) (addr ##_reg - 0x00441000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400))
510 #define RDMA_SSIU_O_N(addr, i, j) RDMA_SSIU_I_N(addr, i, j)
512 #define RDMA_SSIU_I_P(addr, i, j) (addr ##_reg - 0x00141000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400))
513 #define RDMA_SSIU_O_P(addr, i, j) RDMA_SSIU_I_P(addr, i, j)
515 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i))
516 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i))
518 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i))
519 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i))
521 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i))
522 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i))
525 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io,
526 struct rsnd_mod *mod,
527 int is_play, int is_from)
529 struct rsnd_priv *priv = rsnd_io_to_priv(io);
530 struct device *dev = rsnd_priv_to_dev(priv);
531 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI);
532 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU);
533 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod);
534 int use_src = !!rsnd_io_to_mod_src(io);
535 int use_cmd = !!rsnd_io_to_mod_dvc(io) ||
536 !!rsnd_io_to_mod_mix(io) ||
537 !!rsnd_io_to_mod_ctu(io);
538 int id = rsnd_mod_id(mod);
539 int busif = rsnd_ssi_get_busif(io);
543 } dma_addrs[3][2][3] = {
547 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) },
548 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } },
551 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) },
552 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } }
556 {{{ RDMA_SSI_O_N(ssi, id), 0 },
557 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
558 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
560 {{ 0, RDMA_SSI_I_N(ssi, id) },
561 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
562 { 0, RDMA_SSIU_I_P(ssi, id, busif) } }
566 {{{ RDMA_SSIU_O_N(ssi, id, busif), 0 },
567 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
568 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
570 {{ 0, RDMA_SSIU_I_N(ssi, id, busif) },
571 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
572 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } },
578 * We can't support SSI9-4/5/6/7, because its address is
579 * out of calculation rule
581 if ((id == 9) && (busif >= 4))
582 dev_err(dev, "This driver doesn't support SSI%d-%d, so far",
585 /* it shouldn't happen */
586 if (use_cmd && !use_src)
587 dev_err(dev, "DVC is selected without SRC\n");
589 /* use SSIU or SSI ? */
590 if (is_ssi && rsnd_ssi_use_busif(io))
594 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr :
595 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr;
598 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io,
599 struct rsnd_mod *mod,
600 int is_play, int is_from)
602 struct rsnd_priv *priv = rsnd_io_to_priv(io);
605 * gen1 uses default DMA addr
607 if (rsnd_is_gen1(priv))
613 return rsnd_gen2_dma_addr(io, mod, is_play, is_from);
616 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */
617 static void rsnd_dma_of_path(struct rsnd_mod *this,
618 struct rsnd_dai_stream *io,
620 struct rsnd_mod **mod_from,
621 struct rsnd_mod **mod_to)
623 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
624 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
625 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io);
626 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io);
627 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
628 struct rsnd_mod *mod[MOD_MAX];
629 struct rsnd_mod *mod_start, *mod_end;
630 struct rsnd_priv *priv = rsnd_mod_to_priv(this);
631 struct device *dev = rsnd_priv_to_dev(priv);
638 for (i = 0; i < MOD_MAX; i++) {
640 nr += !!rsnd_io_to_mod(io, i);
645 * [S] -*-> SRC -o-> [E]
646 * [S] -*-> SRC -> DVC -o-> [E]
647 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E]
656 * -o-> Audio DMAC peri peri
658 mod_start = (is_play) ? NULL : ssi;
659 mod_end = (is_play) ? ssi : NULL;
662 mod[idx++] = mod_start;
663 for (i = 1; i < nr; i++) {
682 * -------------+-----+-----+
686 if ((this == ssi) == (is_play)) {
687 *mod_from = mod[idx - 1];
694 dev_dbg(dev, "module connection (this is %s[%d])\n",
695 rsnd_mod_name(this), rsnd_mod_id(this));
696 for (i = 0; i <= idx; i++) {
697 dev_dbg(dev, " %s[%d]%s\n",
698 rsnd_mod_name(mod[i] ? mod[i] : &mem),
699 rsnd_mod_id (mod[i] ? mod[i] : &mem),
700 (mod[i] == *mod_from) ? " from" :
701 (mod[i] == *mod_to) ? " to" : "");
705 static int rsnd_dma_alloc(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
706 struct rsnd_mod **dma_mod)
708 struct rsnd_mod *mod_from = NULL;
709 struct rsnd_mod *mod_to = NULL;
710 struct rsnd_priv *priv = rsnd_io_to_priv(io);
711 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
712 struct device *dev = rsnd_priv_to_dev(priv);
713 struct rsnd_dma *dma;
714 struct rsnd_mod_ops *ops;
715 enum rsnd_mod_type type;
716 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma,
717 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to);
718 int is_play = rsnd_io_is_play(io);
722 * DMA failed. try to PIO mode
724 * rsnd_ssi_fallback()
725 * rsnd_rdai_continuance_probe()
730 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to);
732 /* for Gen2 or later */
733 if (mod_from && mod_to) {
734 ops = &rsnd_dmapp_ops;
735 attach = rsnd_dmapp_attach;
736 dma_id = dmac->dmapp_num;
737 type = RSND_MOD_AUDMAPP;
739 ops = &rsnd_dmaen_ops;
740 attach = rsnd_dmaen_attach;
741 dma_id = dmac->dmaen_num;
742 type = RSND_MOD_AUDMA;
745 /* for Gen1, overwrite */
746 if (rsnd_is_gen1(priv)) {
747 ops = &rsnd_dmaen_ops;
748 attach = rsnd_dmaen_attach;
749 dma_id = dmac->dmaen_num;
750 type = RSND_MOD_AUDMA;
753 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
757 *dma_mod = rsnd_mod_get(dma);
759 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL,
760 rsnd_mod_get_status, type, dma_id);
764 dev_dbg(dev, "%s[%d] %s[%d] -> %s[%d]\n",
765 rsnd_mod_name(*dma_mod), rsnd_mod_id(*dma_mod),
766 rsnd_mod_name(mod_from ? mod_from : &mem),
767 rsnd_mod_id (mod_from ? mod_from : &mem),
768 rsnd_mod_name(mod_to ? mod_to : &mem),
769 rsnd_mod_id (mod_to ? mod_to : &mem));
771 ret = attach(io, dma, mod_from, mod_to);
775 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1);
776 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0);
777 dma->mod_from = mod_from;
778 dma->mod_to = mod_to;
783 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
784 struct rsnd_mod **dma_mod)
787 int ret = rsnd_dma_alloc(io, mod, dma_mod);
793 return rsnd_dai_connect(*dma_mod, io, (*dma_mod)->type);
796 int rsnd_dma_probe(struct rsnd_priv *priv)
798 struct platform_device *pdev = rsnd_priv_to_pdev(priv);
799 struct device *dev = rsnd_priv_to_dev(priv);
800 struct rsnd_dma_ctrl *dmac;
801 struct resource *res;
806 if (rsnd_is_gen1(priv))
812 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp");
813 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL);
815 dev_err(dev, "dma allocate failed\n");
816 return 0; /* it will be PIO mode */
820 dmac->base = devm_ioremap_resource(dev, res);
821 if (IS_ERR(dmac->base))
822 return PTR_ERR(dmac->base);
826 /* dummy mem mod for debug */
827 return rsnd_mod_init(NULL, &mem, &mem_ops, NULL, NULL, 0, 0);