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[] = {
302 0x00, 0x01, 0x02, 0x03, 0x39, 0x3a, 0x3b, 0x3c,
304 0x04, 0x05, 0x06, 0x07, 0x3d, 0x3e, 0x3f, 0x40,
306 0x08, 0x09, 0x0a, 0x0b, 0x41, 0x42, 0x43, 0x44,
308 0x0c, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b,
310 0x0d, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52,
312 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x12, 0x13, 0x14, 0x15, 0x53, 0x54, 0x55, 0x56,
322 static const u8 gen2_id_table_scu[] = {
323 0x2d, /* SCU_SRCI0 */
324 0x2e, /* SCU_SRCI1 */
325 0x2f, /* SCU_SRCI2 */
326 0x30, /* SCU_SRCI3 */
327 0x31, /* SCU_SRCI4 */
328 0x32, /* SCU_SRCI5 */
329 0x33, /* SCU_SRCI6 */
330 0x34, /* SCU_SRCI7 */
331 0x35, /* SCU_SRCI8 */
332 0x36, /* SCU_SRCI9 */
334 static const u8 gen2_id_table_cmd[] = {
339 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io,
340 struct rsnd_mod *mod)
342 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
343 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
344 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
345 const u8 *entry = NULL;
350 int busif = rsnd_ssi_get_busif(io);
352 entry = gen2_id_table_ssiu;
353 size = ARRAY_SIZE(gen2_id_table_ssiu);
354 id = (rsnd_mod_id(mod) * 8) + busif;
355 } else if (mod == src) {
356 entry = gen2_id_table_scu;
357 size = ARRAY_SIZE(gen2_id_table_scu);
358 id = rsnd_mod_id(mod);
359 } else if (mod == dvc) {
360 entry = gen2_id_table_cmd;
361 size = ARRAY_SIZE(gen2_id_table_cmd);
362 id = rsnd_mod_id(mod);
365 if ((!entry) || (size <= id)) {
366 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io));
368 dev_err(dev, "unknown connection (%s[%d])\n",
369 rsnd_mod_name(mod), rsnd_mod_id(mod));
371 /* use non-prohibited SRS number as error */
372 return 0x00; /* SSI00 */
378 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io,
379 struct rsnd_mod *mod_from,
380 struct rsnd_mod *mod_to)
382 return (rsnd_dmapp_get_id(io, mod_from) << 24) +
383 (rsnd_dmapp_get_id(io, mod_to) << 16);
386 #define rsnd_dmapp_addr(dmac, dma, reg) \
387 (dmac->base + 0x20 + reg + \
388 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id))
389 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg)
391 struct rsnd_mod *mod = rsnd_mod_get(dma);
392 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
393 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
394 struct device *dev = rsnd_priv_to_dev(priv);
396 dev_dbg(dev, "w %p : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data);
398 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg));
401 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg)
403 struct rsnd_mod *mod = rsnd_mod_get(dma);
404 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
405 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
407 return ioread32(rsnd_dmapp_addr(dmac, dma, reg));
410 static void rsnd_dmapp_bset(struct rsnd_dma *dma, u32 data, u32 mask, u32 reg)
412 struct rsnd_mod *mod = rsnd_mod_get(dma);
413 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
414 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
415 void __iomem *addr = rsnd_dmapp_addr(dmac, dma, reg);
416 u32 val = ioread32(addr);
419 val |= (data & mask);
421 iowrite32(val, addr);
424 static int rsnd_dmapp_stop(struct rsnd_mod *mod,
425 struct rsnd_dai_stream *io,
426 struct rsnd_priv *priv)
428 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
431 rsnd_dmapp_bset(dma, 0, PDMACHCR_DE, PDMACHCR);
433 for (i = 0; i < 1024; i++) {
434 if (0 == (rsnd_dmapp_read(dma, PDMACHCR) & PDMACHCR_DE))
442 static int rsnd_dmapp_start(struct rsnd_mod *mod,
443 struct rsnd_dai_stream *io,
444 struct rsnd_priv *priv)
446 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
447 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
449 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR);
450 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR);
451 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR);
456 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io,
457 struct rsnd_dma *dma,
458 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
460 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
461 struct rsnd_priv *priv = rsnd_io_to_priv(io);
462 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
463 struct device *dev = rsnd_priv_to_dev(priv);
465 dmapp->dmapp_id = dmac->dmapp_num;
466 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE;
470 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n",
471 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr);
476 static struct rsnd_mod_ops rsnd_dmapp_ops = {
478 .start = rsnd_dmapp_start,
479 .stop = rsnd_dmapp_stop,
480 .quit = rsnd_dmapp_stop,
484 * Common DMAC Interface
488 * DMA read/write register offset
490 * RSND_xxx_I_N for Audio DMAC input
491 * RSND_xxx_O_N for Audio DMAC output
492 * RSND_xxx_I_P for Audio DMAC peri peri input
493 * RSND_xxx_O_P for Audio DMAC peri peri output
496 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out
497 * SSI : 0xec541000 / 0xec241008 / 0xec24100c
498 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000
499 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000
500 * CMD : 0xec500000 / / 0xec008000 0xec308000
502 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8)
503 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc)
505 #define RDMA_SSIU_I_N(addr, i, j) (addr ##_reg - 0x00441000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400))
506 #define RDMA_SSIU_O_N(addr, i, j) RDMA_SSIU_I_N(addr, i, j)
508 #define RDMA_SSIU_I_P(addr, i, j) (addr ##_reg - 0x00141000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400))
509 #define RDMA_SSIU_O_P(addr, i, j) RDMA_SSIU_I_P(addr, i, j)
511 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i))
512 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i))
514 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i))
515 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i))
517 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i))
518 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i))
521 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io,
522 struct rsnd_mod *mod,
523 int is_play, int is_from)
525 struct rsnd_priv *priv = rsnd_io_to_priv(io);
526 struct device *dev = rsnd_priv_to_dev(priv);
527 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI);
528 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU);
529 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod);
530 int use_src = !!rsnd_io_to_mod_src(io);
531 int use_cmd = !!rsnd_io_to_mod_dvc(io) ||
532 !!rsnd_io_to_mod_mix(io) ||
533 !!rsnd_io_to_mod_ctu(io);
534 int id = rsnd_mod_id(mod);
535 int busif = rsnd_ssi_get_busif(io);
539 } dma_addrs[3][2][3] = {
543 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) },
544 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } },
547 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) },
548 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } }
552 {{{ RDMA_SSI_O_N(ssi, id), 0 },
553 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
554 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
556 {{ 0, RDMA_SSI_I_N(ssi, id) },
557 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
558 { 0, RDMA_SSIU_I_P(ssi, id, busif) } }
562 {{{ RDMA_SSIU_O_N(ssi, id, busif), 0 },
563 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
564 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
566 {{ 0, RDMA_SSIU_I_N(ssi, id, busif) },
567 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
568 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } },
574 * We can't support SSI9-4/5/6/7, because its address is
575 * out of calculation rule
577 if ((id == 9) && (busif >= 4))
578 dev_err(dev, "This driver doesn't support SSI%d-%d, so far",
581 /* it shouldn't happen */
582 if (use_cmd && !use_src)
583 dev_err(dev, "DVC is selected without SRC\n");
585 /* use SSIU or SSI ? */
586 if (is_ssi && rsnd_ssi_use_busif(io))
590 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr :
591 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr;
594 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io,
595 struct rsnd_mod *mod,
596 int is_play, int is_from)
598 struct rsnd_priv *priv = rsnd_io_to_priv(io);
601 * gen1 uses default DMA addr
603 if (rsnd_is_gen1(priv))
609 return rsnd_gen2_dma_addr(io, mod, is_play, is_from);
612 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */
613 static void rsnd_dma_of_path(struct rsnd_mod *this,
614 struct rsnd_dai_stream *io,
616 struct rsnd_mod **mod_from,
617 struct rsnd_mod **mod_to)
619 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
620 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
621 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io);
622 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io);
623 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
624 struct rsnd_mod *mod[MOD_MAX];
625 struct rsnd_mod *mod_start, *mod_end;
626 struct rsnd_priv *priv = rsnd_mod_to_priv(this);
627 struct device *dev = rsnd_priv_to_dev(priv);
634 for (i = 0; i < MOD_MAX; i++) {
636 nr += !!rsnd_io_to_mod(io, i);
641 * [S] -*-> SRC -o-> [E]
642 * [S] -*-> SRC -> DVC -o-> [E]
643 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E]
652 * -o-> Audio DMAC peri peri
654 mod_start = (is_play) ? NULL : ssi;
655 mod_end = (is_play) ? ssi : NULL;
658 mod[idx++] = mod_start;
659 for (i = 1; i < nr; i++) {
678 * -------------+-----+-----+
682 if ((this == ssi) == (is_play)) {
683 *mod_from = mod[idx - 1];
690 dev_dbg(dev, "module connection (this is %s[%d])\n",
691 rsnd_mod_name(this), rsnd_mod_id(this));
692 for (i = 0; i <= idx; i++) {
693 dev_dbg(dev, " %s[%d]%s\n",
694 rsnd_mod_name(mod[i] ? mod[i] : &mem),
695 rsnd_mod_id (mod[i] ? mod[i] : &mem),
696 (mod[i] == *mod_from) ? " from" :
697 (mod[i] == *mod_to) ? " to" : "");
701 static int rsnd_dma_alloc(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
702 struct rsnd_mod **dma_mod)
704 struct rsnd_mod *mod_from = NULL;
705 struct rsnd_mod *mod_to = NULL;
706 struct rsnd_priv *priv = rsnd_io_to_priv(io);
707 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
708 struct device *dev = rsnd_priv_to_dev(priv);
709 struct rsnd_dma *dma;
710 struct rsnd_mod_ops *ops;
711 enum rsnd_mod_type type;
712 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma,
713 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to);
714 int is_play = rsnd_io_is_play(io);
718 * DMA failed. try to PIO mode
720 * rsnd_ssi_fallback()
721 * rsnd_rdai_continuance_probe()
726 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to);
728 /* for Gen2 or later */
729 if (mod_from && mod_to) {
730 ops = &rsnd_dmapp_ops;
731 attach = rsnd_dmapp_attach;
732 dma_id = dmac->dmapp_num;
733 type = RSND_MOD_AUDMAPP;
735 ops = &rsnd_dmaen_ops;
736 attach = rsnd_dmaen_attach;
737 dma_id = dmac->dmaen_num;
738 type = RSND_MOD_AUDMA;
741 /* for Gen1, overwrite */
742 if (rsnd_is_gen1(priv)) {
743 ops = &rsnd_dmaen_ops;
744 attach = rsnd_dmaen_attach;
745 dma_id = dmac->dmaen_num;
746 type = RSND_MOD_AUDMA;
749 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
753 *dma_mod = rsnd_mod_get(dma);
755 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL,
756 rsnd_mod_get_status, type, dma_id);
760 dev_dbg(dev, "%s[%d] %s[%d] -> %s[%d]\n",
761 rsnd_mod_name(*dma_mod), rsnd_mod_id(*dma_mod),
762 rsnd_mod_name(mod_from ? mod_from : &mem),
763 rsnd_mod_id (mod_from ? mod_from : &mem),
764 rsnd_mod_name(mod_to ? mod_to : &mem),
765 rsnd_mod_id (mod_to ? mod_to : &mem));
767 ret = attach(io, dma, mod_from, mod_to);
771 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1);
772 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0);
773 dma->mod_from = mod_from;
774 dma->mod_to = mod_to;
779 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
780 struct rsnd_mod **dma_mod)
783 int ret = rsnd_dma_alloc(io, mod, dma_mod);
789 return rsnd_dai_connect(*dma_mod, io, (*dma_mod)->type);
792 int rsnd_dma_probe(struct rsnd_priv *priv)
794 struct platform_device *pdev = rsnd_priv_to_pdev(priv);
795 struct device *dev = rsnd_priv_to_dev(priv);
796 struct rsnd_dma_ctrl *dmac;
797 struct resource *res;
802 if (rsnd_is_gen1(priv))
808 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp");
809 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL);
811 dev_err(dev, "dma allocate failed\n");
812 return 0; /* it will be PIO mode */
816 dmac->base = devm_ioremap_resource(dev, res);
817 if (IS_ERR(dmac->base))
818 return PTR_ERR(dmac->base);
822 /* dummy mem mod for debug */
823 return rsnd_mod_init(NULL, &mem, &mem_ops, NULL, NULL, 0, 0);