]>
Commit | Line | Data |
---|---|---|
ae5c3223 KM |
1 | /* |
2 | * Renesas R-Car SSIU/SSI support | |
3 | * | |
4 | * Copyright (C) 2013 Renesas Solutions Corp. | |
5 | * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> | |
6 | * | |
7 | * Based on fsi.c | |
8 | * Kuninori Morimoto <morimoto.kuninori@renesas.com> | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License version 2 as | |
12 | * published by the Free Software Foundation. | |
13 | */ | |
7fa72cca | 14 | #include <sound/simple_card_utils.h> |
ae5c3223 KM |
15 | #include <linux/delay.h> |
16 | #include "rsnd.h" | |
17 | #define RSND_SSI_NAME_SIZE 16 | |
18 | ||
19 | /* | |
20 | * SSICR | |
21 | */ | |
22 | #define FORCE (1 << 31) /* Fixed */ | |
849fc82a | 23 | #define DMEN (1 << 28) /* DMA Enable */ |
ae5c3223 KM |
24 | #define UIEN (1 << 27) /* Underflow Interrupt Enable */ |
25 | #define OIEN (1 << 26) /* Overflow Interrupt Enable */ | |
26 | #define IIEN (1 << 25) /* Idle Mode Interrupt Enable */ | |
27 | #define DIEN (1 << 24) /* Data Interrupt Enable */ | |
186fadc1 KM |
28 | #define CHNL_4 (1 << 22) /* Channels */ |
29 | #define CHNL_6 (2 << 22) /* Channels */ | |
30 | #define CHNL_8 (3 << 22) /* Channels */ | |
7d970a24 | 31 | #define DWL_MASK (7 << 19) /* Data Word Length mask */ |
ae5c3223 KM |
32 | #define DWL_8 (0 << 19) /* Data Word Length */ |
33 | #define DWL_16 (1 << 19) /* Data Word Length */ | |
34 | #define DWL_18 (2 << 19) /* Data Word Length */ | |
35 | #define DWL_20 (3 << 19) /* Data Word Length */ | |
36 | #define DWL_22 (4 << 19) /* Data Word Length */ | |
37 | #define DWL_24 (5 << 19) /* Data Word Length */ | |
38 | #define DWL_32 (6 << 19) /* Data Word Length */ | |
39 | ||
40 | #define SWL_32 (3 << 16) /* R/W System Word Length */ | |
41 | #define SCKD (1 << 15) /* Serial Bit Clock Direction */ | |
42 | #define SWSD (1 << 14) /* Serial WS Direction */ | |
43 | #define SCKP (1 << 13) /* Serial Bit Clock Polarity */ | |
44 | #define SWSP (1 << 12) /* Serial WS Polarity */ | |
45 | #define SDTA (1 << 10) /* Serial Data Alignment */ | |
f46a93b8 | 46 | #define PDTA (1 << 9) /* Parallel Data Alignment */ |
ae5c3223 KM |
47 | #define DEL (1 << 8) /* Serial Data Delay */ |
48 | #define CKDV(v) (v << 4) /* Serial Clock Division Ratio */ | |
49 | #define TRMD (1 << 1) /* Transmit/Receive Mode Select */ | |
50 | #define EN (1 << 0) /* SSI Module Enable */ | |
51 | ||
52 | /* | |
53 | * SSISR | |
54 | */ | |
55 | #define UIRQ (1 << 27) /* Underflow Error Interrupt Status */ | |
56 | #define OIRQ (1 << 26) /* Overflow Error Interrupt Status */ | |
57 | #define IIRQ (1 << 25) /* Idle Mode Interrupt Status */ | |
58 | #define DIRQ (1 << 24) /* Data Interrupt Status Flag */ | |
59 | ||
849fc82a KM |
60 | /* |
61 | * SSIWSR | |
62 | */ | |
63 | #define CONT (1 << 8) /* WS Continue Function */ | |
186fadc1 | 64 | #define WS_MODE (1 << 0) /* WS Mode */ |
849fc82a | 65 | |
8aefda50 KM |
66 | #define SSI_NAME "ssi" |
67 | ||
ae5c3223 | 68 | struct rsnd_ssi { |
ae5c3223 KM |
69 | struct rsnd_mod mod; |
70 | ||
02534f2f | 71 | u32 flags; |
ae5c3223 KM |
72 | u32 cr_own; |
73 | u32 cr_clk; | |
e7d850dd | 74 | u32 cr_mode; |
597b046f | 75 | u32 cr_en; |
08bada26 | 76 | u32 wsr; |
919567d9 | 77 | int chan; |
e7d850dd | 78 | int rate; |
02534f2f | 79 | int irq; |
ae5c3223 | 80 | unsigned int usrcnt; |
a97a06c7 KM |
81 | |
82 | int byte_pos; | |
83 | int period_pos; | |
84 | int byte_per_period; | |
85 | int next_period_byte; | |
ae5c3223 KM |
86 | }; |
87 | ||
02534f2f KM |
88 | /* flags */ |
89 | #define RSND_SSI_CLK_PIN_SHARE (1 << 0) | |
90 | #define RSND_SSI_NO_BUSIF (1 << 1) /* SSI+DMA without BUSIF */ | |
7fa72cca KM |
91 | #define RSND_SSI_HDMI0 (1 << 2) /* for HDMI0 */ |
92 | #define RSND_SSI_HDMI1 (1 << 3) /* for HDMI1 */ | |
b6e58fca | 93 | #define RSND_SSI_PROBED (1 << 4) |
02534f2f | 94 | |
ae5c3223 KM |
95 | #define for_each_rsnd_ssi(pos, priv, i) \ |
96 | for (i = 0; \ | |
97 | (i < rsnd_ssi_nr(priv)) && \ | |
dd27d808 | 98 | ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i)); \ |
ae5c3223 KM |
99 | i++) |
100 | ||
02534f2f | 101 | #define rsnd_ssi_get(priv, id) ((struct rsnd_ssi *)(priv->ssi) + id) |
dd27d808 | 102 | #define rsnd_ssi_nr(priv) ((priv)->ssi_nr) |
ae5c3223 | 103 | #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod) |
e7d850dd | 104 | #define rsnd_ssi_is_parent(ssi, io) ((ssi) == rsnd_io_to_mod_ssip(io)) |
c308abe4 KM |
105 | #define rsnd_ssi_is_multi_slave(mod, io) \ |
106 | (rsnd_ssi_multi_slaves(io) & (1 << rsnd_mod_id(mod))) | |
fd9adcfd KM |
107 | #define rsnd_ssi_is_run_mods(mod, io) \ |
108 | (rsnd_ssi_run_mods(io) & (1 << rsnd_mod_id(mod))) | |
bb002f92 | 109 | #define rsnd_ssi_can_output_clk(mod) (!__rsnd_ssi_is_pin_sharing(mod)) |
ae5c3223 | 110 | |
7fa72cca KM |
111 | int rsnd_ssi_hdmi_port(struct rsnd_dai_stream *io) |
112 | { | |
113 | struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); | |
114 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
115 | ||
42991989 | 116 | if (rsnd_flags_has(ssi, RSND_SSI_HDMI0)) |
7fa72cca KM |
117 | return RSND_SSI_HDMI_PORT0; |
118 | ||
42991989 | 119 | if (rsnd_flags_has(ssi, RSND_SSI_HDMI1)) |
7fa72cca KM |
120 | return RSND_SSI_HDMI_PORT1; |
121 | ||
122 | return 0; | |
123 | } | |
124 | ||
b415b4d3 | 125 | int rsnd_ssi_use_busif(struct rsnd_dai_stream *io) |
d9288d0b | 126 | { |
b415b4d3 | 127 | struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); |
d9288d0b | 128 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); |
d9288d0b KM |
129 | int use_busif = 0; |
130 | ||
7b466fc6 KM |
131 | if (!rsnd_ssi_is_dma_mode(mod)) |
132 | return 0; | |
133 | ||
42991989 | 134 | if (!(rsnd_flags_has(ssi, RSND_SSI_NO_BUSIF))) |
d9288d0b KM |
135 | use_busif = 1; |
136 | if (rsnd_io_to_mod_src(io)) | |
137 | use_busif = 1; | |
138 | ||
139 | return use_busif; | |
140 | } | |
141 | ||
e10369d8 KM |
142 | static void rsnd_ssi_status_clear(struct rsnd_mod *mod) |
143 | { | |
144 | rsnd_mod_write(mod, SSISR, 0); | |
145 | } | |
146 | ||
147 | static u32 rsnd_ssi_status_get(struct rsnd_mod *mod) | |
148 | { | |
149 | return rsnd_mod_read(mod, SSISR); | |
150 | } | |
151 | ||
ae5c3223 KM |
152 | static void rsnd_ssi_status_check(struct rsnd_mod *mod, |
153 | u32 bit) | |
154 | { | |
155 | struct rsnd_priv *priv = rsnd_mod_to_priv(mod); | |
156 | struct device *dev = rsnd_priv_to_dev(priv); | |
157 | u32 status; | |
158 | int i; | |
159 | ||
160 | for (i = 0; i < 1024; i++) { | |
e10369d8 | 161 | status = rsnd_ssi_status_get(mod); |
ae5c3223 KM |
162 | if (status & bit) |
163 | return; | |
164 | ||
165 | udelay(50); | |
166 | } | |
167 | ||
1120dbff KM |
168 | dev_warn(dev, "%s[%d] status check failed\n", |
169 | rsnd_mod_name(mod), rsnd_mod_id(mod)); | |
ae5c3223 KM |
170 | } |
171 | ||
4f5c634d | 172 | static u32 rsnd_ssi_multi_slaves(struct rsnd_dai_stream *io) |
b4c83b17 KM |
173 | { |
174 | struct rsnd_mod *mod; | |
b4c83b17 KM |
175 | enum rsnd_mod_type types[] = { |
176 | RSND_MOD_SSIM1, | |
177 | RSND_MOD_SSIM2, | |
178 | RSND_MOD_SSIM3, | |
179 | }; | |
180 | int i, mask; | |
181 | ||
b4c83b17 KM |
182 | mask = 0; |
183 | for (i = 0; i < ARRAY_SIZE(types); i++) { | |
184 | mod = rsnd_io_to_mod(io, types[i]); | |
185 | if (!mod) | |
186 | continue; | |
187 | ||
188 | mask |= 1 << rsnd_mod_id(mod); | |
189 | } | |
190 | ||
191 | return mask; | |
192 | } | |
193 | ||
fd9adcfd KM |
194 | static u32 rsnd_ssi_run_mods(struct rsnd_dai_stream *io) |
195 | { | |
196 | struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io); | |
197 | struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io); | |
21781e87 | 198 | u32 mods; |
fd9adcfd | 199 | |
21781e87 KM |
200 | mods = rsnd_ssi_multi_slaves_runtime(io) | |
201 | 1 << rsnd_mod_id(ssi_mod); | |
202 | ||
203 | if (ssi_parent_mod) | |
204 | mods |= 1 << rsnd_mod_id(ssi_parent_mod); | |
205 | ||
206 | return mods; | |
fd9adcfd KM |
207 | } |
208 | ||
4f5c634d KM |
209 | u32 rsnd_ssi_multi_slaves_runtime(struct rsnd_dai_stream *io) |
210 | { | |
eed76bb8 KM |
211 | if (rsnd_runtime_is_ssi_multi(io)) |
212 | return rsnd_ssi_multi_slaves(io); | |
4f5c634d KM |
213 | |
214 | return 0; | |
215 | } | |
216 | ||
947f4eb5 | 217 | unsigned int rsnd_ssi_clk_query(struct rsnd_priv *priv, |
ef4cf5d6 KM |
218 | int param1, int param2, int *idx) |
219 | { | |
220 | int ssi_clk_mul_table[] = { | |
221 | 1, 2, 4, 8, 16, 6, 12, | |
222 | }; | |
223 | int j, ret; | |
947f4eb5 | 224 | unsigned int main_rate; |
ef4cf5d6 KM |
225 | |
226 | for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) { | |
227 | ||
228 | /* | |
229 | * It will set SSIWSR.CONT here, but SSICR.CKDV = 000 | |
230 | * with it is not allowed. (SSIWSR.WS_MODE with | |
231 | * SSICR.CKDV = 000 is not allowed either). | |
232 | * Skip it. See SSICR.CKDV | |
233 | */ | |
234 | if (j == 0) | |
235 | continue; | |
236 | ||
237 | /* | |
238 | * this driver is assuming that | |
239 | * system word is 32bit x chan | |
240 | * see rsnd_ssi_init() | |
241 | */ | |
242 | main_rate = 32 * param1 * param2 * ssi_clk_mul_table[j]; | |
243 | ||
244 | ret = rsnd_adg_clk_query(priv, main_rate); | |
245 | if (ret < 0) | |
246 | continue; | |
247 | ||
248 | if (idx) | |
249 | *idx = j; | |
250 | ||
251 | return main_rate; | |
252 | } | |
253 | ||
947f4eb5 | 254 | return 0; |
ef4cf5d6 KM |
255 | } |
256 | ||
26d34b11 | 257 | static int rsnd_ssi_master_clk_start(struct rsnd_mod *mod, |
adcf7d5e | 258 | struct rsnd_dai_stream *io) |
ae5c3223 | 259 | { |
1b13d118 | 260 | struct rsnd_priv *priv = rsnd_io_to_priv(io); |
ae5c3223 | 261 | struct device *dev = rsnd_priv_to_dev(priv); |
e7d850dd | 262 | struct rsnd_dai *rdai = rsnd_io_to_rdai(io); |
26d34b11 | 263 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); |
eed76bb8 | 264 | int chan = rsnd_runtime_channel_for_ssi(io); |
ef4cf5d6 | 265 | int idx, ret; |
ae5c3223 | 266 | unsigned int main_rate; |
cbf1494f KM |
267 | unsigned int rate = rsnd_io_is_play(io) ? |
268 | rsnd_src_get_out_rate(priv, io) : | |
269 | rsnd_src_get_in_rate(priv, io); | |
ae5c3223 | 270 | |
e7d850dd KM |
271 | if (!rsnd_rdai_is_clk_master(rdai)) |
272 | return 0; | |
273 | ||
bb002f92 | 274 | if (!rsnd_ssi_can_output_clk(mod)) |
e7d850dd KM |
275 | return 0; |
276 | ||
b4c83b17 KM |
277 | if (rsnd_ssi_is_multi_slave(mod, io)) |
278 | return 0; | |
279 | ||
ed3115ee | 280 | if (ssi->usrcnt > 0) { |
e7d850dd KM |
281 | if (ssi->rate != rate) { |
282 | dev_err(dev, "SSI parent/child should use same rate\n"); | |
283 | return -EINVAL; | |
284 | } | |
285 | ||
286 | return 0; | |
287 | } | |
288 | ||
ef4cf5d6 | 289 | main_rate = rsnd_ssi_clk_query(priv, rate, chan, &idx); |
947f4eb5 | 290 | if (!main_rate) { |
ef4cf5d6 KM |
291 | dev_err(dev, "unsupported clock rate\n"); |
292 | return -EIO; | |
293 | } | |
eae6fff4 | 294 | |
ef4cf5d6 KM |
295 | ret = rsnd_adg_ssi_clk_try_start(mod, main_rate); |
296 | if (ret < 0) | |
297 | return ret; | |
e7d850dd | 298 | |
597b046f KM |
299 | /* |
300 | * SSI clock will be output contiguously | |
301 | * by below settings. | |
302 | * This means, rsnd_ssi_master_clk_start() | |
303 | * and rsnd_ssi_register_setup() are necessary | |
304 | * for SSI parent | |
305 | * | |
306 | * SSICR : FORCE, SCKD, SWSD | |
307 | * SSIWSR : CONT | |
308 | */ | |
ef4cf5d6 KM |
309 | ssi->cr_clk = FORCE | SWL_32 | SCKD | SWSD | CKDV(idx); |
310 | ssi->wsr = CONT; | |
311 | ssi->rate = rate; | |
eae6fff4 | 312 | |
ef4cf5d6 KM |
313 | dev_dbg(dev, "%s[%d] outputs %u Hz\n", |
314 | rsnd_mod_name(mod), | |
315 | rsnd_mod_id(mod), rate); | |
ae5c3223 | 316 | |
ef4cf5d6 | 317 | return 0; |
ae5c3223 KM |
318 | } |
319 | ||
26d34b11 | 320 | static void rsnd_ssi_master_clk_stop(struct rsnd_mod *mod, |
e7d850dd | 321 | struct rsnd_dai_stream *io) |
ae5c3223 | 322 | { |
f708d944 | 323 | struct rsnd_dai *rdai = rsnd_io_to_rdai(io); |
26d34b11 | 324 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); |
3ba84f45 | 325 | |
e7d850dd | 326 | if (!rsnd_rdai_is_clk_master(rdai)) |
ae5c3223 | 327 | return; |
ae5c3223 | 328 | |
bb002f92 | 329 | if (!rsnd_ssi_can_output_clk(mod)) |
e7d850dd | 330 | return; |
ae5c3223 | 331 | |
e7d850dd KM |
332 | if (ssi->usrcnt > 1) |
333 | return; | |
919567d9 | 334 | |
e7d850dd KM |
335 | ssi->cr_clk = 0; |
336 | ssi->rate = 0; | |
ae5c3223 | 337 | |
e7d850dd | 338 | rsnd_adg_ssi_clk_stop(mod); |
ae5c3223 KM |
339 | } |
340 | ||
0dc6bf75 | 341 | static void rsnd_ssi_config_init(struct rsnd_mod *mod, |
840ada3b KM |
342 | struct rsnd_dai_stream *io) |
343 | { | |
344 | struct rsnd_dai *rdai = rsnd_io_to_rdai(io); | |
345 | struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); | |
26d34b11 | 346 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); |
7d970a24 KM |
347 | u32 cr_own = ssi->cr_own; |
348 | u32 cr_mode = ssi->cr_mode; | |
349 | u32 wsr = ssi->wsr; | |
f98ed119 KM |
350 | int is_tdm; |
351 | ||
eed76bb8 | 352 | is_tdm = rsnd_runtime_is_ssi_tdm(io); |
840ada3b KM |
353 | |
354 | /* | |
355 | * always use 32bit system word. | |
356 | * see also rsnd_ssi_master_clk_enable() | |
357 | */ | |
7d970a24 | 358 | cr_own |= FORCE | SWL_32; |
840ada3b KM |
359 | |
360 | if (rdai->bit_clk_inv) | |
361 | cr_own |= SCKP; | |
f98ed119 | 362 | if (rdai->frm_clk_inv ^ is_tdm) |
840ada3b KM |
363 | cr_own |= SWSP; |
364 | if (rdai->data_alignment) | |
365 | cr_own |= SDTA; | |
366 | if (rdai->sys_delay) | |
367 | cr_own |= DEL; | |
7d970a24 KM |
368 | |
369 | /* | |
370 | * We shouldn't exchange SWSP after running. | |
371 | * This means, parent needs to care it. | |
372 | */ | |
373 | if (rsnd_ssi_is_parent(mod, io)) | |
374 | goto init_end; | |
375 | ||
840ada3b KM |
376 | if (rsnd_io_is_play(io)) |
377 | cr_own |= TRMD; | |
378 | ||
7d970a24 | 379 | cr_own &= ~DWL_MASK; |
840ada3b KM |
380 | switch (runtime->sample_bits) { |
381 | case 16: | |
382 | cr_own |= DWL_16; | |
383 | break; | |
384 | case 32: | |
385 | cr_own |= DWL_24; | |
386 | break; | |
840ada3b KM |
387 | } |
388 | ||
26d34b11 | 389 | if (rsnd_ssi_is_dma_mode(mod)) { |
840ada3b KM |
390 | cr_mode = UIEN | OIEN | /* over/under run */ |
391 | DMEN; /* DMA : enable DMA */ | |
392 | } else { | |
393 | cr_mode = DIEN; /* PIO : enable Data interrupt */ | |
394 | } | |
395 | ||
186fadc1 KM |
396 | /* |
397 | * TDM Extend Mode | |
398 | * see | |
399 | * rsnd_ssiu_init_gen2() | |
400 | */ | |
401 | wsr = ssi->wsr; | |
f98ed119 | 402 | if (is_tdm) { |
186fadc1 KM |
403 | wsr |= WS_MODE; |
404 | cr_own |= CHNL_8; | |
405 | } | |
7d970a24 | 406 | init_end: |
840ada3b KM |
407 | ssi->cr_own = cr_own; |
408 | ssi->cr_mode = cr_mode; | |
186fadc1 | 409 | ssi->wsr = wsr; |
0dc6bf75 | 410 | } |
840ada3b | 411 | |
0dc6bf75 KM |
412 | static void rsnd_ssi_register_setup(struct rsnd_mod *mod) |
413 | { | |
414 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
415 | ||
416 | rsnd_mod_write(mod, SSIWSR, ssi->wsr); | |
417 | rsnd_mod_write(mod, SSICR, ssi->cr_own | | |
418 | ssi->cr_clk | | |
597b046f KM |
419 | ssi->cr_mode | |
420 | ssi->cr_en); | |
840ada3b KM |
421 | } |
422 | ||
a97a06c7 KM |
423 | static void rsnd_ssi_pointer_init(struct rsnd_mod *mod, |
424 | struct rsnd_dai_stream *io) | |
425 | { | |
426 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
427 | struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); | |
428 | ||
429 | ssi->byte_pos = 0; | |
430 | ssi->period_pos = 0; | |
431 | ssi->byte_per_period = runtime->period_size * | |
432 | runtime->channels * | |
433 | samples_to_bytes(runtime, 1); | |
434 | ssi->next_period_byte = ssi->byte_per_period; | |
435 | } | |
436 | ||
437 | static int rsnd_ssi_pointer_offset(struct rsnd_mod *mod, | |
438 | struct rsnd_dai_stream *io, | |
439 | int additional) | |
440 | { | |
441 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
442 | struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); | |
443 | int pos = ssi->byte_pos + additional; | |
444 | ||
445 | pos %= (runtime->periods * ssi->byte_per_period); | |
446 | ||
447 | return pos; | |
448 | } | |
449 | ||
450 | static bool rsnd_ssi_pointer_update(struct rsnd_mod *mod, | |
451 | struct rsnd_dai_stream *io, | |
452 | int byte) | |
453 | { | |
454 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
33f80136 JW |
455 | bool ret = false; |
456 | int byte_pos; | |
a97a06c7 | 457 | |
33f80136 | 458 | byte_pos = ssi->byte_pos + byte; |
a97a06c7 | 459 | |
33f80136 | 460 | if (byte_pos >= ssi->next_period_byte) { |
a97a06c7 KM |
461 | struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
462 | ||
463 | ssi->period_pos++; | |
464 | ssi->next_period_byte += ssi->byte_per_period; | |
465 | ||
466 | if (ssi->period_pos >= runtime->periods) { | |
33f80136 | 467 | byte_pos = 0; |
a97a06c7 KM |
468 | ssi->period_pos = 0; |
469 | ssi->next_period_byte = ssi->byte_per_period; | |
470 | } | |
471 | ||
33f80136 | 472 | ret = true; |
a97a06c7 KM |
473 | } |
474 | ||
33f80136 JW |
475 | WRITE_ONCE(ssi->byte_pos, byte_pos); |
476 | ||
477 | return ret; | |
a97a06c7 KM |
478 | } |
479 | ||
ae5c3223 KM |
480 | /* |
481 | * SSI mod common functions | |
482 | */ | |
483 | static int rsnd_ssi_init(struct rsnd_mod *mod, | |
2c0fac19 | 484 | struct rsnd_dai_stream *io, |
690602fc | 485 | struct rsnd_priv *priv) |
ae5c3223 KM |
486 | { |
487 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
e7d850dd | 488 | |
fd9adcfd KM |
489 | if (!rsnd_ssi_is_run_mods(mod, io)) |
490 | return 0; | |
491 | ||
a97a06c7 KM |
492 | rsnd_ssi_pointer_init(mod, io); |
493 | ||
e7d850dd KM |
494 | ssi->usrcnt++; |
495 | ||
496 | rsnd_mod_power_on(mod); | |
497 | ||
bf23c6a3 | 498 | rsnd_ssi_config_init(mod, io); |
ae5c3223 | 499 | |
0dc6bf75 | 500 | rsnd_ssi_register_setup(mod); |
e7d850dd | 501 | |
e7d850dd KM |
502 | /* clear error status */ |
503 | rsnd_ssi_status_clear(mod); | |
504 | ||
ae5c3223 KM |
505 | return 0; |
506 | } | |
507 | ||
508 | static int rsnd_ssi_quit(struct rsnd_mod *mod, | |
2c0fac19 | 509 | struct rsnd_dai_stream *io, |
690602fc | 510 | struct rsnd_priv *priv) |
ae5c3223 KM |
511 | { |
512 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
ae5c3223 KM |
513 | struct device *dev = rsnd_priv_to_dev(priv); |
514 | ||
fd9adcfd KM |
515 | if (!rsnd_ssi_is_run_mods(mod, io)) |
516 | return 0; | |
517 | ||
e5d9cfc6 AH |
518 | if (!ssi->usrcnt) { |
519 | dev_err(dev, "%s[%d] usrcnt error\n", | |
520 | rsnd_mod_name(mod), rsnd_mod_id(mod)); | |
521 | return -EIO; | |
522 | } | |
e7d850dd | 523 | |
26d34b11 | 524 | rsnd_ssi_master_clk_stop(mod, io); |
e7d850dd KM |
525 | |
526 | rsnd_mod_power_off(mod); | |
527 | ||
528 | ssi->usrcnt--; | |
529 | ||
7d970a24 KM |
530 | if (!ssi->usrcnt) { |
531 | ssi->cr_own = 0; | |
532 | ssi->cr_mode = 0; | |
533 | ssi->wsr = 0; | |
534 | } | |
535 | ||
ae5c3223 KM |
536 | return 0; |
537 | } | |
538 | ||
919567d9 | 539 | static int rsnd_ssi_hw_params(struct rsnd_mod *mod, |
2c0fac19 | 540 | struct rsnd_dai_stream *io, |
919567d9 KM |
541 | struct snd_pcm_substream *substream, |
542 | struct snd_pcm_hw_params *params) | |
543 | { | |
544 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
919567d9 KM |
545 | int chan = params_channels(params); |
546 | ||
547 | /* | |
6bf66b1c KM |
548 | * snd_pcm_ops::hw_params will be called *before* |
549 | * snd_soc_dai_ops::trigger. Thus, ssi->usrcnt is 0 | |
550 | * in 1st call. | |
919567d9 | 551 | */ |
6bf66b1c | 552 | if (ssi->usrcnt) { |
919567d9 | 553 | /* |
6bf66b1c KM |
554 | * Already working. |
555 | * It will happen if SSI has parent/child connection. | |
919567d9 KM |
556 | * it is error if child <-> parent SSI uses |
557 | * different channels. | |
558 | */ | |
559 | if (ssi->chan != chan) | |
560 | return -EIO; | |
561 | } | |
562 | ||
919567d9 | 563 | ssi->chan = chan; |
919567d9 KM |
564 | |
565 | return 0; | |
566 | } | |
567 | ||
6a25c8da KM |
568 | static int rsnd_ssi_start(struct rsnd_mod *mod, |
569 | struct rsnd_dai_stream *io, | |
570 | struct rsnd_priv *priv) | |
e7d850dd | 571 | { |
597b046f KM |
572 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); |
573 | ||
fd9adcfd KM |
574 | if (!rsnd_ssi_is_run_mods(mod, io)) |
575 | return 0; | |
576 | ||
b4c83b17 KM |
577 | /* |
578 | * EN will be set via SSIU :: SSI_CONTROL | |
579 | * if Multi channel mode | |
580 | */ | |
4f5c634d | 581 | if (rsnd_ssi_multi_slaves_runtime(io)) |
0dc6bf75 | 582 | return 0; |
e7d850dd | 583 | |
597b046f KM |
584 | /* |
585 | * EN is for data output. | |
586 | * SSI parent EN is not needed. | |
587 | */ | |
588 | if (rsnd_ssi_is_parent(mod, io)) | |
589 | return 0; | |
590 | ||
591 | ssi->cr_en = EN; | |
592 | ||
593 | rsnd_mod_write(mod, SSICR, ssi->cr_own | | |
594 | ssi->cr_clk | | |
595 | ssi->cr_mode | | |
596 | ssi->cr_en); | |
e7d850dd KM |
597 | |
598 | return 0; | |
599 | } | |
600 | ||
6a25c8da KM |
601 | static int rsnd_ssi_stop(struct rsnd_mod *mod, |
602 | struct rsnd_dai_stream *io, | |
603 | struct rsnd_priv *priv) | |
e7d850dd | 604 | { |
6a25c8da KM |
605 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); |
606 | u32 cr; | |
607 | ||
fd9adcfd KM |
608 | if (!rsnd_ssi_is_run_mods(mod, io)) |
609 | return 0; | |
610 | ||
597b046f | 611 | if (rsnd_ssi_is_parent(mod, io)) |
6a25c8da | 612 | return 0; |
e7d850dd | 613 | |
e7d850dd KM |
614 | cr = ssi->cr_own | |
615 | ssi->cr_clk; | |
4e7d606c | 616 | |
ce548931 KM |
617 | /* |
618 | * disable all IRQ, | |
619 | * Playback: Wait all data was sent | |
620 | * Capture: It might not receave data. Do nothing | |
621 | */ | |
622 | if (rsnd_io_is_play(io)) { | |
623 | rsnd_mod_write(mod, SSICR, cr | EN); | |
624 | rsnd_ssi_status_check(mod, DIRQ); | |
625 | } | |
4e7d606c | 626 | |
e7d850dd KM |
627 | /* |
628 | * disable SSI, | |
629 | * and, wait idle state | |
630 | */ | |
631 | rsnd_mod_write(mod, SSICR, cr); /* disabled all */ | |
632 | rsnd_ssi_status_check(mod, IIRQ); | |
4e7d606c | 633 | |
597b046f KM |
634 | ssi->cr_en = 0; |
635 | ||
4e7d606c KM |
636 | return 0; |
637 | } | |
638 | ||
615fb6c7 KM |
639 | static int rsnd_ssi_irq(struct rsnd_mod *mod, |
640 | struct rsnd_dai_stream *io, | |
641 | struct rsnd_priv *priv, | |
642 | int enable) | |
643 | { | |
644 | u32 val = 0; | |
645 | ||
646 | if (rsnd_is_gen1(priv)) | |
647 | return 0; | |
648 | ||
649 | if (rsnd_ssi_is_parent(mod, io)) | |
650 | return 0; | |
651 | ||
fd9adcfd KM |
652 | if (!rsnd_ssi_is_run_mods(mod, io)) |
653 | return 0; | |
654 | ||
615fb6c7 KM |
655 | if (enable) |
656 | val = rsnd_ssi_is_dma_mode(mod) ? 0x0e000000 : 0x0f000000; | |
657 | ||
658 | rsnd_mod_write(mod, SSI_INT_ENABLE, val); | |
659 | ||
660 | return 0; | |
661 | } | |
662 | ||
bfc0cfe6 KM |
663 | static void __rsnd_ssi_interrupt(struct rsnd_mod *mod, |
664 | struct rsnd_dai_stream *io) | |
ae5c3223 | 665 | { |
690602fc | 666 | struct rsnd_priv *priv = rsnd_mod_to_priv(mod); |
765ae7c8 | 667 | int is_dma = rsnd_ssi_is_dma_mode(mod); |
02299d98 | 668 | u32 status; |
75defee0 | 669 | bool elapsed = false; |
6a25c8da | 670 | bool stop = false; |
02299d98 KM |
671 | |
672 | spin_lock(&priv->lock); | |
ae5c3223 | 673 | |
02299d98 | 674 | /* ignore all cases if not working */ |
d5bbe7de | 675 | if (!rsnd_io_is_working(io)) |
02299d98 KM |
676 | goto rsnd_ssi_interrupt_out; |
677 | ||
6a25c8da | 678 | status = rsnd_ssi_status_get(mod); |
4e7d606c KM |
679 | |
680 | /* PIO only */ | |
765ae7c8 | 681 | if (!is_dma && (status & DIRQ)) { |
ae5c3223 KM |
682 | struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
683 | u32 *buf = (u32 *)(runtime->dma_area + | |
a97a06c7 | 684 | rsnd_ssi_pointer_offset(mod, io, 0)); |
7819a942 KM |
685 | int shift = 0; |
686 | ||
687 | switch (runtime->sample_bits) { | |
688 | case 32: | |
689 | shift = 8; | |
690 | break; | |
691 | } | |
ae5c3223 | 692 | |
ae5c3223 KM |
693 | /* |
694 | * 8/16/32 data can be assesse to TDR/RDR register | |
695 | * directly as 32bit data | |
696 | * see rsnd_ssi_init() | |
697 | */ | |
985a4f6e | 698 | if (rsnd_io_is_play(io)) |
7819a942 | 699 | rsnd_mod_write(mod, SSITDR, (*buf) << shift); |
ae5c3223 | 700 | else |
7819a942 | 701 | *buf = (rsnd_mod_read(mod, SSIRDR) >> shift); |
ae5c3223 | 702 | |
a97a06c7 | 703 | elapsed = rsnd_ssi_pointer_update(mod, io, sizeof(*buf)); |
4e7d606c | 704 | } |
ae5c3223 | 705 | |
12927a8f | 706 | /* DMA only */ |
6a25c8da KM |
707 | if (is_dma && (status & (UIRQ | OIRQ))) |
708 | stop = true; | |
69e32a58 | 709 | |
5342dff2 | 710 | rsnd_ssi_status_clear(mod); |
02299d98 KM |
711 | rsnd_ssi_interrupt_out: |
712 | spin_unlock(&priv->lock); | |
713 | ||
75defee0 KM |
714 | if (elapsed) |
715 | rsnd_dai_period_elapsed(io); | |
6a25c8da KM |
716 | |
717 | if (stop) | |
718 | snd_pcm_stop_xrun(io->substream); | |
719 | ||
bfc0cfe6 KM |
720 | } |
721 | ||
722 | static irqreturn_t rsnd_ssi_interrupt(int irq, void *data) | |
723 | { | |
724 | struct rsnd_mod *mod = data; | |
725 | ||
726 | rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt); | |
75defee0 | 727 | |
4e7d606c | 728 | return IRQ_HANDLED; |
ae5c3223 KM |
729 | } |
730 | ||
6cfad789 KM |
731 | /* |
732 | * SSI PIO | |
733 | */ | |
e7d850dd | 734 | static void rsnd_ssi_parent_attach(struct rsnd_mod *mod, |
098bd891 | 735 | struct rsnd_dai_stream *io) |
e7d850dd | 736 | { |
098bd891 KM |
737 | struct rsnd_dai *rdai = rsnd_io_to_rdai(io); |
738 | struct rsnd_priv *priv = rsnd_mod_to_priv(mod); | |
739 | ||
e7d850dd KM |
740 | if (!__rsnd_ssi_is_pin_sharing(mod)) |
741 | return; | |
742 | ||
098bd891 KM |
743 | if (!rsnd_rdai_is_clk_master(rdai)) |
744 | return; | |
745 | ||
e7d850dd KM |
746 | switch (rsnd_mod_id(mod)) { |
747 | case 1: | |
748 | case 2: | |
749 | rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP); | |
750 | break; | |
751 | case 4: | |
752 | rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP); | |
753 | break; | |
754 | case 8: | |
755 | rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP); | |
756 | break; | |
757 | } | |
758 | } | |
759 | ||
098bd891 KM |
760 | static int rsnd_ssi_pcm_new(struct rsnd_mod *mod, |
761 | struct rsnd_dai_stream *io, | |
762 | struct snd_soc_pcm_runtime *rtd) | |
763 | { | |
764 | /* | |
765 | * rsnd_rdai_is_clk_master() will be enabled after set_fmt, | |
766 | * and, pcm_new will be called after it. | |
767 | * This function reuse pcm_new at this point. | |
768 | */ | |
769 | rsnd_ssi_parent_attach(mod, io); | |
770 | ||
771 | return 0; | |
772 | } | |
773 | ||
c7f69ab5 KM |
774 | static int rsnd_ssi_common_probe(struct rsnd_mod *mod, |
775 | struct rsnd_dai_stream *io, | |
776 | struct rsnd_priv *priv) | |
ff8f30e6 | 777 | { |
ff8f30e6 KM |
778 | struct device *dev = rsnd_priv_to_dev(priv); |
779 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
ff8f30e6 KM |
780 | int ret; |
781 | ||
b4c83b17 KM |
782 | /* |
783 | * SSIP/SSIU/IRQ are not needed on | |
784 | * SSI Multi slaves | |
785 | */ | |
786 | if (rsnd_ssi_is_multi_slave(mod, io)) | |
787 | return 0; | |
788 | ||
098bd891 KM |
789 | /* |
790 | * It can't judge ssi parent at this point | |
791 | * see rsnd_ssi_pcm_new() | |
792 | */ | |
e7d850dd | 793 | |
c7f69ab5 KM |
794 | ret = rsnd_ssiu_attach(io, mod); |
795 | if (ret < 0) | |
796 | return ret; | |
797 | ||
701172dc KM |
798 | /* |
799 | * SSI might be called again as PIO fallback | |
800 | * It is easy to manual handling for IRQ request/free | |
b6e58fca KM |
801 | * |
802 | * OTOH, this function might be called many times if platform is | |
803 | * using MIX. It needs xxx_attach() many times on xxx_probe(). | |
804 | * Because of it, we can't control .probe/.remove calling count by | |
805 | * mod->status. | |
806 | * But it don't need to call request_irq() many times. | |
807 | * Let's control it by RSND_SSI_PROBED flag. | |
701172dc | 808 | */ |
42991989 | 809 | if (!rsnd_flags_has(ssi, RSND_SSI_PROBED)) { |
b6e58fca KM |
810 | ret = request_irq(ssi->irq, |
811 | rsnd_ssi_interrupt, | |
812 | IRQF_SHARED, | |
813 | dev_name(dev), mod); | |
814 | ||
42991989 | 815 | rsnd_flags_set(ssi, RSND_SSI_PROBED); |
b6e58fca | 816 | } |
8aefda50 | 817 | |
ff8f30e6 KM |
818 | return ret; |
819 | } | |
820 | ||
213691c7 KM |
821 | static int rsnd_ssi_common_remove(struct rsnd_mod *mod, |
822 | struct rsnd_dai_stream *io, | |
823 | struct rsnd_priv *priv) | |
824 | { | |
825 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
826 | struct rsnd_mod *pure_ssi_mod = rsnd_io_to_mod_ssi(io); | |
827 | ||
828 | /* Do nothing if non SSI (= SSI parent, multi SSI) mod */ | |
829 | if (pure_ssi_mod != mod) | |
830 | return 0; | |
831 | ||
832 | /* PIO will request IRQ again */ | |
42991989 | 833 | if (rsnd_flags_has(ssi, RSND_SSI_PROBED)) { |
b6e58fca KM |
834 | free_irq(ssi->irq, mod); |
835 | ||
42991989 | 836 | rsnd_flags_del(ssi, RSND_SSI_PROBED); |
b6e58fca | 837 | } |
213691c7 KM |
838 | |
839 | return 0; | |
840 | } | |
841 | ||
07b7acb5 KM |
842 | static int rsnd_ssi_pointer(struct rsnd_mod *mod, |
843 | struct rsnd_dai_stream *io, | |
844 | snd_pcm_uframes_t *pointer) | |
845 | { | |
a97a06c7 | 846 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); |
07b7acb5 KM |
847 | struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
848 | ||
33f80136 | 849 | *pointer = bytes_to_frames(runtime, READ_ONCE(ssi->byte_pos)); |
07b7acb5 KM |
850 | |
851 | return 0; | |
852 | } | |
853 | ||
727588bf JW |
854 | static int rsnd_ssi_prepare(struct rsnd_mod *mod, |
855 | struct rsnd_dai_stream *io, | |
856 | struct rsnd_priv *priv) | |
857 | { | |
858 | return rsnd_ssi_master_clk_start(mod, io); | |
859 | } | |
860 | ||
ae5c3223 | 861 | static struct rsnd_mod_ops rsnd_ssi_pio_ops = { |
8aefda50 | 862 | .name = SSI_NAME, |
c7f69ab5 | 863 | .probe = rsnd_ssi_common_probe, |
213691c7 | 864 | .remove = rsnd_ssi_common_remove, |
ae5c3223 KM |
865 | .init = rsnd_ssi_init, |
866 | .quit = rsnd_ssi_quit, | |
49229850 KM |
867 | .start = rsnd_ssi_start, |
868 | .stop = rsnd_ssi_stop, | |
b5b442ab | 869 | .irq = rsnd_ssi_irq, |
07b7acb5 | 870 | .pointer= rsnd_ssi_pointer, |
098bd891 | 871 | .pcm_new = rsnd_ssi_pcm_new, |
919567d9 | 872 | .hw_params = rsnd_ssi_hw_params, |
727588bf | 873 | .prepare = rsnd_ssi_prepare, |
ae5c3223 KM |
874 | }; |
875 | ||
ff8f30e6 | 876 | static int rsnd_ssi_dma_probe(struct rsnd_mod *mod, |
2c0fac19 | 877 | struct rsnd_dai_stream *io, |
690602fc | 878 | struct rsnd_priv *priv) |
ff8f30e6 | 879 | { |
ff8f30e6 KM |
880 | int ret; |
881 | ||
b4c83b17 KM |
882 | /* |
883 | * SSIP/SSIU/IRQ/DMA are not needed on | |
884 | * SSI Multi slaves | |
885 | */ | |
886 | if (rsnd_ssi_is_multi_slave(mod, io)) | |
887 | return 0; | |
888 | ||
c7f69ab5 | 889 | ret = rsnd_ssi_common_probe(mod, io, priv); |
4e7d606c | 890 | if (ret) |
b543b52a | 891 | return ret; |
4e7d606c | 892 | |
355cb84f | 893 | /* SSI probe might be called many times in MUX multi path */ |
696cda79 | 894 | ret = rsnd_dma_attach(io, mod, &io->dma); |
8aefda50 | 895 | |
ff8f30e6 KM |
896 | return ret; |
897 | } | |
898 | ||
97463e19 | 899 | static int rsnd_ssi_fallback(struct rsnd_mod *mod, |
2c0fac19 | 900 | struct rsnd_dai_stream *io, |
690602fc | 901 | struct rsnd_priv *priv) |
ff8f30e6 | 902 | { |
d3a76823 KM |
903 | struct device *dev = rsnd_priv_to_dev(priv); |
904 | ||
d3a76823 KM |
905 | /* |
906 | * fallback to PIO | |
907 | * | |
908 | * SSI .probe might be called again. | |
909 | * see | |
910 | * rsnd_rdai_continuance_probe() | |
911 | */ | |
912 | mod->ops = &rsnd_ssi_pio_ops; | |
913 | ||
914 | dev_info(dev, "%s[%d] fallback to PIO mode\n", | |
915 | rsnd_mod_name(mod), rsnd_mod_id(mod)); | |
916 | ||
ff8f30e6 KM |
917 | return 0; |
918 | } | |
919 | ||
9b99e9a7 KM |
920 | static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io, |
921 | struct rsnd_mod *mod) | |
d9288d0b | 922 | { |
72adc61f | 923 | struct rsnd_priv *priv = rsnd_mod_to_priv(mod); |
72adc61f KM |
924 | int is_play = rsnd_io_is_play(io); |
925 | char *name; | |
926 | ||
b415b4d3 | 927 | if (rsnd_ssi_use_busif(io)) |
72adc61f KM |
928 | name = is_play ? "rxu" : "txu"; |
929 | else | |
930 | name = is_play ? "rx" : "tx"; | |
931 | ||
932 | return rsnd_dma_request_channel(rsnd_ssi_of_node(priv), | |
933 | mod, name); | |
d9288d0b KM |
934 | } |
935 | ||
849fc82a | 936 | static struct rsnd_mod_ops rsnd_ssi_dma_ops = { |
8aefda50 | 937 | .name = SSI_NAME, |
72adc61f | 938 | .dma_req = rsnd_ssi_dma_req, |
ff8f30e6 | 939 | .probe = rsnd_ssi_dma_probe, |
213691c7 | 940 | .remove = rsnd_ssi_common_remove, |
849fc82a KM |
941 | .init = rsnd_ssi_init, |
942 | .quit = rsnd_ssi_quit, | |
497debaa KM |
943 | .start = rsnd_ssi_start, |
944 | .stop = rsnd_ssi_stop, | |
c8e969a8 | 945 | .irq = rsnd_ssi_irq, |
098bd891 | 946 | .pcm_new = rsnd_ssi_pcm_new, |
97463e19 | 947 | .fallback = rsnd_ssi_fallback, |
919567d9 | 948 | .hw_params = rsnd_ssi_hw_params, |
727588bf | 949 | .prepare = rsnd_ssi_prepare, |
849fc82a KM |
950 | }; |
951 | ||
05795411 KM |
952 | int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod) |
953 | { | |
954 | return mod->ops == &rsnd_ssi_dma_ops; | |
955 | } | |
956 | ||
957 | ||
ae5c3223 KM |
958 | /* |
959 | * ssi mod function | |
960 | */ | |
b4c83b17 KM |
961 | static void rsnd_ssi_connect(struct rsnd_mod *mod, |
962 | struct rsnd_dai_stream *io) | |
963 | { | |
964 | struct rsnd_dai *rdai = rsnd_io_to_rdai(io); | |
965 | enum rsnd_mod_type types[] = { | |
966 | RSND_MOD_SSI, | |
967 | RSND_MOD_SSIM1, | |
968 | RSND_MOD_SSIM2, | |
969 | RSND_MOD_SSIM3, | |
970 | }; | |
971 | enum rsnd_mod_type type; | |
972 | int i; | |
973 | ||
974 | /* try SSI -> SSIM1 -> SSIM2 -> SSIM3 */ | |
975 | for (i = 0; i < ARRAY_SIZE(types); i++) { | |
976 | type = types[i]; | |
977 | if (!rsnd_io_to_mod(io, type)) { | |
978 | rsnd_dai_connect(mod, io, type); | |
1ff9593d KM |
979 | rsnd_rdai_channels_set(rdai, (i + 1) * 2); |
980 | rsnd_rdai_ssi_lane_set(rdai, (i + 1)); | |
b4c83b17 KM |
981 | return; |
982 | } | |
983 | } | |
984 | } | |
985 | ||
986 | void rsnd_parse_connect_ssi(struct rsnd_dai *rdai, | |
987 | struct device_node *playback, | |
988 | struct device_node *capture) | |
989 | { | |
990 | struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); | |
991 | struct device_node *node; | |
992 | struct device_node *np; | |
993 | struct rsnd_mod *mod; | |
994 | int i; | |
995 | ||
996 | node = rsnd_ssi_of_node(priv); | |
997 | if (!node) | |
998 | return; | |
999 | ||
1000 | i = 0; | |
1001 | for_each_child_of_node(node, np) { | |
1002 | mod = rsnd_ssi_mod_get(priv, i); | |
1003 | if (np == playback) | |
1004 | rsnd_ssi_connect(mod, &rdai->playback); | |
1005 | if (np == capture) | |
1006 | rsnd_ssi_connect(mod, &rdai->capture); | |
1007 | i++; | |
1008 | } | |
1009 | ||
1010 | of_node_put(node); | |
1011 | } | |
1012 | ||
7fa72cca KM |
1013 | static void __rsnd_ssi_parse_hdmi_connection(struct rsnd_priv *priv, |
1014 | struct rsnd_dai_stream *io, | |
1015 | struct device_node *remote_ep) | |
1016 | { | |
1017 | struct device *dev = rsnd_priv_to_dev(priv); | |
1018 | struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); | |
1019 | struct rsnd_ssi *ssi; | |
1020 | ||
1021 | if (!mod) | |
1022 | return; | |
1023 | ||
1024 | ssi = rsnd_mod_to_ssi(mod); | |
1025 | ||
1026 | if (strstr(remote_ep->full_name, "hdmi0")) { | |
42991989 | 1027 | rsnd_flags_set(ssi, RSND_SSI_HDMI0); |
7fa72cca KM |
1028 | dev_dbg(dev, "%s[%d] connected to HDMI0\n", |
1029 | rsnd_mod_name(mod), rsnd_mod_id(mod)); | |
1030 | } | |
1031 | ||
1032 | if (strstr(remote_ep->full_name, "hdmi1")) { | |
42991989 | 1033 | rsnd_flags_set(ssi, RSND_SSI_HDMI1); |
7fa72cca KM |
1034 | dev_dbg(dev, "%s[%d] connected to HDMI1\n", |
1035 | rsnd_mod_name(mod), rsnd_mod_id(mod)); | |
1036 | } | |
1037 | } | |
1038 | ||
1039 | void rsnd_ssi_parse_hdmi_connection(struct rsnd_priv *priv, | |
1040 | struct device_node *endpoint, | |
1041 | int dai_i) | |
1042 | { | |
1043 | struct rsnd_dai *rdai = rsnd_rdai_get(priv, dai_i); | |
1044 | struct device_node *remote_ep; | |
1045 | ||
1046 | remote_ep = of_graph_get_remote_endpoint(endpoint); | |
1047 | if (!remote_ep) | |
1048 | return; | |
1049 | ||
1050 | __rsnd_ssi_parse_hdmi_connection(priv, &rdai->playback, remote_ep); | |
1051 | __rsnd_ssi_parse_hdmi_connection(priv, &rdai->capture, remote_ep); | |
1052 | } | |
1053 | ||
ae5c3223 KM |
1054 | struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id) |
1055 | { | |
8b14719b TI |
1056 | if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv))) |
1057 | id = 0; | |
ae5c3223 | 1058 | |
02534f2f | 1059 | return rsnd_mod_get(rsnd_ssi_get(priv, id)); |
ae5c3223 KM |
1060 | } |
1061 | ||
b415b4d3 | 1062 | int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod) |
7b5ce975 KM |
1063 | { |
1064 | struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); | |
1065 | ||
42991989 | 1066 | return !!(rsnd_flags_has(ssi, RSND_SSI_CLK_PIN_SHARE)); |
7b5ce975 KM |
1067 | } |
1068 | ||
5ba17b42 KM |
1069 | static u32 *rsnd_ssi_get_status(struct rsnd_dai_stream *io, |
1070 | struct rsnd_mod *mod, | |
1071 | enum rsnd_mod_type type) | |
1072 | { | |
1073 | /* | |
1074 | * SSIP (= SSI parent) needs to be special, otherwise, | |
1075 | * 2nd SSI might doesn't start. see also rsnd_mod_call() | |
1076 | * | |
1077 | * We can't include parent SSI status on SSI, because we don't know | |
1078 | * how many SSI requests parent SSI. Thus, it is localed on "io" now. | |
1079 | * ex) trouble case | |
1080 | * Playback: SSI0 | |
1081 | * Capture : SSI1 (needs SSI0) | |
1082 | * | |
1083 | * 1) start Capture -> SSI0/SSI1 are started. | |
1084 | * 2) start Playback -> SSI0 doesn't work, because it is already | |
1085 | * marked as "started" on 1) | |
1086 | * | |
1087 | * OTOH, using each mod's status is good for MUX case. | |
1088 | * It doesn't need to start in 2nd start | |
1089 | * ex) | |
1090 | * IO-0: SRC0 -> CTU1 -+-> MUX -> DVC -> SSIU -> SSI0 | |
1091 | * | | |
1092 | * IO-1: SRC1 -> CTU2 -+ | |
1093 | * | |
1094 | * 1) start IO-0 -> start SSI0 | |
1095 | * 2) start IO-1 -> SSI0 doesn't need to start, because it is | |
1096 | * already started on 1) | |
1097 | */ | |
1098 | if (type == RSND_MOD_SSIP) | |
1099 | return &io->parent_ssi_status; | |
1100 | ||
1101 | return rsnd_mod_get_status(io, mod, type); | |
1102 | } | |
1103 | ||
2ea6b074 | 1104 | int rsnd_ssi_probe(struct rsnd_priv *priv) |
ae5c3223 | 1105 | { |
02534f2f KM |
1106 | struct device_node *node; |
1107 | struct device_node *np; | |
ae5c3223 KM |
1108 | struct device *dev = rsnd_priv_to_dev(priv); |
1109 | struct rsnd_mod_ops *ops; | |
1110 | struct clk *clk; | |
ae5c3223 KM |
1111 | struct rsnd_ssi *ssi; |
1112 | char name[RSND_SSI_NAME_SIZE]; | |
2f78dd7f | 1113 | int i, nr, ret; |
ae5c3223 | 1114 | |
02534f2f KM |
1115 | node = rsnd_ssi_of_node(priv); |
1116 | if (!node) | |
1117 | return -EINVAL; | |
1118 | ||
1119 | nr = of_get_child_count(node); | |
1120 | if (!nr) { | |
1121 | ret = -EINVAL; | |
1122 | goto rsnd_ssi_probe_done; | |
1123 | } | |
90e8e50f | 1124 | |
dd27d808 | 1125 | ssi = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL); |
02534f2f KM |
1126 | if (!ssi) { |
1127 | ret = -ENOMEM; | |
1128 | goto rsnd_ssi_probe_done; | |
1129 | } | |
ae5c3223 | 1130 | |
dd27d808 KM |
1131 | priv->ssi = ssi; |
1132 | priv->ssi_nr = nr; | |
ae5c3223 | 1133 | |
02534f2f KM |
1134 | i = 0; |
1135 | for_each_child_of_node(node, np) { | |
9e9e95df KM |
1136 | if (!of_device_is_available(np)) |
1137 | goto skip; | |
1138 | ||
02534f2f | 1139 | ssi = rsnd_ssi_get(priv, i); |
ae5c3223 | 1140 | |
8aefda50 KM |
1141 | snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d", |
1142 | SSI_NAME, i); | |
ae5c3223 | 1143 | |
60dbb4f1 | 1144 | clk = devm_clk_get(dev, name); |
02534f2f KM |
1145 | if (IS_ERR(clk)) { |
1146 | ret = PTR_ERR(clk); | |
53ba2aa3 | 1147 | of_node_put(np); |
02534f2f KM |
1148 | goto rsnd_ssi_probe_done; |
1149 | } | |
ae5c3223 | 1150 | |
02534f2f | 1151 | if (of_get_property(np, "shared-pin", NULL)) |
42991989 | 1152 | rsnd_flags_set(ssi, RSND_SSI_CLK_PIN_SHARE); |
02534f2f KM |
1153 | |
1154 | if (of_get_property(np, "no-busif", NULL)) | |
42991989 | 1155 | rsnd_flags_set(ssi, RSND_SSI_NO_BUSIF); |
02534f2f KM |
1156 | |
1157 | ssi->irq = irq_of_parse_and_map(np, 0); | |
1158 | if (!ssi->irq) { | |
1159 | ret = -EINVAL; | |
53ba2aa3 | 1160 | of_node_put(np); |
02534f2f KM |
1161 | goto rsnd_ssi_probe_done; |
1162 | } | |
ae5c3223 | 1163 | |
51930295 | 1164 | if (of_property_read_bool(np, "pio-transfer")) |
ff8f30e6 | 1165 | ops = &rsnd_ssi_pio_ops; |
02534f2f KM |
1166 | else |
1167 | ops = &rsnd_ssi_dma_ops; | |
ae5c3223 | 1168 | |
b76e218a | 1169 | ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk, |
5ba17b42 | 1170 | rsnd_ssi_get_status, RSND_MOD_SSI, i); |
53ba2aa3 JL |
1171 | if (ret) { |
1172 | of_node_put(np); | |
02534f2f | 1173 | goto rsnd_ssi_probe_done; |
53ba2aa3 | 1174 | } |
9e9e95df | 1175 | skip: |
02534f2f | 1176 | i++; |
ae5c3223 KM |
1177 | } |
1178 | ||
02534f2f KM |
1179 | ret = 0; |
1180 | ||
1181 | rsnd_ssi_probe_done: | |
1182 | of_node_put(node); | |
1183 | ||
1184 | return ret; | |
ae5c3223 | 1185 | } |
2f78dd7f | 1186 | |
2ea6b074 | 1187 | void rsnd_ssi_remove(struct rsnd_priv *priv) |
2f78dd7f KM |
1188 | { |
1189 | struct rsnd_ssi *ssi; | |
1190 | int i; | |
1191 | ||
1192 | for_each_rsnd_ssi(ssi, priv, i) { | |
b76e218a | 1193 | rsnd_mod_quit(rsnd_mod_get(ssi)); |
2f78dd7f KM |
1194 | } |
1195 | } |