2 * Renesas R-Car SRC support
4 * Copyright (C) 2013 Renesas Solutions Corp.
5 * 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.
13 #define SRC_NAME "src"
16 #define OUF_SRCO ((1 << 12) | (1 << 13))
17 #define OUF_SRCI ((1 << 9) | (1 << 8))
19 /* SCU_SYSTEM_STATUS0/1 */
20 #define OUF_SRC(id) ((1 << (id + 16)) | (1 << id))
25 struct rsnd_kctrl_cfg_s sen
; /* sync convert enable */
26 struct rsnd_kctrl_cfg_s sync
; /* sync convert */
27 u32 convert_rate
; /* sampling rate convert */
31 #define RSND_SRC_NAME_SIZE 16
33 #define rsnd_src_get(priv, id) ((struct rsnd_src *)(priv->src) + id)
34 #define rsnd_src_to_dma(src) ((src)->dma)
35 #define rsnd_src_nr(priv) ((priv)->src_nr)
36 #define rsnd_src_sync_is_enabled(mod) (rsnd_mod_to_src(mod)->sen.val)
38 #define rsnd_mod_to_src(_mod) \
39 container_of((_mod), struct rsnd_src, mod)
41 #define for_each_rsnd_src(pos, priv, i) \
43 ((i) < rsnd_src_nr(priv)) && \
44 ((pos) = (struct rsnd_src *)(priv)->src + i); \
49 * image of SRC (Sampling Rate Converter)
51 * 96kHz <-> +-----+ 48kHz +-----+ 48kHz +-------+
52 * 48kHz <-> | SRC | <------> | SSI | <-----> | codec |
53 * 44.1kHz <-> +-----+ +-----+ +-------+
63 * [mem] -> [SRU] -> [SSI]
68 * [mem] -> [SRC] -> [SSIU] -> [SSI]
72 static void rsnd_src_activation(struct rsnd_mod
*mod
)
74 rsnd_mod_write(mod
, SRC_SWRSR
, 0);
75 rsnd_mod_write(mod
, SRC_SWRSR
, 1);
78 static void rsnd_src_halt(struct rsnd_mod
*mod
)
80 rsnd_mod_write(mod
, SRC_SRCIR
, 1);
81 rsnd_mod_write(mod
, SRC_SWRSR
, 0);
84 static struct dma_chan
*rsnd_src_dma_req(struct rsnd_dai_stream
*io
,
87 struct rsnd_priv
*priv
= rsnd_mod_to_priv(mod
);
88 int is_play
= rsnd_io_is_play(io
);
90 return rsnd_dma_request_channel(rsnd_src_of_node(priv
),
92 is_play
? "rx" : "tx");
95 static u32
rsnd_src_convert_rate(struct rsnd_dai_stream
*io
,
98 struct snd_pcm_runtime
*runtime
= rsnd_io_to_runtime(io
);
99 struct rsnd_src
*src
= rsnd_mod_to_src(mod
);
105 if (!rsnd_src_sync_is_enabled(mod
))
106 return src
->convert_rate
;
108 convert_rate
= src
->sync
.val
;
111 convert_rate
= src
->convert_rate
;
114 convert_rate
= runtime
->rate
;
119 unsigned int rsnd_src_get_rate(struct rsnd_priv
*priv
,
120 struct rsnd_dai_stream
*io
,
123 struct rsnd_mod
*src_mod
= rsnd_io_to_mod_src(io
);
124 struct snd_pcm_runtime
*runtime
= rsnd_io_to_runtime(io
);
125 unsigned int rate
= 0;
126 int is_play
= rsnd_io_is_play(io
);
131 * runtime_rate -> [SRC] -> convert_rate
134 * convert_rate -> [SRC] -> runtime_rate
137 if (is_play
== is_in
)
138 return runtime
->rate
;
141 * return convert rate if SRC is used,
142 * otherwise, return runtime->rate as usual
145 rate
= rsnd_src_convert_rate(io
, src_mod
);
148 rate
= runtime
->rate
;
153 static int rsnd_src_hw_params(struct rsnd_mod
*mod
,
154 struct rsnd_dai_stream
*io
,
155 struct snd_pcm_substream
*substream
,
156 struct snd_pcm_hw_params
*fe_params
)
158 struct rsnd_src
*src
= rsnd_mod_to_src(mod
);
159 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
162 * SRC assumes that it is used under DPCM if user want to use
163 * sampling rate convert. Then, SRC should be FE.
164 * And then, this function will be called *after* BE settings.
165 * this means, each BE already has fixuped hw_params.
167 * dpcm_fe_dai_hw_params()
168 * dpcm_be_dai_hw_params()
170 if (fe
->dai_link
->dynamic
) {
171 int stream
= substream
->stream
;
172 struct snd_soc_dpcm
*dpcm
;
173 struct snd_pcm_hw_params
*be_params
;
175 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
176 be_params
= &dpcm
->hw_params
;
178 if (params_rate(fe_params
) != params_rate(be_params
))
179 src
->convert_rate
= params_rate(be_params
);
186 static void rsnd_src_set_convert_rate(struct rsnd_dai_stream
*io
,
187 struct rsnd_mod
*mod
)
189 struct rsnd_priv
*priv
= rsnd_mod_to_priv(mod
);
190 struct device
*dev
= rsnd_priv_to_dev(priv
);
191 struct snd_pcm_runtime
*runtime
= rsnd_io_to_runtime(io
);
193 u32 ifscr
, fsrate
, adinr
;
201 fin
= rsnd_src_get_in_rate(priv
, io
);
202 fout
= rsnd_src_get_out_rate(priv
, io
);
204 /* 6 - 1/6 are very enough ratio for SRC_BSDSR */
208 ratio
= 100 * fin
/ fout
;
210 ratio
= 100 * fout
/ fin
;
213 dev_err(dev
, "FSO/FSI ratio error\n");
220 adinr
= rsnd_get_adinr_bit(mod
, io
) |
221 rsnd_runtime_channel_original(io
);
224 * SRC_IFSCR / SRC_IFSVR
230 fsrate
= 0x0400000 / fout
* fin
;
234 * SRC_SRCCR / SRC_ROUTE_MODE0
241 if (rsnd_src_sync_is_enabled(mod
)) {
243 route
|= rsnd_io_is_play(io
) ?
244 (0x1 << 24) : (0x1 << 25);
249 * SRC_BSDSR / SRC_BSISR
251 switch (rsnd_mod_id(mod
)) {
256 bsdsr
= 0x02400000; /* 6 - 1/6 */
257 bsisr
= 0x00100060; /* 6 - 1/6 */
260 bsdsr
= 0x01800000; /* 6 - 1/6 */
261 bsisr
= 0x00100060 ;/* 6 - 1/6 */
265 rsnd_mod_write(mod
, SRC_ROUTE_MODE0
, route
);
267 rsnd_mod_write(mod
, SRC_SRCIR
, 1); /* initialize */
268 rsnd_mod_write(mod
, SRC_ADINR
, adinr
);
269 rsnd_mod_write(mod
, SRC_IFSCR
, ifscr
);
270 rsnd_mod_write(mod
, SRC_IFSVR
, fsrate
);
271 rsnd_mod_write(mod
, SRC_SRCCR
, cr
);
272 rsnd_mod_write(mod
, SRC_BSDSR
, bsdsr
);
273 rsnd_mod_write(mod
, SRC_BSISR
, bsisr
);
274 rsnd_mod_write(mod
, SRC_SRCIR
, 0); /* cancel initialize */
276 rsnd_mod_write(mod
, SRC_I_BUSIF_MODE
, 1);
277 rsnd_mod_write(mod
, SRC_O_BUSIF_MODE
, 1);
278 rsnd_mod_write(mod
, SRC_BUSIF_DALIGN
, rsnd_get_dalign(mod
, io
));
280 rsnd_adg_set_src_timesel_gen2(mod
, io
, fin
, fout
);
283 static int rsnd_src_irq(struct rsnd_mod
*mod
,
284 struct rsnd_dai_stream
*io
,
285 struct rsnd_priv
*priv
,
288 struct rsnd_src
*src
= rsnd_mod_to_src(mod
);
289 u32 sys_int_val
, int_val
, sys_int_mask
;
291 int id
= rsnd_mod_id(mod
);
294 sys_int_mask
= OUF_SRC(id
);
298 * IRQ is not supported on non-DT
302 if ((irq
<= 0) || !enable
) {
310 * ignore over flow error when rsnd_src_sync_is_enabled()
312 if (rsnd_src_sync_is_enabled(mod
))
313 sys_int_val
= sys_int_val
& 0xffff;
315 rsnd_mod_write(mod
, SRC_INT_ENABLE0
, int_val
);
316 rsnd_mod_bset(mod
, SCU_SYS_INT_EN0
, sys_int_mask
, sys_int_val
);
317 rsnd_mod_bset(mod
, SCU_SYS_INT_EN1
, sys_int_mask
, sys_int_val
);
322 static void rsnd_src_status_clear(struct rsnd_mod
*mod
)
324 u32 val
= OUF_SRC(rsnd_mod_id(mod
));
326 rsnd_mod_bset(mod
, SCU_SYS_STATUS0
, val
, val
);
327 rsnd_mod_bset(mod
, SCU_SYS_STATUS1
, val
, val
);
330 static bool rsnd_src_error_occurred(struct rsnd_mod
*mod
)
335 val0
= val1
= OUF_SRC(rsnd_mod_id(mod
));
340 * ignore over flow error when rsnd_src_sync_is_enabled()
342 if (rsnd_src_sync_is_enabled(mod
))
343 val0
= val0
& 0xffff;
345 if ((rsnd_mod_read(mod
, SCU_SYS_STATUS0
) & val0
) ||
346 (rsnd_mod_read(mod
, SCU_SYS_STATUS1
) & val1
))
352 static int rsnd_src_start(struct rsnd_mod
*mod
,
353 struct rsnd_dai_stream
*io
,
354 struct rsnd_priv
*priv
)
361 * Enable SRC output if you want to use sync convert together with DVC
363 val
= (rsnd_io_to_mod_dvc(io
) && !rsnd_src_sync_is_enabled(mod
)) ?
366 rsnd_mod_write(mod
, SRC_CTRL
, val
);
371 static int rsnd_src_stop(struct rsnd_mod
*mod
,
372 struct rsnd_dai_stream
*io
,
373 struct rsnd_priv
*priv
)
375 rsnd_mod_write(mod
, SRC_CTRL
, 0);
380 static int rsnd_src_init(struct rsnd_mod
*mod
,
381 struct rsnd_dai_stream
*io
,
382 struct rsnd_priv
*priv
)
384 struct rsnd_src
*src
= rsnd_mod_to_src(mod
);
386 rsnd_mod_power_on(mod
);
388 rsnd_src_activation(mod
);
390 rsnd_src_set_convert_rate(io
, mod
);
392 rsnd_src_status_clear(mod
);
394 /* reset sync convert_rate */
400 static int rsnd_src_quit(struct rsnd_mod
*mod
,
401 struct rsnd_dai_stream
*io
,
402 struct rsnd_priv
*priv
)
404 struct rsnd_src
*src
= rsnd_mod_to_src(mod
);
408 rsnd_mod_power_off(mod
);
410 src
->convert_rate
= 0;
412 /* reset sync convert_rate */
418 static void __rsnd_src_interrupt(struct rsnd_mod
*mod
,
419 struct rsnd_dai_stream
*io
)
421 struct rsnd_priv
*priv
= rsnd_mod_to_priv(mod
);
424 spin_lock(&priv
->lock
);
426 /* ignore all cases if not working */
427 if (!rsnd_io_is_working(io
))
428 goto rsnd_src_interrupt_out
;
430 if (rsnd_src_error_occurred(mod
))
433 rsnd_src_status_clear(mod
);
434 rsnd_src_interrupt_out
:
436 spin_unlock(&priv
->lock
);
439 snd_pcm_stop_xrun(io
->substream
);
442 static irqreturn_t
rsnd_src_interrupt(int irq
, void *data
)
444 struct rsnd_mod
*mod
= data
;
446 rsnd_mod_interrupt(mod
, __rsnd_src_interrupt
);
451 static int rsnd_src_probe_(struct rsnd_mod
*mod
,
452 struct rsnd_dai_stream
*io
,
453 struct rsnd_priv
*priv
)
455 struct rsnd_src
*src
= rsnd_mod_to_src(mod
);
456 struct device
*dev
= rsnd_priv_to_dev(priv
);
462 * IRQ is not supported on non-DT
466 ret
= devm_request_irq(dev
, irq
,
474 ret
= rsnd_dma_attach(io
, mod
, &src
->dma
, 0);
479 static int rsnd_src_pcm_new(struct rsnd_mod
*mod
,
480 struct rsnd_dai_stream
*io
,
481 struct snd_soc_pcm_runtime
*rtd
)
483 struct rsnd_src
*src
= rsnd_mod_to_src(mod
);
487 * enable SRC sync convert if possible
491 * It can't use SRC Synchronous convert
492 * when Capture if it uses CMD
494 if (rsnd_io_to_mod_cmd(io
) && !rsnd_io_is_play(io
))
498 * enable sync convert
500 ret
= rsnd_kctrl_new_s(mod
, io
, rtd
,
501 rsnd_io_is_play(io
) ?
502 "SRC Out Rate Switch" :
503 "SRC In Rate Switch",
504 rsnd_src_set_convert_rate
,
509 ret
= rsnd_kctrl_new_s(mod
, io
, rtd
,
510 rsnd_io_is_play(io
) ?
513 rsnd_src_set_convert_rate
,
519 static struct rsnd_mod_ops rsnd_src_ops
= {
521 .dma_req
= rsnd_src_dma_req
,
522 .probe
= rsnd_src_probe_
,
523 .init
= rsnd_src_init
,
524 .quit
= rsnd_src_quit
,
525 .start
= rsnd_src_start
,
526 .stop
= rsnd_src_stop
,
528 .hw_params
= rsnd_src_hw_params
,
529 .pcm_new
= rsnd_src_pcm_new
,
532 struct rsnd_mod
*rsnd_src_mod_get(struct rsnd_priv
*priv
, int id
)
534 if (WARN_ON(id
< 0 || id
>= rsnd_src_nr(priv
)))
537 return rsnd_mod_get(rsnd_src_get(priv
, id
));
540 int rsnd_src_probe(struct rsnd_priv
*priv
)
542 struct device_node
*node
;
543 struct device_node
*np
;
544 struct device
*dev
= rsnd_priv_to_dev(priv
);
545 struct rsnd_src
*src
;
547 char name
[RSND_SRC_NAME_SIZE
];
550 /* This driver doesn't support Gen1 at this point */
551 if (rsnd_is_gen1(priv
))
554 node
= rsnd_src_of_node(priv
);
556 return 0; /* not used is not error */
558 nr
= of_get_child_count(node
);
561 goto rsnd_src_probe_done
;
564 src
= devm_kzalloc(dev
, sizeof(*src
) * nr
, GFP_KERNEL
);
567 goto rsnd_src_probe_done
;
574 for_each_child_of_node(node
, np
) {
575 if (!of_device_is_available(np
))
578 src
= rsnd_src_get(priv
, i
);
580 snprintf(name
, RSND_SRC_NAME_SIZE
, "%s.%d",
583 src
->irq
= irq_of_parse_and_map(np
, 0);
586 goto rsnd_src_probe_done
;
589 clk
= devm_clk_get(dev
, name
);
592 goto rsnd_src_probe_done
;
595 ret
= rsnd_mod_init(priv
, rsnd_mod_get(src
),
596 &rsnd_src_ops
, clk
, rsnd_mod_get_status
,
599 goto rsnd_src_probe_done
;
613 void rsnd_src_remove(struct rsnd_priv
*priv
)
615 struct rsnd_src
*src
;
618 for_each_rsnd_src(src
, priv
, i
) {
619 rsnd_mod_quit(rsnd_mod_get(src
));