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_nolock_stop(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 nolock_start
122 dma_release_channel(dmaen->chan);
129 static int rsnd_dmaen_nolock_start(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 nolock_start
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)) {
245 * DMA failed. try to PIO mode
247 * rsnd_ssi_fallback()
248 * rsnd_rdai_continuance_probe()
254 * use it for IPMMU if needed
256 * rsnd_preallocate_pages()
258 io->dmac_dev = chan->device->dev;
260 dma_release_channel(chan);
267 static int rsnd_dmaen_pointer(struct rsnd_mod *mod,
268 struct rsnd_dai_stream *io,
269 snd_pcm_uframes_t *pointer)
271 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
272 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
273 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
274 struct dma_tx_state state;
275 enum dma_status status;
276 unsigned int pos = 0;
278 status = dmaengine_tx_status(dmaen->chan, dmaen->cookie, &state);
279 if (status == DMA_IN_PROGRESS || status == DMA_PAUSED) {
280 if (state.residue > 0 && state.residue <= dmaen->dma_len)
281 pos = dmaen->dma_len - state.residue;
283 *pointer = bytes_to_frames(runtime, pos);
288 static struct rsnd_mod_ops rsnd_dmaen_ops = {
290 .nolock_start = rsnd_dmaen_nolock_start,
291 .nolock_stop = rsnd_dmaen_nolock_stop,
292 .start = rsnd_dmaen_start,
293 .stop = rsnd_dmaen_stop,
294 .pointer= rsnd_dmaen_pointer,
298 * Audio DMAC peri peri
300 static const u8 gen2_id_table_ssiu[] = {
312 static const u8 gen2_id_table_scu[] = {
313 0x2d, /* SCU_SRCI0 */
314 0x2e, /* SCU_SRCI1 */
315 0x2f, /* SCU_SRCI2 */
316 0x30, /* SCU_SRCI3 */
317 0x31, /* SCU_SRCI4 */
318 0x32, /* SCU_SRCI5 */
319 0x33, /* SCU_SRCI6 */
320 0x34, /* SCU_SRCI7 */
321 0x35, /* SCU_SRCI8 */
322 0x36, /* SCU_SRCI9 */
324 static const u8 gen2_id_table_cmd[] = {
329 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io,
330 struct rsnd_mod *mod)
332 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
333 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
334 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
335 const u8 *entry = NULL;
336 int id = rsnd_mod_id(mod);
340 entry = gen2_id_table_ssiu;
341 size = ARRAY_SIZE(gen2_id_table_ssiu);
342 } else if (mod == src) {
343 entry = gen2_id_table_scu;
344 size = ARRAY_SIZE(gen2_id_table_scu);
345 } else if (mod == dvc) {
346 entry = gen2_id_table_cmd;
347 size = ARRAY_SIZE(gen2_id_table_cmd);
350 if ((!entry) || (size <= id)) {
351 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io));
353 dev_err(dev, "unknown connection (%s[%d])\n",
354 rsnd_mod_name(mod), rsnd_mod_id(mod));
356 /* use non-prohibited SRS number as error */
357 return 0x00; /* SSI00 */
363 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io,
364 struct rsnd_mod *mod_from,
365 struct rsnd_mod *mod_to)
367 return (rsnd_dmapp_get_id(io, mod_from) << 24) +
368 (rsnd_dmapp_get_id(io, mod_to) << 16);
371 #define rsnd_dmapp_addr(dmac, dma, reg) \
372 (dmac->base + 0x20 + reg + \
373 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id))
374 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg)
376 struct rsnd_mod *mod = rsnd_mod_get(dma);
377 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
378 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
379 struct device *dev = rsnd_priv_to_dev(priv);
381 dev_dbg(dev, "w %p : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data);
383 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg));
386 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg)
388 struct rsnd_mod *mod = rsnd_mod_get(dma);
389 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
390 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
392 return ioread32(rsnd_dmapp_addr(dmac, dma, reg));
395 static void rsnd_dmapp_bset(struct rsnd_dma *dma, u32 data, u32 mask, u32 reg)
397 struct rsnd_mod *mod = rsnd_mod_get(dma);
398 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
399 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
400 void __iomem *addr = rsnd_dmapp_addr(dmac, dma, reg);
401 u32 val = ioread32(addr);
404 val |= (data & mask);
406 iowrite32(val, addr);
409 static int rsnd_dmapp_stop(struct rsnd_mod *mod,
410 struct rsnd_dai_stream *io,
411 struct rsnd_priv *priv)
413 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
416 rsnd_dmapp_bset(dma, 0, PDMACHCR_DE, PDMACHCR);
418 for (i = 0; i < 1024; i++) {
419 if (0 == (rsnd_dmapp_read(dma, PDMACHCR) & PDMACHCR_DE))
427 static int rsnd_dmapp_start(struct rsnd_mod *mod,
428 struct rsnd_dai_stream *io,
429 struct rsnd_priv *priv)
431 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
432 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
434 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR);
435 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR);
436 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR);
441 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io,
442 struct rsnd_dma *dma,
443 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
445 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
446 struct rsnd_priv *priv = rsnd_io_to_priv(io);
447 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
448 struct device *dev = rsnd_priv_to_dev(priv);
450 dmapp->dmapp_id = dmac->dmapp_num;
451 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE;
455 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n",
456 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr);
461 static struct rsnd_mod_ops rsnd_dmapp_ops = {
463 .start = rsnd_dmapp_start,
464 .stop = rsnd_dmapp_stop,
465 .quit = rsnd_dmapp_stop,
469 * Common DMAC Interface
473 * DMA read/write register offset
475 * RSND_xxx_I_N for Audio DMAC input
476 * RSND_xxx_O_N for Audio DMAC output
477 * RSND_xxx_I_P for Audio DMAC peri peri input
478 * RSND_xxx_O_P for Audio DMAC peri peri output
481 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out
482 * SSI : 0xec541000 / 0xec241008 / 0xec24100c
483 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000
484 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000
485 * CMD : 0xec500000 / / 0xec008000 0xec308000
487 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8)
488 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc)
490 #define RDMA_SSIU_I_N(addr, i, j) (addr ##_reg - 0x00441000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400))
491 #define RDMA_SSIU_O_N(addr, i, j) RDMA_SSIU_I_N(addr, i, j)
493 #define RDMA_SSIU_I_P(addr, i, j) (addr ##_reg - 0x00141000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400))
494 #define RDMA_SSIU_O_P(addr, i, j) RDMA_SSIU_I_P(addr, i, j)
496 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i))
497 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i))
499 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i))
500 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i))
502 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i))
503 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i))
506 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io,
507 struct rsnd_mod *mod,
508 int is_play, int is_from)
510 struct rsnd_priv *priv = rsnd_io_to_priv(io);
511 struct device *dev = rsnd_priv_to_dev(priv);
512 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI);
513 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU);
514 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod);
515 int use_src = !!rsnd_io_to_mod_src(io);
516 int use_cmd = !!rsnd_io_to_mod_dvc(io) ||
517 !!rsnd_io_to_mod_mix(io) ||
518 !!rsnd_io_to_mod_ctu(io);
519 int id = rsnd_mod_id(mod);
520 int busif = rsnd_ssi_get_busif(io);
524 } dma_addrs[3][2][3] = {
528 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) },
529 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } },
532 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) },
533 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } }
537 {{{ RDMA_SSI_O_N(ssi, id), 0 },
538 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
539 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
541 {{ 0, RDMA_SSI_I_N(ssi, id) },
542 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
543 { 0, RDMA_SSIU_I_P(ssi, id, busif) } }
547 {{{ RDMA_SSIU_O_N(ssi, id, busif), 0 },
548 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
549 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
551 {{ 0, RDMA_SSIU_I_N(ssi, id, busif) },
552 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
553 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } },
559 * We can't support SSI9-4/5/6/7, because its address is
560 * out of calculation rule
562 if ((id == 9) && (busif >= 4))
563 dev_err(dev, "This driver doesn't support SSI%d-%d, so far",
566 /* it shouldn't happen */
567 if (use_cmd && !use_src)
568 dev_err(dev, "DVC is selected without SRC\n");
570 /* use SSIU or SSI ? */
571 if (is_ssi && rsnd_ssi_use_busif(io))
575 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr :
576 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr;
579 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io,
580 struct rsnd_mod *mod,
581 int is_play, int is_from)
583 struct rsnd_priv *priv = rsnd_io_to_priv(io);
586 * gen1 uses default DMA addr
588 if (rsnd_is_gen1(priv))
594 return rsnd_gen2_dma_addr(io, mod, is_play, is_from);
597 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */
598 static void rsnd_dma_of_path(struct rsnd_mod *this,
599 struct rsnd_dai_stream *io,
601 struct rsnd_mod **mod_from,
602 struct rsnd_mod **mod_to)
604 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
605 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
606 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io);
607 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io);
608 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
609 struct rsnd_mod *mod[MOD_MAX];
610 struct rsnd_mod *mod_start, *mod_end;
611 struct rsnd_priv *priv = rsnd_mod_to_priv(this);
612 struct device *dev = rsnd_priv_to_dev(priv);
619 for (i = 0; i < MOD_MAX; i++) {
621 nr += !!rsnd_io_to_mod(io, i);
626 * [S] -*-> SRC -o-> [E]
627 * [S] -*-> SRC -> DVC -o-> [E]
628 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E]
637 * -o-> Audio DMAC peri peri
639 mod_start = (is_play) ? NULL : ssi;
640 mod_end = (is_play) ? ssi : NULL;
643 mod[idx++] = mod_start;
644 for (i = 1; i < nr; i++) {
663 * -------------+-----+-----+
667 if ((this == ssi) == (is_play)) {
668 *mod_from = mod[idx - 1];
675 dev_dbg(dev, "module connection (this is %s[%d])\n",
676 rsnd_mod_name(this), rsnd_mod_id(this));
677 for (i = 0; i <= idx; i++) {
678 dev_dbg(dev, " %s[%d]%s\n",
679 rsnd_mod_name(mod[i] ? mod[i] : &mem),
680 rsnd_mod_id (mod[i] ? mod[i] : &mem),
681 (mod[i] == *mod_from) ? " from" :
682 (mod[i] == *mod_to) ? " to" : "");
686 static int rsnd_dma_alloc(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
687 struct rsnd_mod **dma_mod)
689 struct rsnd_mod *mod_from = NULL;
690 struct rsnd_mod *mod_to = NULL;
691 struct rsnd_priv *priv = rsnd_io_to_priv(io);
692 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
693 struct device *dev = rsnd_priv_to_dev(priv);
694 struct rsnd_dma *dma;
695 struct rsnd_mod_ops *ops;
696 enum rsnd_mod_type type;
697 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma,
698 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to);
699 int is_play = rsnd_io_is_play(io);
703 * DMA failed. try to PIO mode
705 * rsnd_ssi_fallback()
706 * rsnd_rdai_continuance_probe()
711 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to);
713 /* for Gen2 or later */
714 if (mod_from && mod_to) {
715 ops = &rsnd_dmapp_ops;
716 attach = rsnd_dmapp_attach;
717 dma_id = dmac->dmapp_num;
718 type = RSND_MOD_AUDMAPP;
720 ops = &rsnd_dmaen_ops;
721 attach = rsnd_dmaen_attach;
722 dma_id = dmac->dmaen_num;
723 type = RSND_MOD_AUDMA;
726 /* for Gen1, overwrite */
727 if (rsnd_is_gen1(priv)) {
728 ops = &rsnd_dmaen_ops;
729 attach = rsnd_dmaen_attach;
730 dma_id = dmac->dmaen_num;
731 type = RSND_MOD_AUDMA;
734 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
738 *dma_mod = rsnd_mod_get(dma);
740 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL,
741 rsnd_mod_get_status, type, dma_id);
745 dev_dbg(dev, "%s[%d] %s[%d] -> %s[%d]\n",
746 rsnd_mod_name(*dma_mod), rsnd_mod_id(*dma_mod),
747 rsnd_mod_name(mod_from ? mod_from : &mem),
748 rsnd_mod_id (mod_from ? mod_from : &mem),
749 rsnd_mod_name(mod_to ? mod_to : &mem),
750 rsnd_mod_id (mod_to ? mod_to : &mem));
752 ret = attach(io, dma, mod_from, mod_to);
756 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1);
757 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0);
758 dma->mod_from = mod_from;
759 dma->mod_to = mod_to;
764 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
765 struct rsnd_mod **dma_mod)
768 int ret = rsnd_dma_alloc(io, mod, dma_mod);
774 return rsnd_dai_connect(*dma_mod, io, (*dma_mod)->type);
777 int rsnd_dma_probe(struct rsnd_priv *priv)
779 struct platform_device *pdev = rsnd_priv_to_pdev(priv);
780 struct device *dev = rsnd_priv_to_dev(priv);
781 struct rsnd_dma_ctrl *dmac;
782 struct resource *res;
787 if (rsnd_is_gen1(priv))
793 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp");
794 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL);
796 dev_err(dev, "dma allocate failed\n");
797 return 0; /* it will be PIO mode */
801 dmac->base = devm_ioremap_resource(dev, res);
802 if (IS_ERR(dmac->base))
803 return PTR_ERR(dmac->base);
807 /* dummy mem mod for debug */
808 return rsnd_mod_init(NULL, &mem, &mem_ops, NULL, NULL, 0, 0);