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 {
53 #define rsnd_priv_to_dmac(p) ((struct rsnd_dma_ctrl *)(p)->dma)
54 #define rsnd_mod_to_dma(_mod) container_of((_mod), struct rsnd_dma, mod)
55 #define rsnd_dma_to_dmaen(dma) (&(dma)->dma.en)
56 #define rsnd_dma_to_dmapp(dma) (&(dma)->dma.pp)
59 static struct rsnd_mod_ops mem_ops = {
63 static struct rsnd_mod mem = {
69 static void __rsnd_dmaen_complete(struct rsnd_mod *mod,
70 struct rsnd_dai_stream *io)
72 if (rsnd_io_is_working(io))
73 rsnd_dai_period_elapsed(io);
76 static void rsnd_dmaen_complete(void *data)
78 struct rsnd_mod *mod = data;
80 rsnd_mod_interrupt(mod, __rsnd_dmaen_complete);
83 static struct dma_chan *rsnd_dmaen_request_channel(struct rsnd_dai_stream *io,
84 struct rsnd_mod *mod_from,
85 struct rsnd_mod *mod_to)
87 if ((!mod_from && !mod_to) ||
92 return rsnd_mod_dma_req(io, mod_from);
94 return rsnd_mod_dma_req(io, mod_to);
97 static int rsnd_dmaen_stop(struct rsnd_mod *mod,
98 struct rsnd_dai_stream *io,
99 struct rsnd_priv *priv)
101 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
102 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
105 dmaengine_terminate_async(dmaen->chan);
110 static int rsnd_dmaen_cleanup(struct rsnd_mod *mod,
111 struct rsnd_dai_stream *io,
112 struct rsnd_priv *priv)
114 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
115 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
118 * DMAEngine release uses mutex lock.
119 * Thus, it shouldn't be called under spinlock.
120 * Let's call it under prepare
123 dma_release_channel(dmaen->chan);
130 static int rsnd_dmaen_prepare(struct rsnd_mod *mod,
131 struct rsnd_dai_stream *io,
132 struct rsnd_priv *priv)
134 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
135 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
136 struct device *dev = rsnd_priv_to_dev(priv);
138 /* maybe suspended */
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 enum dma_slave_buswidth buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
170 int is_play = rsnd_io_is_play(io);
174 * in case of monaural data writing or reading through Audio-DMAC
175 * data is always in Left Justified format, so both src and dst
176 * DMA Bus width need to be set equal to physical data width.
178 if (rsnd_runtime_channel_original(io) == 1) {
179 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
180 int bits = snd_pcm_format_physical_width(runtime->format);
184 buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE;
187 buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
190 buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
193 dev_err(dev, "invalid format width %d\n", bits);
198 cfg.direction = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
199 cfg.src_addr = dma->src_addr;
200 cfg.dst_addr = dma->dst_addr;
201 cfg.src_addr_width = buswidth;
202 cfg.dst_addr_width = buswidth;
204 dev_dbg(dev, "%s %pad -> %pad\n",
206 &cfg.src_addr, &cfg.dst_addr);
208 ret = dmaengine_slave_config(dmaen->chan, &cfg);
212 desc = dmaengine_prep_dma_cyclic(dmaen->chan,
213 substream->runtime->dma_addr,
214 snd_pcm_lib_buffer_bytes(substream),
215 snd_pcm_lib_period_bytes(substream),
216 is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM,
217 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
220 dev_err(dev, "dmaengine_prep_slave_sg() fail\n");
224 desc->callback = rsnd_dmaen_complete;
225 desc->callback_param = rsnd_mod_get(dma);
227 dmaen->dma_len = snd_pcm_lib_buffer_bytes(substream);
229 dmaen->cookie = dmaengine_submit(desc);
230 if (dmaen->cookie < 0) {
231 dev_err(dev, "dmaengine_submit() fail\n");
235 dma_async_issue_pending(dmaen->chan);
240 struct dma_chan *rsnd_dma_request_channel(struct device_node *of_node, char *name,
241 struct rsnd_mod *mod, char *x)
243 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
244 struct device *dev = rsnd_priv_to_dev(priv);
245 struct dma_chan *chan = NULL;
246 struct device_node *np;
249 for_each_child_of_node(of_node, np) {
250 i = rsnd_node_fixed_index(dev, np, name, i);
257 if (i == rsnd_mod_id_raw(mod) && (!chan))
258 chan = of_dma_request_slave_channel(np, x);
262 /* It should call of_node_put(), since, it is rsnd_xxx_of_node() */
263 of_node_put(of_node);
268 static int rsnd_dmaen_attach(struct rsnd_dai_stream *io,
269 struct rsnd_dma *dma,
270 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
272 struct rsnd_priv *priv = rsnd_io_to_priv(io);
273 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
274 struct dma_chan *chan;
276 /* try to get DMAEngine channel */
277 chan = rsnd_dmaen_request_channel(io, mod_from, mod_to);
278 if (IS_ERR_OR_NULL(chan)) {
279 /* Let's follow when -EPROBE_DEFER case */
280 if (PTR_ERR(chan) == -EPROBE_DEFER)
281 return PTR_ERR(chan);
284 * DMA failed. try to PIO mode
286 * rsnd_ssi_fallback()
287 * rsnd_rdai_continuance_probe()
293 * use it for IPMMU if needed
295 * rsnd_preallocate_pages()
297 io->dmac_dev = chan->device->dev;
299 dma_release_channel(chan);
306 static int rsnd_dmaen_pointer(struct rsnd_mod *mod,
307 struct rsnd_dai_stream *io,
308 snd_pcm_uframes_t *pointer)
310 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
311 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
312 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
313 struct dma_tx_state state;
314 enum dma_status status;
315 unsigned int pos = 0;
317 status = dmaengine_tx_status(dmaen->chan, dmaen->cookie, &state);
318 if (status == DMA_IN_PROGRESS || status == DMA_PAUSED) {
319 if (state.residue > 0 && state.residue <= dmaen->dma_len)
320 pos = dmaen->dma_len - state.residue;
322 *pointer = bytes_to_frames(runtime, pos);
327 static struct rsnd_mod_ops rsnd_dmaen_ops = {
329 .prepare = rsnd_dmaen_prepare,
330 .cleanup = rsnd_dmaen_cleanup,
331 .start = rsnd_dmaen_start,
332 .stop = rsnd_dmaen_stop,
333 .pointer = rsnd_dmaen_pointer,
334 .get_status = rsnd_mod_get_status,
338 * Audio DMAC peri peri
340 static const u8 gen2_id_table_ssiu[] = {
342 0x00, 0x01, 0x02, 0x03, 0x39, 0x3a, 0x3b, 0x3c,
344 0x04, 0x05, 0x06, 0x07, 0x3d, 0x3e, 0x3f, 0x40,
346 0x08, 0x09, 0x0a, 0x0b, 0x41, 0x42, 0x43, 0x44,
348 0x0c, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b,
350 0x0d, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52,
352 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x12, 0x13, 0x14, 0x15, 0x53, 0x54, 0x55, 0x56,
362 static const u8 gen2_id_table_scu[] = {
363 0x2d, /* SCU_SRCI0 */
364 0x2e, /* SCU_SRCI1 */
365 0x2f, /* SCU_SRCI2 */
366 0x30, /* SCU_SRCI3 */
367 0x31, /* SCU_SRCI4 */
368 0x32, /* SCU_SRCI5 */
369 0x33, /* SCU_SRCI6 */
370 0x34, /* SCU_SRCI7 */
371 0x35, /* SCU_SRCI8 */
372 0x36, /* SCU_SRCI9 */
374 static const u8 gen2_id_table_cmd[] = {
379 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io,
380 struct rsnd_mod *mod)
382 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
383 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io);
384 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
385 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
386 const u8 *entry = NULL;
392 int busif = rsnd_mod_id_sub(ssiu);
394 entry = gen2_id_table_ssiu;
395 size = ARRAY_SIZE(gen2_id_table_ssiu);
396 id = (rsnd_mod_id(mod) * 8) + busif;
397 } else if (mod == src) {
398 entry = gen2_id_table_scu;
399 size = ARRAY_SIZE(gen2_id_table_scu);
400 id = rsnd_mod_id(mod);
401 } else if (mod == dvc) {
402 entry = gen2_id_table_cmd;
403 size = ARRAY_SIZE(gen2_id_table_cmd);
404 id = rsnd_mod_id(mod);
407 if ((!entry) || (size <= id)) {
408 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io));
410 dev_err(dev, "unknown connection (%s)\n", rsnd_mod_name(mod));
412 /* use non-prohibited SRS number as error */
413 return 0x00; /* SSI00 */
419 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io,
420 struct rsnd_mod *mod_from,
421 struct rsnd_mod *mod_to)
423 return (rsnd_dmapp_get_id(io, mod_from) << 24) +
424 (rsnd_dmapp_get_id(io, mod_to) << 16);
427 #define rsnd_dmapp_addr(dmac, dma, reg) \
428 (dmac->ppbase + 0x20 + reg + \
429 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id))
430 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg)
432 struct rsnd_mod *mod = rsnd_mod_get(dma);
433 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
434 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
435 struct device *dev = rsnd_priv_to_dev(priv);
437 dev_dbg(dev, "w 0x%px : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data);
439 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg));
442 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg)
444 struct rsnd_mod *mod = rsnd_mod_get(dma);
445 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
446 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
448 return ioread32(rsnd_dmapp_addr(dmac, dma, reg));
451 static void rsnd_dmapp_bset(struct rsnd_dma *dma, u32 data, u32 mask, u32 reg)
453 struct rsnd_mod *mod = rsnd_mod_get(dma);
454 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
455 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
456 void __iomem *addr = rsnd_dmapp_addr(dmac, dma, reg);
457 u32 val = ioread32(addr);
460 val |= (data & mask);
462 iowrite32(val, addr);
465 static int rsnd_dmapp_stop(struct rsnd_mod *mod,
466 struct rsnd_dai_stream *io,
467 struct rsnd_priv *priv)
469 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
472 rsnd_dmapp_bset(dma, 0, PDMACHCR_DE, PDMACHCR);
474 for (i = 0; i < 1024; i++) {
475 if (0 == (rsnd_dmapp_read(dma, PDMACHCR) & PDMACHCR_DE))
483 static int rsnd_dmapp_start(struct rsnd_mod *mod,
484 struct rsnd_dai_stream *io,
485 struct rsnd_priv *priv)
487 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
488 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
490 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR);
491 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR);
492 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR);
497 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io,
498 struct rsnd_dma *dma,
499 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
501 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
502 struct rsnd_priv *priv = rsnd_io_to_priv(io);
503 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
504 struct device *dev = rsnd_priv_to_dev(priv);
506 dmapp->dmapp_id = dmac->dmapp_num;
507 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE;
511 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n",
512 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr);
517 #ifdef CONFIG_DEBUG_FS
518 static void rsnd_dmapp_debug_info(struct seq_file *m,
519 struct rsnd_dai_stream *io,
520 struct rsnd_mod *mod)
522 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
523 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
524 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
525 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
527 rsnd_debugfs_reg_show(m, dmac->ppres, dmac->ppbase,
528 0x20 + 0x10 * dmapp->dmapp_id, 0x10);
530 #define DEBUG_INFO .debug_info = rsnd_dmapp_debug_info
535 static struct rsnd_mod_ops rsnd_dmapp_ops = {
537 .start = rsnd_dmapp_start,
538 .stop = rsnd_dmapp_stop,
539 .quit = rsnd_dmapp_stop,
540 .get_status = rsnd_mod_get_status,
545 * Common DMAC Interface
549 * DMA read/write register offset
551 * RSND_xxx_I_N for Audio DMAC input
552 * RSND_xxx_O_N for Audio DMAC output
553 * RSND_xxx_I_P for Audio DMAC peri peri input
554 * RSND_xxx_O_P for Audio DMAC peri peri output
557 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out
558 * SSI : 0xec541000 / 0xec241008 / 0xec24100c
559 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000
560 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000
561 * CMD : 0xec500000 / / 0xec008000 0xec308000
563 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8)
564 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc)
566 #define RDMA_SSIU_I_N(addr, i, j) (addr ##_reg - 0x00441000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400) - (0x4000 * ((i) / 9) * ((j) / 4)))
567 #define RDMA_SSIU_O_N(addr, i, j) RDMA_SSIU_I_N(addr, i, j)
569 #define RDMA_SSIU_I_P(addr, i, j) (addr ##_reg - 0x00141000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400) - (0x4000 * ((i) / 9) * ((j) / 4)))
570 #define RDMA_SSIU_O_P(addr, i, j) RDMA_SSIU_I_P(addr, i, j)
572 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i))
573 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i))
575 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i))
576 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i))
578 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i))
579 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i))
582 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io,
583 struct rsnd_mod *mod,
584 int is_play, int is_from)
586 struct rsnd_priv *priv = rsnd_io_to_priv(io);
587 struct device *dev = rsnd_priv_to_dev(priv);
588 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI);
589 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU);
590 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod) ||
591 !!(rsnd_io_to_mod_ssiu(io) == mod);
592 int use_src = !!rsnd_io_to_mod_src(io);
593 int use_cmd = !!rsnd_io_to_mod_dvc(io) ||
594 !!rsnd_io_to_mod_mix(io) ||
595 !!rsnd_io_to_mod_ctu(io);
596 int id = rsnd_mod_id(mod);
597 int busif = rsnd_mod_id_sub(rsnd_io_to_mod_ssiu(io));
601 } dma_addrs[3][2][3] = {
605 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) },
606 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } },
609 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) },
610 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } }
614 {{{ RDMA_SSI_O_N(ssi, id), 0 },
615 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
616 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
618 {{ 0, RDMA_SSI_I_N(ssi, id) },
619 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
620 { 0, RDMA_SSIU_I_P(ssi, id, busif) } }
624 {{{ RDMA_SSIU_O_N(ssi, id, busif), 0 },
625 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
626 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
628 {{ 0, RDMA_SSIU_I_N(ssi, id, busif) },
629 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
630 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } },
636 * We can't support SSI9-4/5/6/7, because its address is
637 * out of calculation rule
639 if ((id == 9) && (busif >= 4))
640 dev_err(dev, "This driver doesn't support SSI%d-%d, so far",
643 /* it shouldn't happen */
644 if (use_cmd && !use_src)
645 dev_err(dev, "DVC is selected without SRC\n");
647 /* use SSIU or SSI ? */
648 if (is_ssi && rsnd_ssi_use_busif(io))
652 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr :
653 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr;
656 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io,
657 struct rsnd_mod *mod,
658 int is_play, int is_from)
660 struct rsnd_priv *priv = rsnd_io_to_priv(io);
663 * gen1 uses default DMA addr
665 if (rsnd_is_gen1(priv))
671 return rsnd_gen2_dma_addr(io, mod, is_play, is_from);
674 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */
675 static void rsnd_dma_of_path(struct rsnd_mod *this,
676 struct rsnd_dai_stream *io,
678 struct rsnd_mod **mod_from,
679 struct rsnd_mod **mod_to)
681 struct rsnd_mod *ssi;
682 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
683 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io);
684 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io);
685 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
686 struct rsnd_mod *mod[MOD_MAX];
687 struct rsnd_mod *mod_start, *mod_end;
688 struct rsnd_priv *priv = rsnd_mod_to_priv(this);
689 struct device *dev = rsnd_priv_to_dev(priv);
693 * It should use "rcar_sound,ssiu" on DT.
694 * But, we need to keep compatibility for old version.
696 * If it has "rcar_sound.ssiu", it will be used.
697 * If not, "rcar_sound.ssi" will be used.
699 * rsnd_ssiu_dma_req()
702 if (rsnd_ssiu_of_node(priv)) {
703 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io);
707 if (this == rsnd_io_to_mod_ssi(io))
710 /* keep compatible, use SSI */
711 ssi = rsnd_io_to_mod_ssi(io);
718 for (i = 0; i < MOD_MAX; i++) {
720 nr += !!rsnd_io_to_mod(io, i);
725 * [S] -*-> SRC -o-> [E]
726 * [S] -*-> SRC -> DVC -o-> [E]
727 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E]
736 * -o-> Audio DMAC peri peri
738 mod_start = (is_play) ? NULL : ssi;
739 mod_end = (is_play) ? ssi : NULL;
742 mod[idx++] = mod_start;
743 for (i = 1; i < nr; i++) {
762 * -------------+-----+-----+
766 if ((this == ssi) == (is_play)) {
767 *mod_from = mod[idx - 1];
774 dev_dbg(dev, "module connection (this is %s)\n", rsnd_mod_name(this));
775 for (i = 0; i <= idx; i++) {
776 dev_dbg(dev, " %s%s\n",
777 rsnd_mod_name(mod[i] ? mod[i] : &mem),
778 (mod[i] == *mod_from) ? " from" :
779 (mod[i] == *mod_to) ? " to" : "");
783 static int rsnd_dma_alloc(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
784 struct rsnd_mod **dma_mod)
786 struct rsnd_mod *mod_from = NULL;
787 struct rsnd_mod *mod_to = NULL;
788 struct rsnd_priv *priv = rsnd_io_to_priv(io);
789 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
790 struct device *dev = rsnd_priv_to_dev(priv);
791 struct rsnd_dma *dma;
792 struct rsnd_mod_ops *ops;
793 enum rsnd_mod_type type;
794 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma,
795 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to);
796 int is_play = rsnd_io_is_play(io);
800 * DMA failed. try to PIO mode
802 * rsnd_ssi_fallback()
803 * rsnd_rdai_continuance_probe()
808 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to);
810 /* for Gen2 or later */
811 if (mod_from && mod_to) {
812 ops = &rsnd_dmapp_ops;
813 attach = rsnd_dmapp_attach;
814 dma_id = dmac->dmapp_num;
815 type = RSND_MOD_AUDMAPP;
817 ops = &rsnd_dmaen_ops;
818 attach = rsnd_dmaen_attach;
819 dma_id = dmac->dmaen_num;
820 type = RSND_MOD_AUDMA;
823 /* for Gen1, overwrite */
824 if (rsnd_is_gen1(priv)) {
825 ops = &rsnd_dmaen_ops;
826 attach = rsnd_dmaen_attach;
827 dma_id = dmac->dmaen_num;
828 type = RSND_MOD_AUDMA;
831 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
835 *dma_mod = rsnd_mod_get(dma);
837 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL,
842 dev_dbg(dev, "%s %s -> %s\n",
843 rsnd_mod_name(*dma_mod),
844 rsnd_mod_name(mod_from ? mod_from : &mem),
845 rsnd_mod_name(mod_to ? mod_to : &mem));
847 ret = attach(io, dma, mod_from, mod_to);
851 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1);
852 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0);
853 dma->mod_from = mod_from;
854 dma->mod_to = mod_to;
859 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
860 struct rsnd_mod **dma_mod)
863 int ret = rsnd_dma_alloc(io, mod, dma_mod);
869 return rsnd_dai_connect(*dma_mod, io, (*dma_mod)->type);
872 int rsnd_dma_probe(struct rsnd_priv *priv)
874 struct platform_device *pdev = rsnd_priv_to_pdev(priv);
875 struct device *dev = rsnd_priv_to_dev(priv);
876 struct rsnd_dma_ctrl *dmac;
877 struct resource *res;
882 if (rsnd_is_gen1(priv))
888 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp");
889 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL);
891 dev_err(dev, "dma allocate failed\n");
892 return 0; /* it will be PIO mode */
896 dmac->ppres = res->start;
897 dmac->ppbase = devm_ioremap_resource(dev, res);
898 if (IS_ERR(dmac->ppbase))
899 return PTR_ERR(dmac->ppbase);
903 /* dummy mem mod for debug */
904 return rsnd_mod_init(NULL, &mem, &mem_ops, NULL, 0, 0);