2 * Renesas R-Car Audio DMAC support
4 * Copyright (C) 2015 Renesas Electronics Corp.
5 * Copyright (c) 2015 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 #include <linux/delay.h>
12 #include <linux/of_dma.h>
16 * Audio DMAC peri peri register
23 #define PDMACHCR_DE (1 << 0)
25 struct rsnd_dma_ctrl {
32 void (*start)(struct rsnd_dai_stream *io, struct rsnd_dma *dma);
33 void (*stop)(struct rsnd_dai_stream *io, struct rsnd_dma *dma);
34 int (*init)(struct rsnd_dai_stream *io, struct rsnd_dma *dma, int id,
35 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to);
36 void (*quit)(struct rsnd_dai_stream *io, struct rsnd_dma *dma);
39 #define rsnd_priv_to_dmac(p) ((struct rsnd_dma_ctrl *)(p)->dma)
44 static void __rsnd_dmaen_complete(struct rsnd_mod *mod,
45 struct rsnd_dai_stream *io)
47 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
52 * Renesas sound Gen1 needs 1 DMAC,
54 * In Gen2 case, it are Audio-DMAC, and Audio-DMAC-peri-peri.
55 * But, Audio-DMAC-peri-peri doesn't have interrupt,
56 * and this driver is assuming that here.
58 * If Audio-DMAC-peri-peri has interrpt,
59 * rsnd_dai_pointer_update() will be called twice,
60 * ant it will breaks io->byte_pos
62 spin_lock_irqsave(&priv->lock, flags);
64 if (rsnd_io_is_working(io))
65 elapsed = rsnd_dai_pointer_update(io, io->byte_per_period);
67 spin_unlock_irqrestore(&priv->lock, flags);
70 rsnd_dai_period_elapsed(io);
73 static void rsnd_dmaen_complete(void *data)
75 struct rsnd_mod *mod = data;
77 rsnd_mod_interrupt(mod, __rsnd_dmaen_complete);
80 static void rsnd_dmaen_stop(struct rsnd_dai_stream *io, struct rsnd_dma *dma)
82 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
84 dmaengine_terminate_all(dmaen->chan);
87 static void rsnd_dmaen_start(struct rsnd_dai_stream *io, struct rsnd_dma *dma)
89 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
90 struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
91 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
92 struct snd_pcm_substream *substream = io->substream;
93 struct device *dev = rsnd_priv_to_dev(priv);
94 struct dma_async_tx_descriptor *desc;
95 int is_play = rsnd_io_is_play(io);
97 desc = dmaengine_prep_dma_cyclic(dmaen->chan,
98 substream->runtime->dma_addr,
99 snd_pcm_lib_buffer_bytes(substream),
100 snd_pcm_lib_period_bytes(substream),
101 is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM,
102 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
105 dev_err(dev, "dmaengine_prep_slave_sg() fail\n");
109 desc->callback = rsnd_dmaen_complete;
110 desc->callback_param = mod;
112 if (dmaengine_submit(desc) < 0) {
113 dev_err(dev, "dmaengine_submit() fail\n");
117 dma_async_issue_pending(dmaen->chan);
120 struct dma_chan *rsnd_dma_request_channel(struct device_node *of_node,
121 struct rsnd_mod *mod, char *name)
123 struct dma_chan *chan;
124 struct device_node *np;
127 for_each_child_of_node(of_node, np) {
128 if (i == rsnd_mod_id(mod))
133 chan = of_dma_request_slave_channel(np, name);
136 of_node_put(of_node);
141 static struct dma_chan *rsnd_dmaen_request_channel(struct rsnd_dai_stream *io,
142 struct rsnd_mod *mod_from,
143 struct rsnd_mod *mod_to)
145 if ((!mod_from && !mod_to) ||
146 (mod_from && mod_to))
150 return rsnd_mod_dma_req(io, mod_from);
152 return rsnd_mod_dma_req(io, mod_to);
155 static int rsnd_dmaen_init(struct rsnd_dai_stream *io,
156 struct rsnd_dma *dma, int id,
157 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
159 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
160 struct rsnd_priv *priv = rsnd_io_to_priv(io);
161 struct device *dev = rsnd_priv_to_dev(priv);
162 struct dma_slave_config cfg = {};
163 int is_play = rsnd_io_is_play(io);
167 dev_err(dev, "it already has dma channel\n");
172 dmaen->chan = rsnd_dmaen_request_channel(io, mod_from, mod_to);
177 dma_cap_set(DMA_SLAVE, mask);
179 dmaen->chan = dma_request_channel(mask, shdma_chan_filter,
180 (void *)(uintptr_t)id);
182 if (IS_ERR_OR_NULL(dmaen->chan)) {
184 dev_err(dev, "can't get dma channel\n");
185 goto rsnd_dma_channel_err;
188 cfg.direction = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
189 cfg.src_addr = dma->src_addr;
190 cfg.dst_addr = dma->dst_addr;
191 cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
192 cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
194 dev_dbg(dev, "%s %pad -> %pad\n",
196 &cfg.src_addr, &cfg.dst_addr);
198 ret = dmaengine_slave_config(dmaen->chan, &cfg);
200 goto rsnd_dma_init_err;
205 rsnd_dma_quit(io, dma);
206 rsnd_dma_channel_err:
209 * DMA failed. try to PIO mode
211 * rsnd_ssi_fallback()
212 * rsnd_rdai_continuance_probe()
217 static void rsnd_dmaen_quit(struct rsnd_dai_stream *io, struct rsnd_dma *dma)
219 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
222 dma_release_channel(dmaen->chan);
227 static struct rsnd_dma_ops rsnd_dmaen_ops = {
229 .start = rsnd_dmaen_start,
230 .stop = rsnd_dmaen_stop,
231 .init = rsnd_dmaen_init,
232 .quit = rsnd_dmaen_quit,
236 * Audio DMAC peri peri
238 static const u8 gen2_id_table_ssiu[] = {
250 static const u8 gen2_id_table_scu[] = {
251 0x2d, /* SCU_SRCI0 */
252 0x2e, /* SCU_SRCI1 */
253 0x2f, /* SCU_SRCI2 */
254 0x30, /* SCU_SRCI3 */
255 0x31, /* SCU_SRCI4 */
256 0x32, /* SCU_SRCI5 */
257 0x33, /* SCU_SRCI6 */
258 0x34, /* SCU_SRCI7 */
259 0x35, /* SCU_SRCI8 */
260 0x36, /* SCU_SRCI9 */
262 static const u8 gen2_id_table_cmd[] = {
267 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io,
268 struct rsnd_mod *mod)
270 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
271 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
272 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
273 const u8 *entry = NULL;
274 int id = rsnd_mod_id(mod);
278 entry = gen2_id_table_ssiu;
279 size = ARRAY_SIZE(gen2_id_table_ssiu);
280 } else if (mod == src) {
281 entry = gen2_id_table_scu;
282 size = ARRAY_SIZE(gen2_id_table_scu);
283 } else if (mod == dvc) {
284 entry = gen2_id_table_cmd;
285 size = ARRAY_SIZE(gen2_id_table_cmd);
297 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io,
298 struct rsnd_mod *mod_from,
299 struct rsnd_mod *mod_to)
301 return (rsnd_dmapp_get_id(io, mod_from) << 24) +
302 (rsnd_dmapp_get_id(io, mod_to) << 16);
305 #define rsnd_dmapp_addr(dmac, dma, reg) \
306 (dmac->base + 0x20 + reg + \
307 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id))
308 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg)
310 struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
311 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
312 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
313 struct device *dev = rsnd_priv_to_dev(priv);
315 dev_dbg(dev, "w %p : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data);
317 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg));
320 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg)
322 struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
323 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
324 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
326 return ioread32(rsnd_dmapp_addr(dmac, dma, reg));
329 static void rsnd_dmapp_stop(struct rsnd_dai_stream *io, struct rsnd_dma *dma)
333 rsnd_dmapp_write(dma, 0, PDMACHCR);
335 for (i = 0; i < 1024; i++) {
336 if (0 == rsnd_dmapp_read(dma, PDMACHCR))
342 static void rsnd_dmapp_start(struct rsnd_dai_stream *io, struct rsnd_dma *dma)
344 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
346 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR);
347 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR);
348 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR);
351 static int rsnd_dmapp_init(struct rsnd_dai_stream *io,
352 struct rsnd_dma *dma, int id,
353 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
355 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
356 struct rsnd_priv *priv = rsnd_io_to_priv(io);
357 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
358 struct device *dev = rsnd_priv_to_dev(priv);
360 dmapp->dmapp_id = dmac->dmapp_num;
361 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE;
365 rsnd_dmapp_stop(io, dma);
367 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n",
368 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr);
373 static struct rsnd_dma_ops rsnd_dmapp_ops = {
375 .start = rsnd_dmapp_start,
376 .stop = rsnd_dmapp_stop,
377 .init = rsnd_dmapp_init,
378 .quit = rsnd_dmapp_stop,
382 * Common DMAC Interface
386 * DMA read/write register offset
388 * RSND_xxx_I_N for Audio DMAC input
389 * RSND_xxx_O_N for Audio DMAC output
390 * RSND_xxx_I_P for Audio DMAC peri peri input
391 * RSND_xxx_O_P for Audio DMAC peri peri output
394 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out
395 * SSI : 0xec541000 / 0xec241008 / 0xec24100c
396 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000
397 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000
398 * CMD : 0xec500000 / / 0xec008000 0xec308000
400 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8)
401 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc)
403 #define RDMA_SSIU_I_N(addr, i) (addr ##_reg - 0x00441000 + (0x1000 * i))
404 #define RDMA_SSIU_O_N(addr, i) (addr ##_reg - 0x00441000 + (0x1000 * i))
406 #define RDMA_SSIU_I_P(addr, i) (addr ##_reg - 0x00141000 + (0x1000 * i))
407 #define RDMA_SSIU_O_P(addr, i) (addr ##_reg - 0x00141000 + (0x1000 * i))
409 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i))
410 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i))
412 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i))
413 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i))
415 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i))
416 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i))
419 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io,
420 struct rsnd_mod *mod,
421 int is_play, int is_from)
423 struct rsnd_priv *priv = rsnd_io_to_priv(io);
424 struct device *dev = rsnd_priv_to_dev(priv);
425 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI);
426 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU);
427 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod);
428 int use_src = !!rsnd_io_to_mod_src(io);
429 int use_cmd = !!rsnd_io_to_mod_dvc(io) ||
430 !!rsnd_io_to_mod_mix(io) ||
431 !!rsnd_io_to_mod_ctu(io);
432 int id = rsnd_mod_id(mod);
436 } dma_addrs[3][2][3] = {
440 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) },
441 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } },
444 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) },
445 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } }
449 {{{ RDMA_SSI_O_N(ssi, id), 0 },
450 { RDMA_SSIU_O_P(ssi, id), 0 },
451 { RDMA_SSIU_O_P(ssi, id), 0 } },
453 {{ 0, RDMA_SSI_I_N(ssi, id) },
454 { 0, RDMA_SSIU_I_P(ssi, id) },
455 { 0, RDMA_SSIU_I_P(ssi, id) } }
459 {{{ RDMA_SSIU_O_N(ssi, id), 0 },
460 { RDMA_SSIU_O_P(ssi, id), 0 },
461 { RDMA_SSIU_O_P(ssi, id), 0 } },
463 {{ 0, RDMA_SSIU_I_N(ssi, id) },
464 { 0, RDMA_SSIU_I_P(ssi, id) },
465 { 0, RDMA_SSIU_I_P(ssi, id) } } },
468 /* it shouldn't happen */
469 if (use_cmd && !use_src)
470 dev_err(dev, "DVC is selected without SRC\n");
472 /* use SSIU or SSI ? */
473 if (is_ssi && rsnd_ssi_use_busif(io))
477 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr :
478 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr;
481 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io,
482 struct rsnd_mod *mod,
483 int is_play, int is_from)
485 struct rsnd_priv *priv = rsnd_io_to_priv(io);
488 * gen1 uses default DMA addr
490 if (rsnd_is_gen1(priv))
496 return rsnd_gen2_dma_addr(io, mod, is_play, is_from);
499 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */
500 static void rsnd_dma_of_path(struct rsnd_dma *dma,
501 struct rsnd_dai_stream *io,
503 struct rsnd_mod **mod_from,
504 struct rsnd_mod **mod_to)
506 struct rsnd_mod *this = rsnd_dma_to_mod(dma);
507 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
508 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
509 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io);
510 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io);
511 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
512 struct rsnd_mod *mod[MOD_MAX];
513 struct rsnd_mod *mod_start, *mod_end;
514 struct rsnd_priv *priv = rsnd_mod_to_priv(this);
515 struct device *dev = rsnd_priv_to_dev(priv);
522 for (i = 0; i < MOD_MAX; i++) {
524 nr += !!rsnd_io_to_mod(io, i);
529 * [S] -*-> SRC -o-> [E]
530 * [S] -*-> SRC -> DVC -o-> [E]
531 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E]
540 * -o-> Audio DMAC peri peri
542 mod_start = (is_play) ? NULL : ssi;
543 mod_end = (is_play) ? ssi : NULL;
546 for (i = 1; i < nr; i++) {
565 * -------------+-----+-----+
569 if ((this == ssi) == (is_play)) {
570 *mod_from = mod[nr - 1];
577 dev_dbg(dev, "module connection (this is %s[%d])\n",
578 rsnd_mod_name(this), rsnd_mod_id(this));
579 for (i = 0; i <= nr; i++) {
580 dev_dbg(dev, " %s[%d]%s\n",
581 rsnd_mod_name(mod[i]), rsnd_mod_id(mod[i]),
582 (mod[i] == *mod_from) ? " from" :
583 (mod[i] == *mod_to) ? " to" : "");
587 void rsnd_dma_stop(struct rsnd_dai_stream *io, struct rsnd_dma *dma)
589 dma->ops->stop(io, dma);
592 void rsnd_dma_start(struct rsnd_dai_stream *io, struct rsnd_dma *dma)
594 dma->ops->start(io, dma);
597 void rsnd_dma_quit(struct rsnd_dai_stream *io, struct rsnd_dma *dma)
599 struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
600 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
601 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
606 dma->ops->quit(io, dma);
609 int rsnd_dma_init(struct rsnd_dai_stream *io, struct rsnd_dma *dma, int id)
611 struct rsnd_mod *mod_from = NULL;
612 struct rsnd_mod *mod_to = NULL;
613 struct rsnd_priv *priv = rsnd_io_to_priv(io);
614 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
615 struct device *dev = rsnd_priv_to_dev(priv);
616 int is_play = rsnd_io_is_play(io);
619 * DMA failed. try to PIO mode
621 * rsnd_ssi_fallback()
622 * rsnd_rdai_continuance_probe()
627 rsnd_dma_of_path(dma, io, is_play, &mod_from, &mod_to);
629 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1);
630 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0);
633 if (mod_from && mod_to)
634 dma->ops = &rsnd_dmapp_ops;
636 dma->ops = &rsnd_dmaen_ops;
638 /* for Gen1, overwrite */
639 if (rsnd_is_gen1(priv))
640 dma->ops = &rsnd_dmaen_ops;
642 dev_dbg(dev, "%s %s[%d] -> %s[%d]\n",
644 rsnd_mod_name(mod_from), rsnd_mod_id(mod_from),
645 rsnd_mod_name(mod_to), rsnd_mod_id(mod_to));
647 return dma->ops->init(io, dma, id, mod_from, mod_to);
650 int rsnd_dma_probe(struct platform_device *pdev,
651 const struct rsnd_of_data *of_data,
652 struct rsnd_priv *priv)
654 struct device *dev = rsnd_priv_to_dev(priv);
655 struct rsnd_dma_ctrl *dmac;
656 struct resource *res;
661 if (rsnd_is_gen1(priv))
667 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp");
668 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL);
670 dev_err(dev, "dma allocate failed\n");
671 return 0; /* it will be PIO mode */
675 dmac->base = devm_ioremap_resource(dev, res);
676 if (IS_ERR(dmac->base))
677 return PTR_ERR(dmac->base);