1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // Renesas R-Car Audio DMAC support
4 //
5 // Copyright (C) 2015 Renesas Electronics Corp.
6 // Copyright (c) 2015 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7
8 #include <linux/delay.h>
9 #include <linux/of_dma.h>
10 #include <sound/dmaengine_pcm.h>
11 #include "rsnd.h"
12
13 /*
14 * Audio DMAC peri peri register
15 */
16 #define PDMASAR 0x00
17 #define PDMADAR 0x04
18 #define PDMACHCR 0x0c
19
20 /* PDMACHCR */
21 #define PDMACHCR_DE (1 << 0)
22
23
24 struct rsnd_dmaen {
25 struct dma_chan *chan;
26 };
27
28 struct rsnd_dmapp {
29 int dmapp_id;
30 u32 chcr;
31 };
32
33 struct rsnd_dma {
34 struct rsnd_mod mod;
35 struct rsnd_mod *mod_from;
36 struct rsnd_mod *mod_to;
37 dma_addr_t src_addr;
38 dma_addr_t dst_addr;
39 union {
40 struct rsnd_dmaen en;
41 struct rsnd_dmapp pp;
42 } dma;
43 };
44
45 struct rsnd_dma_ctrl {
46 void __iomem *ppbase;
47 phys_addr_t ppres;
48 int dmaen_num;
49 int dmapp_num;
50 };
51
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)
56
57 /* for DEBUG */
58 static struct rsnd_mod_ops mem_ops = {
59 .name = "mem",
60 };
61
62 static struct rsnd_mod mem = {
63 };
64
65 /*
66 * Audio DMAC
67 */
rsnd_dmaen_request_channel(struct rsnd_dai_stream * io,struct rsnd_mod * mod_from,struct rsnd_mod * mod_to)68 static struct dma_chan *rsnd_dmaen_request_channel(struct rsnd_dai_stream *io,
69 struct rsnd_mod *mod_from,
70 struct rsnd_mod *mod_to)
71 {
72 if ((!mod_from && !mod_to) ||
73 (mod_from && mod_to))
74 return NULL;
75
76 if (mod_from)
77 return rsnd_mod_dma_req(io, mod_from);
78 else
79 return rsnd_mod_dma_req(io, mod_to);
80 }
81
rsnd_dmaen_stop(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)82 static int rsnd_dmaen_stop(struct rsnd_mod *mod,
83 struct rsnd_dai_stream *io,
84 struct rsnd_priv *priv)
85 {
86 return snd_dmaengine_pcm_trigger(io->substream, SNDRV_PCM_TRIGGER_STOP);
87 }
88
rsnd_dmaen_cleanup(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)89 static int rsnd_dmaen_cleanup(struct rsnd_mod *mod,
90 struct rsnd_dai_stream *io,
91 struct rsnd_priv *priv)
92 {
93 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
94 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
95
96 /*
97 * DMAEngine release uses mutex lock.
98 * Thus, it shouldn't be called under spinlock.
99 * Let's call it under prepare
100 */
101 if (dmaen->chan)
102 snd_dmaengine_pcm_close_release_chan(io->substream);
103
104 dmaen->chan = NULL;
105
106 return 0;
107 }
108
rsnd_dmaen_prepare(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)109 static int rsnd_dmaen_prepare(struct rsnd_mod *mod,
110 struct rsnd_dai_stream *io,
111 struct rsnd_priv *priv)
112 {
113 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
114 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
115 struct device *dev = rsnd_priv_to_dev(priv);
116
117 /* maybe suspended */
118 if (dmaen->chan)
119 return 0;
120
121 /*
122 * DMAEngine request uses mutex lock.
123 * Thus, it shouldn't be called under spinlock.
124 * Let's call it under prepare
125 */
126 dmaen->chan = rsnd_dmaen_request_channel(io,
127 dma->mod_from,
128 dma->mod_to);
129 if (IS_ERR_OR_NULL(dmaen->chan)) {
130 dmaen->chan = NULL;
131 dev_err(dev, "can't get dma channel\n");
132 return -EIO;
133 }
134
135 return snd_dmaengine_pcm_open(io->substream, dmaen->chan);
136 }
137
rsnd_dmaen_start(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)138 static int rsnd_dmaen_start(struct rsnd_mod *mod,
139 struct rsnd_dai_stream *io,
140 struct rsnd_priv *priv)
141 {
142 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
143 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
144 struct device *dev = rsnd_priv_to_dev(priv);
145 struct dma_slave_config cfg = {};
146 enum dma_slave_buswidth buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
147 int ret;
148
149 /*
150 * in case of monaural data writing or reading through Audio-DMAC
151 * data is always in Left Justified format, so both src and dst
152 * DMA Bus width need to be set equal to physical data width.
153 */
154 if (rsnd_runtime_channel_original(io) == 1) {
155 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
156 int bits = snd_pcm_format_physical_width(runtime->format);
157
158 switch (bits) {
159 case 8:
160 buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE;
161 break;
162 case 16:
163 buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
164 break;
165 case 32:
166 buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
167 break;
168 default:
169 dev_err(dev, "invalid format width %d\n", bits);
170 return -EINVAL;
171 }
172 }
173
174 cfg.direction = snd_pcm_substream_to_dma_direction(io->substream);
175 cfg.src_addr = dma->src_addr;
176 cfg.dst_addr = dma->dst_addr;
177 cfg.src_addr_width = buswidth;
178 cfg.dst_addr_width = buswidth;
179
180 dev_dbg(dev, "%s %pad -> %pad\n",
181 rsnd_mod_name(mod),
182 &cfg.src_addr, &cfg.dst_addr);
183
184 ret = dmaengine_slave_config(dmaen->chan, &cfg);
185 if (ret < 0)
186 return ret;
187
188 return snd_dmaengine_pcm_trigger(io->substream, SNDRV_PCM_TRIGGER_START);
189 }
190
rsnd_dma_request_channel(struct device_node * of_node,char * name,struct rsnd_mod * mod,char * x)191 struct dma_chan *rsnd_dma_request_channel(struct device_node *of_node, char *name,
192 struct rsnd_mod *mod, char *x)
193 {
194 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
195 struct device *dev = rsnd_priv_to_dev(priv);
196 struct dma_chan *chan = NULL;
197 struct device_node *np;
198 int i = 0;
199
200 for_each_child_of_node(of_node, np) {
201 i = rsnd_node_fixed_index(dev, np, name, i);
202 if (i < 0) {
203 chan = NULL;
204 of_node_put(np);
205 break;
206 }
207
208 if (i == rsnd_mod_id_raw(mod) && (!chan))
209 chan = of_dma_request_slave_channel(np, x);
210 i++;
211 }
212
213 /* It should call of_node_put(), since, it is rsnd_xxx_of_node() */
214 of_node_put(of_node);
215
216 return chan;
217 }
218
rsnd_dmaen_attach(struct rsnd_dai_stream * io,struct rsnd_dma * dma,struct rsnd_mod * mod_from,struct rsnd_mod * mod_to)219 static int rsnd_dmaen_attach(struct rsnd_dai_stream *io,
220 struct rsnd_dma *dma,
221 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
222 {
223 struct rsnd_priv *priv = rsnd_io_to_priv(io);
224 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
225 struct dma_chan *chan;
226
227 /* try to get DMAEngine channel */
228 chan = rsnd_dmaen_request_channel(io, mod_from, mod_to);
229 if (IS_ERR_OR_NULL(chan)) {
230 /* Let's follow when -EPROBE_DEFER case */
231 if (PTR_ERR(chan) == -EPROBE_DEFER)
232 return PTR_ERR(chan);
233
234 /*
235 * DMA failed. try to PIO mode
236 * see
237 * rsnd_ssi_fallback()
238 * rsnd_rdai_continuance_probe()
239 */
240 return -EAGAIN;
241 }
242
243 /*
244 * use it for IPMMU if needed
245 * see
246 * rsnd_preallocate_pages()
247 */
248 io->dmac_dev = chan->device->dev;
249
250 dma_release_channel(chan);
251
252 dmac->dmaen_num++;
253
254 return 0;
255 }
256
rsnd_dmaen_pointer(struct rsnd_mod * mod,struct rsnd_dai_stream * io,snd_pcm_uframes_t * pointer)257 static int rsnd_dmaen_pointer(struct rsnd_mod *mod,
258 struct rsnd_dai_stream *io,
259 snd_pcm_uframes_t *pointer)
260 {
261 *pointer = snd_dmaengine_pcm_pointer(io->substream);
262
263 return 0;
264 }
265
266 static struct rsnd_mod_ops rsnd_dmaen_ops = {
267 .name = "audmac",
268 .prepare = rsnd_dmaen_prepare,
269 .cleanup = rsnd_dmaen_cleanup,
270 .start = rsnd_dmaen_start,
271 .stop = rsnd_dmaen_stop,
272 .pointer = rsnd_dmaen_pointer,
273 .get_status = rsnd_mod_get_status,
274 };
275
276 /*
277 * Audio DMAC peri peri
278 */
279 static const u8 gen2_id_table_ssiu[] = {
280 /* SSI00 ~ SSI07 */
281 0x00, 0x01, 0x02, 0x03, 0x39, 0x3a, 0x3b, 0x3c,
282 /* SSI10 ~ SSI17 */
283 0x04, 0x05, 0x06, 0x07, 0x3d, 0x3e, 0x3f, 0x40,
284 /* SSI20 ~ SSI27 */
285 0x08, 0x09, 0x0a, 0x0b, 0x41, 0x42, 0x43, 0x44,
286 /* SSI30 ~ SSI37 */
287 0x0c, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b,
288 /* SSI40 ~ SSI47 */
289 0x0d, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52,
290 /* SSI5 */
291 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
292 /* SSI6 */
293 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
294 /* SSI7 */
295 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
296 /* SSI8 */
297 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
298 /* SSI90 ~ SSI97 */
299 0x12, 0x13, 0x14, 0x15, 0x53, 0x54, 0x55, 0x56,
300 };
301 static const u8 gen2_id_table_scu[] = {
302 0x2d, /* SCU_SRCI0 */
303 0x2e, /* SCU_SRCI1 */
304 0x2f, /* SCU_SRCI2 */
305 0x30, /* SCU_SRCI3 */
306 0x31, /* SCU_SRCI4 */
307 0x32, /* SCU_SRCI5 */
308 0x33, /* SCU_SRCI6 */
309 0x34, /* SCU_SRCI7 */
310 0x35, /* SCU_SRCI8 */
311 0x36, /* SCU_SRCI9 */
312 };
313 static const u8 gen2_id_table_cmd[] = {
314 0x37, /* SCU_CMD0 */
315 0x38, /* SCU_CMD1 */
316 };
317
rsnd_dmapp_get_id(struct rsnd_dai_stream * io,struct rsnd_mod * mod)318 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io,
319 struct rsnd_mod *mod)
320 {
321 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
322 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io);
323 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
324 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
325 const u8 *entry = NULL;
326 int id = 255;
327 int size = 0;
328
329 if ((mod == ssi) ||
330 (mod == ssiu)) {
331 int busif = rsnd_mod_id_sub(ssiu);
332
333 entry = gen2_id_table_ssiu;
334 size = ARRAY_SIZE(gen2_id_table_ssiu);
335 id = (rsnd_mod_id(mod) * 8) + busif;
336 } else if (mod == src) {
337 entry = gen2_id_table_scu;
338 size = ARRAY_SIZE(gen2_id_table_scu);
339 id = rsnd_mod_id(mod);
340 } else if (mod == dvc) {
341 entry = gen2_id_table_cmd;
342 size = ARRAY_SIZE(gen2_id_table_cmd);
343 id = rsnd_mod_id(mod);
344 }
345
346 if ((!entry) || (size <= id)) {
347 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io));
348
349 dev_err(dev, "unknown connection (%s)\n", rsnd_mod_name(mod));
350
351 /* use non-prohibited SRS number as error */
352 return 0x00; /* SSI00 */
353 }
354
355 return entry[id];
356 }
357
rsnd_dmapp_get_chcr(struct rsnd_dai_stream * io,struct rsnd_mod * mod_from,struct rsnd_mod * mod_to)358 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io,
359 struct rsnd_mod *mod_from,
360 struct rsnd_mod *mod_to)
361 {
362 return (rsnd_dmapp_get_id(io, mod_from) << 24) +
363 (rsnd_dmapp_get_id(io, mod_to) << 16);
364 }
365
366 #define rsnd_dmapp_addr(dmac, dma, reg) \
367 (dmac->ppbase + 0x20 + reg + \
368 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id))
rsnd_dmapp_write(struct rsnd_dma * dma,u32 data,u32 reg)369 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg)
370 {
371 struct rsnd_mod *mod = rsnd_mod_get(dma);
372 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
373 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
374 struct device *dev = rsnd_priv_to_dev(priv);
375
376 dev_dbg(dev, "w 0x%px : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data);
377
378 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg));
379 }
380
rsnd_dmapp_read(struct rsnd_dma * dma,u32 reg)381 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg)
382 {
383 struct rsnd_mod *mod = rsnd_mod_get(dma);
384 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
385 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
386
387 return ioread32(rsnd_dmapp_addr(dmac, dma, reg));
388 }
389
rsnd_dmapp_bset(struct rsnd_dma * dma,u32 data,u32 mask,u32 reg)390 static void rsnd_dmapp_bset(struct rsnd_dma *dma, u32 data, u32 mask, u32 reg)
391 {
392 struct rsnd_mod *mod = rsnd_mod_get(dma);
393 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
394 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
395 void __iomem *addr = rsnd_dmapp_addr(dmac, dma, reg);
396 u32 val = ioread32(addr);
397
398 val &= ~mask;
399 val |= (data & mask);
400
401 iowrite32(val, addr);
402 }
403
rsnd_dmapp_stop(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)404 static int rsnd_dmapp_stop(struct rsnd_mod *mod,
405 struct rsnd_dai_stream *io,
406 struct rsnd_priv *priv)
407 {
408 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
409 int i;
410
411 rsnd_dmapp_bset(dma, 0, PDMACHCR_DE, PDMACHCR);
412
413 for (i = 0; i < 1024; i++) {
414 if (0 == (rsnd_dmapp_read(dma, PDMACHCR) & PDMACHCR_DE))
415 return 0;
416 udelay(1);
417 }
418
419 return -EIO;
420 }
421
rsnd_dmapp_start(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)422 static int rsnd_dmapp_start(struct rsnd_mod *mod,
423 struct rsnd_dai_stream *io,
424 struct rsnd_priv *priv)
425 {
426 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
427 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
428
429 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR);
430 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR);
431 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR);
432
433 return 0;
434 }
435
rsnd_dmapp_attach(struct rsnd_dai_stream * io,struct rsnd_dma * dma,struct rsnd_mod * mod_from,struct rsnd_mod * mod_to)436 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io,
437 struct rsnd_dma *dma,
438 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
439 {
440 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
441 struct rsnd_priv *priv = rsnd_io_to_priv(io);
442 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
443 struct device *dev = rsnd_priv_to_dev(priv);
444
445 dmapp->dmapp_id = dmac->dmapp_num;
446 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE;
447
448 dmac->dmapp_num++;
449
450 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n",
451 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr);
452
453 return 0;
454 }
455
456 #ifdef CONFIG_DEBUG_FS
rsnd_dmapp_debug_info(struct seq_file * m,struct rsnd_dai_stream * io,struct rsnd_mod * mod)457 static void rsnd_dmapp_debug_info(struct seq_file *m,
458 struct rsnd_dai_stream *io,
459 struct rsnd_mod *mod)
460 {
461 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
462 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
463 struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
464 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
465
466 rsnd_debugfs_reg_show(m, dmac->ppres, dmac->ppbase,
467 0x20 + 0x10 * dmapp->dmapp_id, 0x10);
468 }
469 #define DEBUG_INFO .debug_info = rsnd_dmapp_debug_info
470 #else
471 #define DEBUG_INFO
472 #endif
473
474 static struct rsnd_mod_ops rsnd_dmapp_ops = {
475 .name = "audmac-pp",
476 .start = rsnd_dmapp_start,
477 .stop = rsnd_dmapp_stop,
478 .quit = rsnd_dmapp_stop,
479 .get_status = rsnd_mod_get_status,
480 DEBUG_INFO
481 };
482
483 /*
484 * Common DMAC Interface
485 */
486
487 /*
488 * DMA read/write register offset
489 *
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
494 *
495 * ex) R-Car H2 case
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
501 */
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)
504
505 #define RDMA_SSIU_I_N(addr, i, j) (addr ##_reg - 0x00441000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400) - (0x4000 * ((i) / 9) * ((j) / 4)))
506 #define RDMA_SSIU_O_N(addr, i, j) RDMA_SSIU_I_N(addr, i, j)
507
508 #define RDMA_SSIU_I_P(addr, i, j) (addr ##_reg - 0x00141000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400) - (0x4000 * ((i) / 9) * ((j) / 4)))
509 #define RDMA_SSIU_O_P(addr, i, j) RDMA_SSIU_I_P(addr, i, j)
510
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))
513
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))
516
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))
519
520 static dma_addr_t
rsnd_gen2_dma_addr(struct rsnd_dai_stream * io,struct rsnd_mod * mod,int is_play,int is_from)521 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io,
522 struct rsnd_mod *mod,
523 int is_play, int is_from)
524 {
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_BASE_SSI);
528 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_BASE_SCU);
529 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod) ||
530 !!(rsnd_io_to_mod_ssiu(io) == mod);
531 int use_src = !!rsnd_io_to_mod_src(io);
532 int use_cmd = !!rsnd_io_to_mod_dvc(io) ||
533 !!rsnd_io_to_mod_mix(io) ||
534 !!rsnd_io_to_mod_ctu(io);
535 int id = rsnd_mod_id(mod);
536 int busif = rsnd_mod_id_sub(rsnd_io_to_mod_ssiu(io));
537 struct dma_addr {
538 dma_addr_t out_addr;
539 dma_addr_t in_addr;
540 } dma_addrs[3][2][3] = {
541 /* SRC */
542 /* Capture */
543 {{{ 0, 0 },
544 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) },
545 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } },
546 /* Playback */
547 {{ 0, 0, },
548 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) },
549 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } }
550 },
551 /* SSI */
552 /* Capture */
553 {{{ RDMA_SSI_O_N(ssi, id), 0 },
554 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
555 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
556 /* Playback */
557 {{ 0, RDMA_SSI_I_N(ssi, id) },
558 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
559 { 0, RDMA_SSIU_I_P(ssi, id, busif) } }
560 },
561 /* SSIU */
562 /* Capture */
563 {{{ RDMA_SSIU_O_N(ssi, id, busif), 0 },
564 { RDMA_SSIU_O_P(ssi, id, busif), 0 },
565 { RDMA_SSIU_O_P(ssi, id, busif), 0 } },
566 /* Playback */
567 {{ 0, RDMA_SSIU_I_N(ssi, id, busif) },
568 { 0, RDMA_SSIU_I_P(ssi, id, busif) },
569 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } },
570 };
571
572 /*
573 * FIXME
574 *
575 * We can't support SSI9-4/5/6/7, because its address is
576 * out of calculation rule
577 */
578 if ((id == 9) && (busif >= 4))
579 dev_err(dev, "This driver doesn't support SSI%d-%d, so far",
580 id, busif);
581
582 /* it shouldn't happen */
583 if (use_cmd && !use_src)
584 dev_err(dev, "DVC is selected without SRC\n");
585
586 /* use SSIU or SSI ? */
587 if (is_ssi && rsnd_ssi_use_busif(io))
588 is_ssi++;
589
590 return (is_from) ?
591 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr :
592 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr;
593 }
594
595 /*
596 * Gen4 DMA read/write register offset
597 *
598 * ex) R-Car V4H case
599 * mod / SYS-DMAC in / SYS-DMAC out
600 * SSI_SDMC: 0xec400000 / 0xec400000 / 0xec400000
601 */
602 #define RDMA_SSI_SDMC(addr, i) (addr + (0x8000 * i))
603 static dma_addr_t
rsnd_gen4_dma_addr(struct rsnd_dai_stream * io,struct rsnd_mod * mod,int is_play,int is_from)604 rsnd_gen4_dma_addr(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
605 int is_play, int is_from)
606 {
607 struct rsnd_priv *priv = rsnd_io_to_priv(io);
608 phys_addr_t addr = rsnd_gen_get_phy_addr(priv, RSND_BASE_SDMC);
609 int id = rsnd_mod_id(mod);
610 int busif = rsnd_mod_id_sub(mod);
611
612 /*
613 * SSI0 only is supported
614 */
615 if (id != 0) {
616 struct device *dev = rsnd_priv_to_dev(priv);
617
618 dev_err(dev, "This driver doesn't support non SSI0");
619 return -EINVAL;
620 }
621
622 return RDMA_SSI_SDMC(addr, busif);
623 }
624
rsnd_dma_addr(struct rsnd_dai_stream * io,struct rsnd_mod * mod,int is_play,int is_from)625 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io,
626 struct rsnd_mod *mod,
627 int is_play, int is_from)
628 {
629 struct rsnd_priv *priv = rsnd_io_to_priv(io);
630
631 if (!mod)
632 return 0;
633
634 /*
635 * gen1 uses default DMA addr
636 */
637 if (rsnd_is_gen1(priv))
638 return 0;
639 else if (rsnd_is_gen4(priv))
640 return rsnd_gen4_dma_addr(io, mod, is_play, is_from);
641 else
642 return rsnd_gen2_dma_addr(io, mod, is_play, is_from);
643 }
644
645 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */
rsnd_dma_of_path(struct rsnd_mod * this,struct rsnd_dai_stream * io,int is_play,struct rsnd_mod ** mod_from,struct rsnd_mod ** mod_to)646 static void rsnd_dma_of_path(struct rsnd_mod *this,
647 struct rsnd_dai_stream *io,
648 int is_play,
649 struct rsnd_mod **mod_from,
650 struct rsnd_mod **mod_to)
651 {
652 struct rsnd_mod *ssi;
653 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
654 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io);
655 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io);
656 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
657 struct rsnd_mod *mod[MOD_MAX];
658 struct rsnd_mod *mod_start, *mod_end;
659 struct rsnd_priv *priv = rsnd_mod_to_priv(this);
660 struct device *dev = rsnd_priv_to_dev(priv);
661 int nr, i, idx;
662
663 /*
664 * It should use "rcar_sound,ssiu" on DT.
665 * But, we need to keep compatibility for old version.
666 *
667 * If it has "rcar_sound.ssiu", it will be used.
668 * If not, "rcar_sound.ssi" will be used.
669 * see
670 * rsnd_ssiu_dma_req()
671 * rsnd_ssi_dma_req()
672 */
673 if (rsnd_ssiu_of_node(priv)) {
674 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io);
675
676 /* use SSIU */
677 ssi = ssiu;
678 if (this == rsnd_io_to_mod_ssi(io))
679 this = ssiu;
680 } else {
681 /* keep compatible, use SSI */
682 ssi = rsnd_io_to_mod_ssi(io);
683 }
684
685 if (!ssi)
686 return;
687
688 nr = 0;
689 for (i = 0; i < MOD_MAX; i++) {
690 mod[i] = NULL;
691 nr += !!rsnd_io_to_mod(io, i);
692 }
693
694 /*
695 * [S] -*-> [E]
696 * [S] -*-> SRC -o-> [E]
697 * [S] -*-> SRC -> DVC -o-> [E]
698 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E]
699 *
700 * playback [S] = mem
701 * [E] = SSI
702 *
703 * capture [S] = SSI
704 * [E] = mem
705 *
706 * -*-> Audio DMAC
707 * -o-> Audio DMAC peri peri
708 */
709 mod_start = (is_play) ? NULL : ssi;
710 mod_end = (is_play) ? ssi : NULL;
711
712 idx = 0;
713 mod[idx++] = mod_start;
714 for (i = 1; i < nr; i++) {
715 if (src) {
716 mod[idx++] = src;
717 src = NULL;
718 } else if (ctu) {
719 mod[idx++] = ctu;
720 ctu = NULL;
721 } else if (mix) {
722 mod[idx++] = mix;
723 mix = NULL;
724 } else if (dvc) {
725 mod[idx++] = dvc;
726 dvc = NULL;
727 }
728 }
729 mod[idx] = mod_end;
730
731 /*
732 * | SSI | SRC |
733 * -------------+-----+-----+
734 * is_play | o | * |
735 * !is_play | * | o |
736 */
737 if ((this == ssi) == (is_play)) {
738 *mod_from = mod[idx - 1];
739 *mod_to = mod[idx];
740 } else {
741 *mod_from = mod[0];
742 *mod_to = mod[1];
743 }
744
745 dev_dbg(dev, "module connection (this is %s)\n", rsnd_mod_name(this));
746 for (i = 0; i <= idx; i++) {
747 dev_dbg(dev, " %s%s\n",
748 rsnd_mod_name(mod[i] ? mod[i] : &mem),
749 (mod[i] == *mod_from) ? " from" :
750 (mod[i] == *mod_to) ? " to" : "");
751 }
752 }
753
rsnd_dma_alloc(struct rsnd_dai_stream * io,struct rsnd_mod * mod,struct rsnd_mod ** dma_mod)754 static int rsnd_dma_alloc(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
755 struct rsnd_mod **dma_mod)
756 {
757 struct rsnd_mod *mod_from = NULL;
758 struct rsnd_mod *mod_to = NULL;
759 struct rsnd_priv *priv = rsnd_io_to_priv(io);
760 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
761 struct device *dev = rsnd_priv_to_dev(priv);
762 struct rsnd_dma *dma;
763 struct rsnd_mod_ops *ops;
764 enum rsnd_mod_type type;
765 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma,
766 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to);
767 int is_play = rsnd_io_is_play(io);
768 int ret, dma_id;
769
770 /*
771 * DMA failed. try to PIO mode
772 * see
773 * rsnd_ssi_fallback()
774 * rsnd_rdai_continuance_probe()
775 */
776 if (!dmac)
777 return -EAGAIN;
778
779 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to);
780
781 /* for Gen2 or later */
782 if (mod_from && mod_to) {
783 ops = &rsnd_dmapp_ops;
784 attach = rsnd_dmapp_attach;
785 dma_id = dmac->dmapp_num;
786 type = RSND_MOD_AUDMAPP;
787 } else {
788 ops = &rsnd_dmaen_ops;
789 attach = rsnd_dmaen_attach;
790 dma_id = dmac->dmaen_num;
791 type = RSND_MOD_AUDMA;
792 }
793
794 /* for Gen1, overwrite */
795 if (rsnd_is_gen1(priv)) {
796 ops = &rsnd_dmaen_ops;
797 attach = rsnd_dmaen_attach;
798 dma_id = dmac->dmaen_num;
799 type = RSND_MOD_AUDMA;
800 }
801
802 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
803 if (!dma)
804 return -ENOMEM;
805
806 *dma_mod = rsnd_mod_get(dma);
807
808 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL,
809 type, dma_id);
810 if (ret < 0)
811 return ret;
812
813 dev_dbg(dev, "%s %s -> %s\n",
814 rsnd_mod_name(*dma_mod),
815 rsnd_mod_name(mod_from ? mod_from : &mem),
816 rsnd_mod_name(mod_to ? mod_to : &mem));
817
818 ret = attach(io, dma, mod_from, mod_to);
819 if (ret < 0)
820 return ret;
821
822 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1);
823 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0);
824 dma->mod_from = mod_from;
825 dma->mod_to = mod_to;
826
827 return 0;
828 }
829
rsnd_dma_attach(struct rsnd_dai_stream * io,struct rsnd_mod * mod,struct rsnd_mod ** dma_mod)830 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod,
831 struct rsnd_mod **dma_mod)
832 {
833 if (!(*dma_mod)) {
834 int ret = rsnd_dma_alloc(io, mod, dma_mod);
835
836 if (ret < 0)
837 return ret;
838 }
839
840 return rsnd_dai_connect(*dma_mod, io, (*dma_mod)->type);
841 }
842
rsnd_dma_probe(struct rsnd_priv * priv)843 int rsnd_dma_probe(struct rsnd_priv *priv)
844 {
845 struct platform_device *pdev = rsnd_priv_to_pdev(priv);
846 struct device *dev = rsnd_priv_to_dev(priv);
847 struct rsnd_dma_ctrl *dmac;
848 struct resource *res;
849
850 /*
851 * for Gen1
852 */
853 if (rsnd_is_gen1(priv))
854 return 0;
855
856 /*
857 * for Gen2 or later
858 */
859 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL);
860 if (!dmac) {
861 dev_err(dev, "dma allocate failed\n");
862 return 0; /* it will be PIO mode */
863 }
864
865 /* for Gen4 doesn't have DMA-pp */
866 if (rsnd_is_gen4(priv))
867 goto audmapp_end;
868
869 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp");
870 if (!res) {
871 dev_err(dev, "lack of audmapp in DT\n");
872 return 0; /* it will be PIO mode */
873 }
874
875 dmac->dmapp_num = 0;
876 dmac->ppres = res->start;
877 dmac->ppbase = devm_ioremap_resource(dev, res);
878 if (IS_ERR(dmac->ppbase))
879 return PTR_ERR(dmac->ppbase);
880 audmapp_end:
881 priv->dma = dmac;
882
883 /* dummy mem mod for debug */
884 return rsnd_mod_init(NULL, &mem, &mem_ops, NULL, 0, 0);
885 }
886