1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // Renesas R-Car SRC support
4 //
5 // Copyright (C) 2013 Renesas Solutions Corp.
6 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7
8 /*
9 * You can use Synchronous Sampling Rate Convert (if no DVC)
10 *
11 * amixer set "SRC Out Rate" on
12 * aplay xxx.wav &
13 * amixer set "SRC Out Rate" 96000 // convert rate to 96000Hz
14 * amixer set "SRC Out Rate" 22050 // convert rate to 22050Hz
15 */
16
17 /*
18 * you can enable below define if you don't need
19 * SSI interrupt status debug message when debugging
20 * see rsnd_print_irq_status()
21 *
22 * #define RSND_DEBUG_NO_IRQ_STATUS 1
23 */
24
25 #include "rsnd.h"
26
27 #define SRC_NAME "src"
28
29 /* SCU_SYSTEM_STATUS0/1 */
30 #define OUF_SRC(id) ((1 << (id + 16)) | (1 << id))
31
32 struct rsnd_src {
33 struct rsnd_mod mod;
34 struct rsnd_mod *dma;
35 struct rsnd_kctrl_cfg_s sen; /* sync convert enable */
36 struct rsnd_kctrl_cfg_s sync; /* sync convert */
37 u32 current_sync_rate;
38 int irq;
39 };
40
41 #define RSND_SRC_NAME_SIZE 16
42
43 #define rsnd_src_get(priv, id) ((struct rsnd_src *)(priv->src) + id)
44 #define rsnd_src_nr(priv) ((priv)->src_nr)
45 #define rsnd_src_sync_is_enabled(mod) (rsnd_mod_to_src(mod)->sen.val)
46
47 #define rsnd_mod_to_src(_mod) \
48 container_of((_mod), struct rsnd_src, mod)
49
50 #define for_each_rsnd_src(pos, priv, i) \
51 for ((i) = 0; \
52 ((i) < rsnd_src_nr(priv)) && \
53 ((pos) = (struct rsnd_src *)(priv)->src + i); \
54 i++)
55
56
57 /*
58 * image of SRC (Sampling Rate Converter)
59 *
60 * 96kHz <-> +-----+ 48kHz +-----+ 48kHz +-------+
61 * 48kHz <-> | SRC | <------> | SSI | <-----> | codec |
62 * 44.1kHz <-> +-----+ +-----+ +-------+
63 * ...
64 *
65 */
66
rsnd_src_activation(struct rsnd_mod * mod)67 static void rsnd_src_activation(struct rsnd_mod *mod)
68 {
69 rsnd_mod_write(mod, SRC_SWRSR, 0);
70 rsnd_mod_write(mod, SRC_SWRSR, 1);
71 }
72
rsnd_src_halt(struct rsnd_mod * mod)73 static void rsnd_src_halt(struct rsnd_mod *mod)
74 {
75 rsnd_mod_write(mod, SRC_SRCIR, 1);
76 rsnd_mod_write(mod, SRC_SWRSR, 0);
77 }
78
rsnd_src_dma_req(struct rsnd_dai_stream * io,struct rsnd_mod * mod)79 static struct dma_chan *rsnd_src_dma_req(struct rsnd_dai_stream *io,
80 struct rsnd_mod *mod)
81 {
82 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
83 int is_play = rsnd_io_is_play(io);
84
85 return rsnd_dma_request_channel(rsnd_src_of_node(priv),
86 SRC_NAME, mod,
87 is_play ? "rx" : "tx");
88 }
89
rsnd_src_convert_rate(struct rsnd_dai_stream * io,struct rsnd_mod * mod)90 static u32 rsnd_src_convert_rate(struct rsnd_dai_stream *io,
91 struct rsnd_mod *mod)
92 {
93 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
94 struct rsnd_src *src = rsnd_mod_to_src(mod);
95 u32 convert_rate;
96
97 if (!runtime)
98 return 0;
99
100 if (!rsnd_src_sync_is_enabled(mod))
101 return rsnd_io_converted_rate(io);
102
103 convert_rate = src->current_sync_rate;
104
105 if (!convert_rate)
106 convert_rate = rsnd_io_converted_rate(io);
107
108 if (!convert_rate)
109 convert_rate = runtime->rate;
110
111 return convert_rate;
112 }
113
rsnd_src_get_rate(struct rsnd_priv * priv,struct rsnd_dai_stream * io,int is_in)114 unsigned int rsnd_src_get_rate(struct rsnd_priv *priv,
115 struct rsnd_dai_stream *io,
116 int is_in)
117 {
118 struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
119 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
120 unsigned int rate = 0;
121 int is_play = rsnd_io_is_play(io);
122
123 /*
124 * Playback
125 * runtime_rate -> [SRC] -> convert_rate
126 *
127 * Capture
128 * convert_rate -> [SRC] -> runtime_rate
129 */
130
131 if (is_play == is_in)
132 return runtime->rate;
133
134 /*
135 * return convert rate if SRC is used,
136 * otherwise, return runtime->rate as usual
137 */
138 if (src_mod)
139 rate = rsnd_src_convert_rate(io, src_mod);
140
141 if (!rate)
142 rate = runtime->rate;
143
144 return rate;
145 }
146
147 static const u32 bsdsr_table_pattern1[] = {
148 0x01800000, /* 6 - 1/6 */
149 0x01000000, /* 6 - 1/4 */
150 0x00c00000, /* 6 - 1/3 */
151 0x00800000, /* 6 - 1/2 */
152 0x00600000, /* 6 - 2/3 */
153 0x00400000, /* 6 - 1 */
154 };
155
156 static const u32 bsdsr_table_pattern2[] = {
157 0x02400000, /* 6 - 1/6 */
158 0x01800000, /* 6 - 1/4 */
159 0x01200000, /* 6 - 1/3 */
160 0x00c00000, /* 6 - 1/2 */
161 0x00900000, /* 6 - 2/3 */
162 0x00600000, /* 6 - 1 */
163 };
164
165 static const u32 bsisr_table[] = {
166 0x00100060, /* 6 - 1/6 */
167 0x00100040, /* 6 - 1/4 */
168 0x00100030, /* 6 - 1/3 */
169 0x00100020, /* 6 - 1/2 */
170 0x00100020, /* 6 - 2/3 */
171 0x00100020, /* 6 - 1 */
172 };
173
174 static const u32 chan288888[] = {
175 0x00000006, /* 1 to 2 */
176 0x000001fe, /* 1 to 8 */
177 0x000001fe, /* 1 to 8 */
178 0x000001fe, /* 1 to 8 */
179 0x000001fe, /* 1 to 8 */
180 0x000001fe, /* 1 to 8 */
181 };
182
183 static const u32 chan244888[] = {
184 0x00000006, /* 1 to 2 */
185 0x0000001e, /* 1 to 4 */
186 0x0000001e, /* 1 to 4 */
187 0x000001fe, /* 1 to 8 */
188 0x000001fe, /* 1 to 8 */
189 0x000001fe, /* 1 to 8 */
190 };
191
192 static const u32 chan222222[] = {
193 0x00000006, /* 1 to 2 */
194 0x00000006, /* 1 to 2 */
195 0x00000006, /* 1 to 2 */
196 0x00000006, /* 1 to 2 */
197 0x00000006, /* 1 to 2 */
198 0x00000006, /* 1 to 2 */
199 };
200
rsnd_src_set_convert_rate(struct rsnd_dai_stream * io,struct rsnd_mod * mod)201 static void rsnd_src_set_convert_rate(struct rsnd_dai_stream *io,
202 struct rsnd_mod *mod)
203 {
204 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
205 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
206 struct rsnd_src *src = rsnd_mod_to_src(mod);
207 u32 fin, fout, new_rate;
208 int inc, cnt, rate;
209 u64 base, val;
210
211 if (!runtime)
212 return;
213
214 if (!rsnd_src_sync_is_enabled(mod))
215 return;
216
217 fin = rsnd_src_get_in_rate(priv, io);
218 fout = rsnd_src_get_out_rate(priv, io);
219
220 new_rate = src->sync.val;
221
222 if (!new_rate)
223 new_rate = fout;
224
225 /* Do nothing if no diff */
226 if (new_rate == src->current_sync_rate)
227 return;
228
229 /*
230 * SRCm_IFSVR::INTIFS can change within 1%
231 * see
232 * SRCm_IFSVR::INTIFS Note
233 */
234 inc = fout / 100;
235 cnt = abs(new_rate - fout) / inc;
236 if (fout > new_rate)
237 inc *= -1;
238
239 /*
240 * After start running SRC, we can update only SRC_IFSVR
241 * for Synchronous Mode
242 */
243 base = (u64)0x0400000 * fin;
244 rate = fout;
245 for (int i = 0; i < cnt; i++) {
246 val = base;
247 rate += inc;
248 do_div(val, rate);
249
250 rsnd_mod_write(mod, SRC_IFSVR, val);
251 }
252 val = base;
253 do_div(val, new_rate);
254
255 rsnd_mod_write(mod, SRC_IFSVR, val);
256
257 /* update current_sync_rate */
258 src->current_sync_rate = new_rate;
259 }
260
rsnd_src_init_convert_rate(struct rsnd_dai_stream * io,struct rsnd_mod * mod)261 static void rsnd_src_init_convert_rate(struct rsnd_dai_stream *io,
262 struct rsnd_mod *mod)
263 {
264 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
265 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
266 struct device *dev = rsnd_priv_to_dev(priv);
267 int is_play = rsnd_io_is_play(io);
268 int use_src = 0;
269 u32 fin, fout;
270 u32 ifscr, adinr;
271 u32 cr, route;
272 u32 i_busif, o_busif, tmp;
273 const u32 *bsdsr_table;
274 const u32 *chptn;
275 uint ratio;
276 int chan;
277 int idx;
278
279 if (!runtime)
280 return;
281
282 fin = rsnd_src_get_in_rate(priv, io);
283 fout = rsnd_src_get_out_rate(priv, io);
284
285 chan = rsnd_runtime_channel_original(io);
286
287 /* 6 - 1/6 are very enough ratio for SRC_BSDSR */
288 if (fin == fout)
289 ratio = 0;
290 else if (fin > fout)
291 ratio = 100 * fin / fout;
292 else
293 ratio = 100 * fout / fin;
294
295 if (ratio > 600) {
296 dev_err(dev, "FSO/FSI ratio error\n");
297 return;
298 }
299
300 use_src = (fin != fout) | rsnd_src_sync_is_enabled(mod);
301
302 /*
303 * SRC_ADINR
304 */
305 adinr = rsnd_get_adinr_bit(mod, io) | chan;
306
307 /*
308 * SRC_IFSCR
309 * SRC_SRCCR / SRC_ROUTE_MODE0
310 */
311 ifscr = 0;
312 cr = 0x00011110;
313 route = 0x0;
314 if (use_src) {
315 route = 0x1;
316 ifscr = 0x1;
317
318 if (rsnd_src_sync_is_enabled(mod)) {
319 cr |= 0x1;
320 route |= rsnd_io_is_play(io) ?
321 (0x1 << 24) : (0x1 << 25);
322 }
323 }
324
325 /*
326 * SRC_BSDSR / SRC_BSISR
327 *
328 * see
329 * Combination of Register Setting Related to
330 * FSO/FSI Ratio and Channel, Latency
331 */
332 switch (rsnd_mod_id(mod)) {
333 case 0:
334 chptn = chan288888;
335 bsdsr_table = bsdsr_table_pattern1;
336 break;
337 case 1:
338 case 3:
339 case 4:
340 chptn = chan244888;
341 bsdsr_table = bsdsr_table_pattern1;
342 break;
343 case 2:
344 case 9:
345 chptn = chan222222;
346 bsdsr_table = bsdsr_table_pattern1;
347 break;
348 case 5:
349 case 6:
350 case 7:
351 case 8:
352 chptn = chan222222;
353 bsdsr_table = bsdsr_table_pattern2;
354 break;
355 default:
356 goto convert_rate_err;
357 }
358
359 /*
360 * E3 need to overwrite
361 */
362 if (rsnd_is_e3(priv))
363 switch (rsnd_mod_id(mod)) {
364 case 0:
365 case 4:
366 chptn = chan222222;
367 }
368
369 for (idx = 0; idx < ARRAY_SIZE(chan222222); idx++)
370 if (chptn[idx] & (1 << chan))
371 break;
372
373 if (chan > 8 ||
374 idx >= ARRAY_SIZE(chan222222))
375 goto convert_rate_err;
376
377 /* BUSIF_MODE */
378 tmp = rsnd_get_busif_shift(io, mod);
379 i_busif = ( is_play ? tmp : 0) | 1;
380 o_busif = (!is_play ? tmp : 0) | 1;
381
382 rsnd_mod_write(mod, SRC_ROUTE_MODE0, route);
383
384 rsnd_mod_write(mod, SRC_SRCIR, 1); /* initialize */
385 rsnd_mod_write(mod, SRC_ADINR, adinr);
386 rsnd_mod_write(mod, SRC_IFSCR, ifscr);
387 rsnd_mod_write(mod, SRC_SRCCR, cr);
388 rsnd_mod_write(mod, SRC_BSDSR, bsdsr_table[idx]);
389 rsnd_mod_write(mod, SRC_BSISR, bsisr_table[idx]);
390 rsnd_mod_write(mod, SRC_SRCIR, 0); /* cancel initialize */
391
392 rsnd_mod_write(mod, SRC_I_BUSIF_MODE, i_busif);
393 rsnd_mod_write(mod, SRC_O_BUSIF_MODE, o_busif);
394
395 rsnd_mod_write(mod, SRC_BUSIF_DALIGN, rsnd_get_dalign(mod, io));
396
397 rsnd_adg_set_src_timesel_gen2(mod, io, fin, fout);
398
399 /* update SRC_IFSVR */
400 rsnd_src_set_convert_rate(io, mod);
401
402 return;
403
404 convert_rate_err:
405 dev_err(dev, "unknown BSDSR/BSDIR settings\n");
406 }
407
rsnd_src_irq(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv,int enable)408 static int rsnd_src_irq(struct rsnd_mod *mod,
409 struct rsnd_dai_stream *io,
410 struct rsnd_priv *priv,
411 int enable)
412 {
413 struct rsnd_src *src = rsnd_mod_to_src(mod);
414 u32 sys_int_val, int_val, sys_int_mask;
415 int irq = src->irq;
416 int id = rsnd_mod_id(mod);
417
418 sys_int_val =
419 sys_int_mask = OUF_SRC(id);
420 int_val = 0x3300;
421
422 /*
423 * IRQ is not supported on non-DT
424 * see
425 * rsnd_src_probe_()
426 */
427 if ((irq <= 0) || !enable) {
428 sys_int_val = 0;
429 int_val = 0;
430 }
431
432 /*
433 * WORKAROUND
434 *
435 * ignore over flow error when rsnd_src_sync_is_enabled()
436 */
437 if (rsnd_src_sync_is_enabled(mod))
438 sys_int_val = sys_int_val & 0xffff;
439
440 rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val);
441 rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val);
442 rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val);
443
444 return 0;
445 }
446
rsnd_src_status_clear(struct rsnd_mod * mod)447 static void rsnd_src_status_clear(struct rsnd_mod *mod)
448 {
449 u32 val = OUF_SRC(rsnd_mod_id(mod));
450
451 rsnd_mod_write(mod, SCU_SYS_STATUS0, val);
452 rsnd_mod_write(mod, SCU_SYS_STATUS1, val);
453 }
454
rsnd_src_error_occurred(struct rsnd_mod * mod)455 static bool rsnd_src_error_occurred(struct rsnd_mod *mod)
456 {
457 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
458 struct device *dev = rsnd_priv_to_dev(priv);
459 u32 val0, val1;
460 u32 status0, status1;
461 bool ret = false;
462
463 val0 = val1 = OUF_SRC(rsnd_mod_id(mod));
464
465 /*
466 * WORKAROUND
467 *
468 * ignore over flow error when rsnd_src_sync_is_enabled()
469 */
470 if (rsnd_src_sync_is_enabled(mod))
471 val0 = val0 & 0xffff;
472
473 status0 = rsnd_mod_read(mod, SCU_SYS_STATUS0);
474 status1 = rsnd_mod_read(mod, SCU_SYS_STATUS1);
475 if ((status0 & val0) || (status1 & val1)) {
476 rsnd_print_irq_status(dev, "%s err status : 0x%08x, 0x%08x\n",
477 rsnd_mod_name(mod), status0, status1);
478
479 ret = true;
480 }
481
482 return ret;
483 }
484
rsnd_src_start(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)485 static int rsnd_src_start(struct rsnd_mod *mod,
486 struct rsnd_dai_stream *io,
487 struct rsnd_priv *priv)
488 {
489 u32 val;
490
491 /*
492 * WORKAROUND
493 *
494 * Enable SRC output if you want to use sync convert together with DVC
495 */
496 val = (rsnd_io_to_mod_dvc(io) && !rsnd_src_sync_is_enabled(mod)) ?
497 0x01 : 0x11;
498
499 rsnd_mod_write(mod, SRC_CTRL, val);
500
501 return 0;
502 }
503
rsnd_src_stop(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)504 static int rsnd_src_stop(struct rsnd_mod *mod,
505 struct rsnd_dai_stream *io,
506 struct rsnd_priv *priv)
507 {
508 rsnd_mod_write(mod, SRC_CTRL, 0);
509
510 return 0;
511 }
512
rsnd_src_init(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)513 static int rsnd_src_init(struct rsnd_mod *mod,
514 struct rsnd_dai_stream *io,
515 struct rsnd_priv *priv)
516 {
517 struct rsnd_src *src = rsnd_mod_to_src(mod);
518 int ret;
519
520 /* reset sync convert_rate */
521 src->sync.val =
522 src->current_sync_rate = 0;
523
524 ret = rsnd_mod_power_on(mod);
525 if (ret < 0)
526 return ret;
527
528 rsnd_src_activation(mod);
529
530 rsnd_src_init_convert_rate(io, mod);
531
532 rsnd_src_status_clear(mod);
533
534 return 0;
535 }
536
rsnd_src_quit(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)537 static int rsnd_src_quit(struct rsnd_mod *mod,
538 struct rsnd_dai_stream *io,
539 struct rsnd_priv *priv)
540 {
541 struct rsnd_src *src = rsnd_mod_to_src(mod);
542
543 rsnd_src_halt(mod);
544
545 rsnd_mod_power_off(mod);
546
547 /* reset sync convert_rate */
548 src->sync.val =
549 src->current_sync_rate = 0;
550
551 return 0;
552 }
553
__rsnd_src_interrupt(struct rsnd_mod * mod,struct rsnd_dai_stream * io)554 static void __rsnd_src_interrupt(struct rsnd_mod *mod,
555 struct rsnd_dai_stream *io)
556 {
557 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
558 bool stop = false;
559
560 spin_lock(&priv->lock);
561
562 /* ignore all cases if not working */
563 if (!rsnd_io_is_working(io))
564 goto rsnd_src_interrupt_out;
565
566 if (rsnd_src_error_occurred(mod))
567 stop = true;
568
569 rsnd_src_status_clear(mod);
570 rsnd_src_interrupt_out:
571
572 spin_unlock(&priv->lock);
573
574 if (stop)
575 snd_pcm_stop_xrun(io->substream);
576 }
577
rsnd_src_interrupt(int irq,void * data)578 static irqreturn_t rsnd_src_interrupt(int irq, void *data)
579 {
580 struct rsnd_mod *mod = data;
581
582 rsnd_mod_interrupt(mod, __rsnd_src_interrupt);
583
584 return IRQ_HANDLED;
585 }
586
rsnd_src_kctrl_accept_runtime(struct rsnd_dai_stream * io)587 static int rsnd_src_kctrl_accept_runtime(struct rsnd_dai_stream *io)
588 {
589 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
590
591 if (!runtime) {
592 struct rsnd_priv *priv = rsnd_io_to_priv(io);
593 struct device *dev = rsnd_priv_to_dev(priv);
594
595 dev_warn(dev, "\"SRC Out Rate\" can use during running\n");
596
597 return 0;
598 }
599
600 return 1;
601 }
602
rsnd_src_probe_(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct rsnd_priv * priv)603 static int rsnd_src_probe_(struct rsnd_mod *mod,
604 struct rsnd_dai_stream *io,
605 struct rsnd_priv *priv)
606 {
607 struct rsnd_src *src = rsnd_mod_to_src(mod);
608 struct device *dev = rsnd_priv_to_dev(priv);
609 int irq = src->irq;
610 int ret;
611
612 if (irq > 0) {
613 /*
614 * IRQ is not supported on non-DT
615 * see
616 * rsnd_src_irq()
617 */
618 ret = devm_request_irq(dev, irq,
619 rsnd_src_interrupt,
620 IRQF_SHARED,
621 dev_name(dev), mod);
622 if (ret)
623 return ret;
624 }
625
626 ret = rsnd_dma_attach(io, mod, &src->dma);
627
628 return ret;
629 }
630
rsnd_src_pcm_new(struct rsnd_mod * mod,struct rsnd_dai_stream * io,struct snd_soc_pcm_runtime * rtd)631 static int rsnd_src_pcm_new(struct rsnd_mod *mod,
632 struct rsnd_dai_stream *io,
633 struct snd_soc_pcm_runtime *rtd)
634 {
635 struct rsnd_src *src = rsnd_mod_to_src(mod);
636 int ret;
637
638 /*
639 * enable SRC sync convert if possible
640 */
641
642 /*
643 * It can't use SRC Synchronous convert
644 * when Capture if it uses CMD
645 */
646 if (rsnd_io_to_mod_cmd(io) && !rsnd_io_is_play(io))
647 return 0;
648
649 /*
650 * enable sync convert
651 */
652 ret = rsnd_kctrl_new_s(mod, io, rtd,
653 rsnd_io_is_play(io) ?
654 "SRC Out Rate Switch" :
655 "SRC In Rate Switch",
656 rsnd_kctrl_accept_anytime,
657 rsnd_src_init_convert_rate,
658 &src->sen, 1);
659 if (ret < 0)
660 return ret;
661
662 ret = rsnd_kctrl_new_s(mod, io, rtd,
663 rsnd_io_is_play(io) ?
664 "SRC Out Rate" :
665 "SRC In Rate",
666 rsnd_src_kctrl_accept_runtime,
667 rsnd_src_set_convert_rate,
668 &src->sync, 192000);
669
670 return ret;
671 }
672
673 #ifdef CONFIG_DEBUG_FS
rsnd_src_debug_info(struct seq_file * m,struct rsnd_dai_stream * io,struct rsnd_mod * mod)674 static void rsnd_src_debug_info(struct seq_file *m,
675 struct rsnd_dai_stream *io,
676 struct rsnd_mod *mod)
677 {
678 rsnd_debugfs_mod_reg_show(m, mod, RSND_GEN2_SCU,
679 rsnd_mod_id(mod) * 0x20, 0x20);
680 seq_puts(m, "\n");
681 rsnd_debugfs_mod_reg_show(m, mod, RSND_GEN2_SCU,
682 0x1c0, 0x20);
683 seq_puts(m, "\n");
684 rsnd_debugfs_mod_reg_show(m, mod, RSND_GEN2_SCU,
685 0x200 + rsnd_mod_id(mod) * 0x40, 0x40);
686 }
687 #define DEBUG_INFO .debug_info = rsnd_src_debug_info
688 #else
689 #define DEBUG_INFO
690 #endif
691
692 static struct rsnd_mod_ops rsnd_src_ops = {
693 .name = SRC_NAME,
694 .dma_req = rsnd_src_dma_req,
695 .probe = rsnd_src_probe_,
696 .init = rsnd_src_init,
697 .quit = rsnd_src_quit,
698 .start = rsnd_src_start,
699 .stop = rsnd_src_stop,
700 .irq = rsnd_src_irq,
701 .pcm_new = rsnd_src_pcm_new,
702 .get_status = rsnd_mod_get_status,
703 DEBUG_INFO
704 };
705
rsnd_src_mod_get(struct rsnd_priv * priv,int id)706 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
707 {
708 if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv)))
709 id = 0;
710
711 return rsnd_mod_get(rsnd_src_get(priv, id));
712 }
713
rsnd_src_probe(struct rsnd_priv * priv)714 int rsnd_src_probe(struct rsnd_priv *priv)
715 {
716 struct device_node *node;
717 struct device_node *np;
718 struct device *dev = rsnd_priv_to_dev(priv);
719 struct rsnd_src *src;
720 struct clk *clk;
721 char name[RSND_SRC_NAME_SIZE];
722 int i, nr, ret;
723
724 /* This driver doesn't support Gen1 at this point */
725 if (rsnd_is_gen1(priv))
726 return 0;
727
728 node = rsnd_src_of_node(priv);
729 if (!node)
730 return 0; /* not used is not error */
731
732 nr = rsnd_node_count(priv, node, SRC_NAME);
733 if (!nr) {
734 ret = -EINVAL;
735 goto rsnd_src_probe_done;
736 }
737
738 src = devm_kcalloc(dev, nr, sizeof(*src), GFP_KERNEL);
739 if (!src) {
740 ret = -ENOMEM;
741 goto rsnd_src_probe_done;
742 }
743
744 priv->src_nr = nr;
745 priv->src = src;
746
747 i = 0;
748 for_each_child_of_node(node, np) {
749 if (!of_device_is_available(np))
750 goto skip;
751
752 i = rsnd_node_fixed_index(dev, np, SRC_NAME, i);
753 if (i < 0) {
754 ret = -EINVAL;
755 of_node_put(np);
756 goto rsnd_src_probe_done;
757 }
758
759 src = rsnd_src_get(priv, i);
760
761 snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d",
762 SRC_NAME, i);
763
764 src->irq = irq_of_parse_and_map(np, 0);
765 if (!src->irq) {
766 ret = -EINVAL;
767 of_node_put(np);
768 goto rsnd_src_probe_done;
769 }
770
771 clk = devm_clk_get(dev, name);
772 if (IS_ERR(clk)) {
773 ret = PTR_ERR(clk);
774 of_node_put(np);
775 goto rsnd_src_probe_done;
776 }
777
778 ret = rsnd_mod_init(priv, rsnd_mod_get(src),
779 &rsnd_src_ops, clk, RSND_MOD_SRC, i);
780 if (ret) {
781 of_node_put(np);
782 goto rsnd_src_probe_done;
783 }
784
785 skip:
786 i++;
787 }
788
789 ret = 0;
790
791 rsnd_src_probe_done:
792 of_node_put(node);
793
794 return ret;
795 }
796
rsnd_src_remove(struct rsnd_priv * priv)797 void rsnd_src_remove(struct rsnd_priv *priv)
798 {
799 struct rsnd_src *src;
800 int i;
801
802 for_each_rsnd_src(src, priv, i) {
803 rsnd_mod_quit(rsnd_mod_get(src));
804 }
805 }
806