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