1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <sound/simple_card_utils.h>
15#include <linux/delay.h>
16#include "rsnd.h"
17#define RSND_SSI_NAME_SIZE 16
18
19
20
21
22#define FORCE (1 << 31)
23#define DMEN (1 << 28)
24#define UIEN (1 << 27)
25#define OIEN (1 << 26)
26#define IIEN (1 << 25)
27#define DIEN (1 << 24)
28#define CHNL_4 (1 << 22)
29#define CHNL_6 (2 << 22)
30#define CHNL_8 (3 << 22)
31#define DWL_8 (0 << 19)
32#define DWL_16 (1 << 19)
33#define DWL_18 (2 << 19)
34#define DWL_20 (3 << 19)
35#define DWL_22 (4 << 19)
36#define DWL_24 (5 << 19)
37#define DWL_32 (6 << 19)
38
39#define SWL_32 (3 << 16)
40#define SCKD (1 << 15)
41#define SWSD (1 << 14)
42#define SCKP (1 << 13)
43#define SWSP (1 << 12)
44#define SDTA (1 << 10)
45#define PDTA (1 << 9)
46#define DEL (1 << 8)
47#define CKDV(v) (v << 4)
48#define TRMD (1 << 1)
49#define EN (1 << 0)
50
51
52
53
54#define UIRQ (1 << 27)
55#define OIRQ (1 << 26)
56#define IIRQ (1 << 25)
57#define DIRQ (1 << 24)
58
59
60
61
62#define CONT (1 << 8)
63#define WS_MODE (1 << 0)
64
65#define SSI_NAME "ssi"
66
67struct rsnd_ssi {
68 struct rsnd_mod mod;
69 struct rsnd_mod *dma;
70
71 u32 flags;
72 u32 cr_own;
73 u32 cr_clk;
74 u32 cr_mode;
75 u32 wsr;
76 int chan;
77 int rate;
78 int irq;
79 unsigned int usrcnt;
80
81 int byte_pos;
82 int period_pos;
83 int byte_per_period;
84 int next_period_byte;
85};
86
87
88#define RSND_SSI_CLK_PIN_SHARE (1 << 0)
89#define RSND_SSI_NO_BUSIF (1 << 1)
90#define RSND_SSI_HDMI0 (1 << 2)
91#define RSND_SSI_HDMI1 (1 << 3)
92
93#define for_each_rsnd_ssi(pos, priv, i) \
94 for (i = 0; \
95 (i < rsnd_ssi_nr(priv)) && \
96 ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i)); \
97 i++)
98
99#define rsnd_ssi_get(priv, id) ((struct rsnd_ssi *)(priv->ssi) + id)
100#define rsnd_ssi_to_dma(mod) ((ssi)->dma)
101#define rsnd_ssi_nr(priv) ((priv)->ssi_nr)
102#define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod)
103#define rsnd_ssi_mode_flags(p) ((p)->flags)
104#define rsnd_ssi_is_parent(ssi, io) ((ssi) == rsnd_io_to_mod_ssip(io))
105#define rsnd_ssi_is_multi_slave(mod, io) \
106 (rsnd_ssi_multi_slaves(io) & (1 << rsnd_mod_id(mod)))
107#define rsnd_ssi_is_run_mods(mod, io) \
108 (rsnd_ssi_run_mods(io) & (1 << rsnd_mod_id(mod)))
109
110int rsnd_ssi_hdmi_port(struct rsnd_dai_stream *io)
111{
112 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io);
113 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
114
115 if (rsnd_ssi_mode_flags(ssi) & RSND_SSI_HDMI0)
116 return RSND_SSI_HDMI_PORT0;
117
118 if (rsnd_ssi_mode_flags(ssi) & RSND_SSI_HDMI1)
119 return RSND_SSI_HDMI_PORT1;
120
121 return 0;
122}
123
124int rsnd_ssi_use_busif(struct rsnd_dai_stream *io)
125{
126 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io);
127 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
128 int use_busif = 0;
129
130 if (!rsnd_ssi_is_dma_mode(mod))
131 return 0;
132
133 if (!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_NO_BUSIF))
134 use_busif = 1;
135 if (rsnd_io_to_mod_src(io))
136 use_busif = 1;
137
138 return use_busif;
139}
140
141static void rsnd_ssi_status_clear(struct rsnd_mod *mod)
142{
143 rsnd_mod_write(mod, SSISR, 0);
144}
145
146static u32 rsnd_ssi_status_get(struct rsnd_mod *mod)
147{
148 return rsnd_mod_read(mod, SSISR);
149}
150
151static void rsnd_ssi_status_check(struct rsnd_mod *mod,
152 u32 bit)
153{
154 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
155 struct device *dev = rsnd_priv_to_dev(priv);
156 u32 status;
157 int i;
158
159 for (i = 0; i < 1024; i++) {
160 status = rsnd_ssi_status_get(mod);
161 if (status & bit)
162 return;
163
164 udelay(50);
165 }
166
167 dev_warn(dev, "%s[%d] status check failed\n",
168 rsnd_mod_name(mod), rsnd_mod_id(mod));
169}
170
171static u32 rsnd_ssi_multi_slaves(struct rsnd_dai_stream *io)
172{
173 struct rsnd_mod *mod;
174 enum rsnd_mod_type types[] = {
175 RSND_MOD_SSIM1,
176 RSND_MOD_SSIM2,
177 RSND_MOD_SSIM3,
178 };
179 int i, mask;
180
181 mask = 0;
182 for (i = 0; i < ARRAY_SIZE(types); i++) {
183 mod = rsnd_io_to_mod(io, types[i]);
184 if (!mod)
185 continue;
186
187 mask |= 1 << rsnd_mod_id(mod);
188 }
189
190 return mask;
191}
192
193static u32 rsnd_ssi_run_mods(struct rsnd_dai_stream *io)
194{
195 struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);
196 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
197
198 return rsnd_ssi_multi_slaves_runtime(io) |
199 1 << rsnd_mod_id(ssi_mod) |
200 1 << rsnd_mod_id(ssi_parent_mod);
201}
202
203u32 rsnd_ssi_multi_slaves_runtime(struct rsnd_dai_stream *io)
204{
205 if (rsnd_runtime_is_ssi_multi(io))
206 return rsnd_ssi_multi_slaves(io);
207
208 return 0;
209}
210
211unsigned int rsnd_ssi_clk_query(struct rsnd_priv *priv,
212 int param1, int param2, int *idx)
213{
214 int ssi_clk_mul_table[] = {
215 1, 2, 4, 8, 16, 6, 12,
216 };
217 int j, ret;
218 unsigned int main_rate;
219
220 for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) {
221
222
223
224
225
226
227
228 if (j == 0)
229 continue;
230
231
232
233
234
235
236 main_rate = 32 * param1 * param2 * ssi_clk_mul_table[j];
237
238 ret = rsnd_adg_clk_query(priv, main_rate);
239 if (ret < 0)
240 continue;
241
242 if (idx)
243 *idx = j;
244
245 return main_rate;
246 }
247
248 return 0;
249}
250
251static int rsnd_ssi_master_clk_start(struct rsnd_mod *mod,
252 struct rsnd_dai_stream *io)
253{
254 struct rsnd_priv *priv = rsnd_io_to_priv(io);
255 struct device *dev = rsnd_priv_to_dev(priv);
256 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
257 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
258 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
259 int chan = rsnd_runtime_channel_for_ssi(io);
260 int idx, ret;
261 unsigned int main_rate;
262 unsigned int rate = rsnd_io_is_play(io) ?
263 rsnd_src_get_out_rate(priv, io) :
264 rsnd_src_get_in_rate(priv, io);
265
266 if (!rsnd_rdai_is_clk_master(rdai))
267 return 0;
268
269 if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io))
270 return 0;
271
272 if (rsnd_ssi_is_multi_slave(mod, io))
273 return 0;
274
275 if (ssi->usrcnt > 1) {
276 if (ssi->rate != rate) {
277 dev_err(dev, "SSI parent/child should use same rate\n");
278 return -EINVAL;
279 }
280
281 return 0;
282 }
283
284 main_rate = rsnd_ssi_clk_query(priv, rate, chan, &idx);
285 if (!main_rate) {
286 dev_err(dev, "unsupported clock rate\n");
287 return -EIO;
288 }
289
290 ret = rsnd_adg_ssi_clk_try_start(mod, main_rate);
291 if (ret < 0)
292 return ret;
293
294 ssi->cr_clk = FORCE | SWL_32 | SCKD | SWSD | CKDV(idx);
295 ssi->wsr = CONT;
296 ssi->rate = rate;
297
298 dev_dbg(dev, "%s[%d] outputs %u Hz\n",
299 rsnd_mod_name(mod),
300 rsnd_mod_id(mod), rate);
301
302 return 0;
303}
304
305static void rsnd_ssi_master_clk_stop(struct rsnd_mod *mod,
306 struct rsnd_dai_stream *io)
307{
308 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
309 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
310 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
311
312 if (!rsnd_rdai_is_clk_master(rdai))
313 return;
314
315 if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io))
316 return;
317
318 if (ssi->usrcnt > 1)
319 return;
320
321 ssi->cr_clk = 0;
322 ssi->rate = 0;
323
324 rsnd_adg_ssi_clk_stop(mod);
325}
326
327static void rsnd_ssi_config_init(struct rsnd_mod *mod,
328 struct rsnd_dai_stream *io)
329{
330 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
331 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
332 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
333 u32 cr_own;
334 u32 cr_mode;
335 u32 wsr;
336 int is_tdm;
337
338 is_tdm = rsnd_runtime_is_ssi_tdm(io);
339
340
341
342
343
344 cr_own = FORCE | SWL_32;
345
346 if (rdai->bit_clk_inv)
347 cr_own |= SCKP;
348 if (rdai->frm_clk_inv ^ is_tdm)
349 cr_own |= SWSP;
350 if (rdai->data_alignment)
351 cr_own |= SDTA;
352 if (rdai->sys_delay)
353 cr_own |= DEL;
354 if (rsnd_io_is_play(io))
355 cr_own |= TRMD;
356
357 switch (runtime->sample_bits) {
358 case 16:
359 cr_own |= DWL_16;
360 break;
361 case 32:
362 cr_own |= DWL_24;
363 break;
364 }
365
366 if (rsnd_ssi_is_dma_mode(mod)) {
367 cr_mode = UIEN | OIEN |
368 DMEN;
369 } else {
370 cr_mode = DIEN;
371 }
372
373
374
375
376
377
378 wsr = ssi->wsr;
379 if (is_tdm) {
380 wsr |= WS_MODE;
381 cr_own |= CHNL_8;
382 }
383
384 ssi->cr_own = cr_own;
385 ssi->cr_mode = cr_mode;
386 ssi->wsr = wsr;
387}
388
389static void rsnd_ssi_register_setup(struct rsnd_mod *mod)
390{
391 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
392
393 rsnd_mod_write(mod, SSIWSR, ssi->wsr);
394 rsnd_mod_write(mod, SSICR, ssi->cr_own |
395 ssi->cr_clk |
396 ssi->cr_mode);
397}
398
399static void rsnd_ssi_pointer_init(struct rsnd_mod *mod,
400 struct rsnd_dai_stream *io)
401{
402 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
403 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
404
405 ssi->byte_pos = 0;
406 ssi->period_pos = 0;
407 ssi->byte_per_period = runtime->period_size *
408 runtime->channels *
409 samples_to_bytes(runtime, 1);
410 ssi->next_period_byte = ssi->byte_per_period;
411}
412
413static int rsnd_ssi_pointer_offset(struct rsnd_mod *mod,
414 struct rsnd_dai_stream *io,
415 int additional)
416{
417 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
418 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
419 int pos = ssi->byte_pos + additional;
420
421 pos %= (runtime->periods * ssi->byte_per_period);
422
423 return pos;
424}
425
426static bool rsnd_ssi_pointer_update(struct rsnd_mod *mod,
427 struct rsnd_dai_stream *io,
428 int byte)
429{
430 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
431
432 ssi->byte_pos += byte;
433
434 if (ssi->byte_pos >= ssi->next_period_byte) {
435 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
436
437 ssi->period_pos++;
438 ssi->next_period_byte += ssi->byte_per_period;
439
440 if (ssi->period_pos >= runtime->periods) {
441 ssi->byte_pos = 0;
442 ssi->period_pos = 0;
443 ssi->next_period_byte = ssi->byte_per_period;
444 }
445
446 return true;
447 }
448
449 return false;
450}
451
452
453
454
455static int rsnd_ssi_init(struct rsnd_mod *mod,
456 struct rsnd_dai_stream *io,
457 struct rsnd_priv *priv)
458{
459 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
460 int ret;
461
462 if (!rsnd_ssi_is_run_mods(mod, io))
463 return 0;
464
465 rsnd_ssi_pointer_init(mod, io);
466
467 ssi->usrcnt++;
468
469 rsnd_mod_power_on(mod);
470
471 ret = rsnd_ssi_master_clk_start(mod, io);
472 if (ret < 0)
473 return ret;
474
475 if (!rsnd_ssi_is_parent(mod, io))
476 rsnd_ssi_config_init(mod, io);
477
478 rsnd_ssi_register_setup(mod);
479
480
481 rsnd_ssi_status_clear(mod);
482
483 return 0;
484}
485
486static int rsnd_ssi_quit(struct rsnd_mod *mod,
487 struct rsnd_dai_stream *io,
488 struct rsnd_priv *priv)
489{
490 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
491 struct device *dev = rsnd_priv_to_dev(priv);
492
493 if (!rsnd_ssi_is_run_mods(mod, io))
494 return 0;
495
496 if (!ssi->usrcnt) {
497 dev_err(dev, "%s[%d] usrcnt error\n",
498 rsnd_mod_name(mod), rsnd_mod_id(mod));
499 return -EIO;
500 }
501
502 if (!rsnd_ssi_is_parent(mod, io))
503 ssi->cr_own = 0;
504
505 rsnd_ssi_master_clk_stop(mod, io);
506
507 rsnd_mod_power_off(mod);
508
509 ssi->usrcnt--;
510
511 return 0;
512}
513
514static int rsnd_ssi_hw_params(struct rsnd_mod *mod,
515 struct rsnd_dai_stream *io,
516 struct snd_pcm_substream *substream,
517 struct snd_pcm_hw_params *params)
518{
519 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
520 int chan = params_channels(params);
521
522
523
524
525
526
527 if (ssi->usrcnt) {
528
529
530
531
532
533
534 if (ssi->chan != chan)
535 return -EIO;
536 }
537
538 ssi->chan = chan;
539
540 return 0;
541}
542
543static int rsnd_ssi_start(struct rsnd_mod *mod,
544 struct rsnd_dai_stream *io,
545 struct rsnd_priv *priv)
546{
547 if (!rsnd_ssi_is_run_mods(mod, io))
548 return 0;
549
550
551
552
553
554 if (rsnd_ssi_multi_slaves_runtime(io))
555 return 0;
556
557 rsnd_mod_bset(mod, SSICR, EN, EN);
558
559 return 0;
560}
561
562static int rsnd_ssi_stop(struct rsnd_mod *mod,
563 struct rsnd_dai_stream *io,
564 struct rsnd_priv *priv)
565{
566 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
567 u32 cr;
568
569 if (!rsnd_ssi_is_run_mods(mod, io))
570 return 0;
571
572
573
574
575
576
577
578 if (ssi->usrcnt > 1)
579 return 0;
580
581
582
583
584
585 cr = ssi->cr_own |
586 ssi->cr_clk;
587
588 rsnd_mod_write(mod, SSICR, cr | EN);
589 rsnd_ssi_status_check(mod, DIRQ);
590
591
592
593
594
595 rsnd_mod_write(mod, SSICR, cr);
596 rsnd_ssi_status_check(mod, IIRQ);
597
598 return 0;
599}
600
601static int rsnd_ssi_irq(struct rsnd_mod *mod,
602 struct rsnd_dai_stream *io,
603 struct rsnd_priv *priv,
604 int enable)
605{
606 u32 val = 0;
607
608 if (rsnd_is_gen1(priv))
609 return 0;
610
611 if (rsnd_ssi_is_parent(mod, io))
612 return 0;
613
614 if (!rsnd_ssi_is_run_mods(mod, io))
615 return 0;
616
617 if (enable)
618 val = rsnd_ssi_is_dma_mode(mod) ? 0x0e000000 : 0x0f000000;
619
620 rsnd_mod_write(mod, SSI_INT_ENABLE, val);
621
622 return 0;
623}
624
625static void __rsnd_ssi_interrupt(struct rsnd_mod *mod,
626 struct rsnd_dai_stream *io)
627{
628 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
629 int is_dma = rsnd_ssi_is_dma_mode(mod);
630 u32 status;
631 bool elapsed = false;
632 bool stop = false;
633
634 spin_lock(&priv->lock);
635
636
637 if (!rsnd_io_is_working(io))
638 goto rsnd_ssi_interrupt_out;
639
640 status = rsnd_ssi_status_get(mod);
641
642
643 if (!is_dma && (status & DIRQ)) {
644 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
645 u32 *buf = (u32 *)(runtime->dma_area +
646 rsnd_ssi_pointer_offset(mod, io, 0));
647 int shift = 0;
648
649 switch (runtime->sample_bits) {
650 case 32:
651 shift = 8;
652 break;
653 }
654
655
656
657
658
659
660 if (rsnd_io_is_play(io))
661 rsnd_mod_write(mod, SSITDR, (*buf) << shift);
662 else
663 *buf = (rsnd_mod_read(mod, SSIRDR) >> shift);
664
665 elapsed = rsnd_ssi_pointer_update(mod, io, sizeof(*buf));
666 }
667
668
669 if (is_dma && (status & (UIRQ | OIRQ)))
670 stop = true;
671
672 rsnd_ssi_status_clear(mod);
673rsnd_ssi_interrupt_out:
674 spin_unlock(&priv->lock);
675
676 if (elapsed)
677 rsnd_dai_period_elapsed(io);
678
679 if (stop)
680 snd_pcm_stop_xrun(io->substream);
681
682}
683
684static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
685{
686 struct rsnd_mod *mod = data;
687
688 rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt);
689
690 return IRQ_HANDLED;
691}
692
693
694
695
696static void rsnd_ssi_parent_attach(struct rsnd_mod *mod,
697 struct rsnd_dai_stream *io)
698{
699 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
700 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
701
702 if (!__rsnd_ssi_is_pin_sharing(mod))
703 return;
704
705 if (!rsnd_rdai_is_clk_master(rdai))
706 return;
707
708 switch (rsnd_mod_id(mod)) {
709 case 1:
710 case 2:
711 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP);
712 break;
713 case 4:
714 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP);
715 break;
716 case 8:
717 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP);
718 break;
719 }
720}
721
722static int rsnd_ssi_pcm_new(struct rsnd_mod *mod,
723 struct rsnd_dai_stream *io,
724 struct snd_soc_pcm_runtime *rtd)
725{
726
727
728
729
730
731 rsnd_ssi_parent_attach(mod, io);
732
733 return 0;
734}
735
736static int rsnd_ssi_common_probe(struct rsnd_mod *mod,
737 struct rsnd_dai_stream *io,
738 struct rsnd_priv *priv)
739{
740 struct device *dev = rsnd_priv_to_dev(priv);
741 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
742 int ret;
743
744
745
746
747
748 if (rsnd_ssi_is_multi_slave(mod, io))
749 return 0;
750
751
752
753
754
755
756 ret = rsnd_ssiu_attach(io, mod);
757 if (ret < 0)
758 return ret;
759
760
761
762
763
764 ret = request_irq(ssi->irq,
765 rsnd_ssi_interrupt,
766 IRQF_SHARED,
767 dev_name(dev), mod);
768
769 return ret;
770}
771
772static int rsnd_ssi_pointer(struct rsnd_mod *mod,
773 struct rsnd_dai_stream *io,
774 snd_pcm_uframes_t *pointer)
775{
776 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
777 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
778
779 *pointer = bytes_to_frames(runtime, ssi->byte_pos);
780
781 return 0;
782}
783
784static struct rsnd_mod_ops rsnd_ssi_pio_ops = {
785 .name = SSI_NAME,
786 .probe = rsnd_ssi_common_probe,
787 .init = rsnd_ssi_init,
788 .quit = rsnd_ssi_quit,
789 .start = rsnd_ssi_start,
790 .stop = rsnd_ssi_stop,
791 .irq = rsnd_ssi_irq,
792 .pointer= rsnd_ssi_pointer,
793 .pcm_new = rsnd_ssi_pcm_new,
794 .hw_params = rsnd_ssi_hw_params,
795};
796
797static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
798 struct rsnd_dai_stream *io,
799 struct rsnd_priv *priv)
800{
801 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
802 int ret;
803
804
805
806
807
808 if (rsnd_ssi_is_multi_slave(mod, io))
809 return 0;
810
811 ret = rsnd_ssi_common_probe(mod, io, priv);
812 if (ret)
813 return ret;
814
815
816 ret = rsnd_dma_attach(io, mod, &ssi->dma);
817
818 return ret;
819}
820
821static int rsnd_ssi_dma_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 *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
827
828
829 if (ssi_parent_mod == mod)
830 return 0;
831
832
833 free_irq(ssi->irq, mod);
834
835 return 0;
836}
837
838static int rsnd_ssi_fallback(struct rsnd_mod *mod,
839 struct rsnd_dai_stream *io,
840 struct rsnd_priv *priv)
841{
842 struct device *dev = rsnd_priv_to_dev(priv);
843
844
845
846
847
848
849
850
851 mod->ops = &rsnd_ssi_pio_ops;
852
853 dev_info(dev, "%s[%d] fallback to PIO mode\n",
854 rsnd_mod_name(mod), rsnd_mod_id(mod));
855
856 return 0;
857}
858
859static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io,
860 struct rsnd_mod *mod)
861{
862 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
863 int is_play = rsnd_io_is_play(io);
864 char *name;
865
866 if (rsnd_ssi_use_busif(io))
867 name = is_play ? "rxu" : "txu";
868 else
869 name = is_play ? "rx" : "tx";
870
871 return rsnd_dma_request_channel(rsnd_ssi_of_node(priv),
872 mod, name);
873}
874
875static struct rsnd_mod_ops rsnd_ssi_dma_ops = {
876 .name = SSI_NAME,
877 .dma_req = rsnd_ssi_dma_req,
878 .probe = rsnd_ssi_dma_probe,
879 .remove = rsnd_ssi_dma_remove,
880 .init = rsnd_ssi_init,
881 .quit = rsnd_ssi_quit,
882 .start = rsnd_ssi_start,
883 .stop = rsnd_ssi_stop,
884 .irq = rsnd_ssi_irq,
885 .pcm_new = rsnd_ssi_pcm_new,
886 .fallback = rsnd_ssi_fallback,
887 .hw_params = rsnd_ssi_hw_params,
888};
889
890int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod)
891{
892 return mod->ops == &rsnd_ssi_dma_ops;
893}
894
895
896
897
898
899static void rsnd_ssi_connect(struct rsnd_mod *mod,
900 struct rsnd_dai_stream *io)
901{
902 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
903 enum rsnd_mod_type types[] = {
904 RSND_MOD_SSI,
905 RSND_MOD_SSIM1,
906 RSND_MOD_SSIM2,
907 RSND_MOD_SSIM3,
908 };
909 enum rsnd_mod_type type;
910 int i;
911
912
913 for (i = 0; i < ARRAY_SIZE(types); i++) {
914 type = types[i];
915 if (!rsnd_io_to_mod(io, type)) {
916 rsnd_dai_connect(mod, io, type);
917 rsnd_rdai_channels_set(rdai, (i + 1) * 2);
918 rsnd_rdai_ssi_lane_set(rdai, (i + 1));
919 return;
920 }
921 }
922}
923
924void rsnd_parse_connect_ssi(struct rsnd_dai *rdai,
925 struct device_node *playback,
926 struct device_node *capture)
927{
928 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);
929 struct device_node *node;
930 struct device_node *np;
931 struct rsnd_mod *mod;
932 int i;
933
934 node = rsnd_ssi_of_node(priv);
935 if (!node)
936 return;
937
938 i = 0;
939 for_each_child_of_node(node, np) {
940 mod = rsnd_ssi_mod_get(priv, i);
941 if (np == playback)
942 rsnd_ssi_connect(mod, &rdai->playback);
943 if (np == capture)
944 rsnd_ssi_connect(mod, &rdai->capture);
945 i++;
946 }
947
948 of_node_put(node);
949}
950
951static void __rsnd_ssi_parse_hdmi_connection(struct rsnd_priv *priv,
952 struct rsnd_dai_stream *io,
953 struct device_node *remote_ep)
954{
955 struct device *dev = rsnd_priv_to_dev(priv);
956 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io);
957 struct rsnd_ssi *ssi;
958
959 if (!mod)
960 return;
961
962 ssi = rsnd_mod_to_ssi(mod);
963
964 if (strstr(remote_ep->full_name, "hdmi0")) {
965 ssi->flags |= RSND_SSI_HDMI0;
966 dev_dbg(dev, "%s[%d] connected to HDMI0\n",
967 rsnd_mod_name(mod), rsnd_mod_id(mod));
968 }
969
970 if (strstr(remote_ep->full_name, "hdmi1")) {
971 ssi->flags |= RSND_SSI_HDMI1;
972 dev_dbg(dev, "%s[%d] connected to HDMI1\n",
973 rsnd_mod_name(mod), rsnd_mod_id(mod));
974 }
975}
976
977void rsnd_ssi_parse_hdmi_connection(struct rsnd_priv *priv,
978 struct device_node *endpoint,
979 int dai_i)
980{
981 struct rsnd_dai *rdai = rsnd_rdai_get(priv, dai_i);
982 struct device_node *remote_ep;
983
984 remote_ep = of_graph_get_remote_endpoint(endpoint);
985 if (!remote_ep)
986 return;
987
988 __rsnd_ssi_parse_hdmi_connection(priv, &rdai->playback, remote_ep);
989 __rsnd_ssi_parse_hdmi_connection(priv, &rdai->capture, remote_ep);
990}
991
992struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id)
993{
994 if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv)))
995 id = 0;
996
997 return rsnd_mod_get(rsnd_ssi_get(priv, id));
998}
999
1000int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod)
1001{
1002 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
1003
1004 return !!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_CLK_PIN_SHARE);
1005}
1006
1007static u32 *rsnd_ssi_get_status(struct rsnd_dai_stream *io,
1008 struct rsnd_mod *mod,
1009 enum rsnd_mod_type type)
1010{
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036 if (type == RSND_MOD_SSIP)
1037 return &io->parent_ssi_status;
1038
1039 return rsnd_mod_get_status(io, mod, type);
1040}
1041
1042int rsnd_ssi_probe(struct rsnd_priv *priv)
1043{
1044 struct device_node *node;
1045 struct device_node *np;
1046 struct device *dev = rsnd_priv_to_dev(priv);
1047 struct rsnd_mod_ops *ops;
1048 struct clk *clk;
1049 struct rsnd_ssi *ssi;
1050 char name[RSND_SSI_NAME_SIZE];
1051 int i, nr, ret;
1052
1053 node = rsnd_ssi_of_node(priv);
1054 if (!node)
1055 return -EINVAL;
1056
1057 nr = of_get_child_count(node);
1058 if (!nr) {
1059 ret = -EINVAL;
1060 goto rsnd_ssi_probe_done;
1061 }
1062
1063 ssi = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL);
1064 if (!ssi) {
1065 ret = -ENOMEM;
1066 goto rsnd_ssi_probe_done;
1067 }
1068
1069 priv->ssi = ssi;
1070 priv->ssi_nr = nr;
1071
1072 i = 0;
1073 for_each_child_of_node(node, np) {
1074 ssi = rsnd_ssi_get(priv, i);
1075
1076 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d",
1077 SSI_NAME, i);
1078
1079 clk = devm_clk_get(dev, name);
1080 if (IS_ERR(clk)) {
1081 ret = PTR_ERR(clk);
1082 goto rsnd_ssi_probe_done;
1083 }
1084
1085 if (of_get_property(np, "shared-pin", NULL))
1086 ssi->flags |= RSND_SSI_CLK_PIN_SHARE;
1087
1088 if (of_get_property(np, "no-busif", NULL))
1089 ssi->flags |= RSND_SSI_NO_BUSIF;
1090
1091 ssi->irq = irq_of_parse_and_map(np, 0);
1092 if (!ssi->irq) {
1093 ret = -EINVAL;
1094 goto rsnd_ssi_probe_done;
1095 }
1096
1097 if (of_property_read_bool(np, "pio-transfer"))
1098 ops = &rsnd_ssi_pio_ops;
1099 else
1100 ops = &rsnd_ssi_dma_ops;
1101
1102 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk,
1103 rsnd_ssi_get_status, RSND_MOD_SSI, i);
1104 if (ret)
1105 goto rsnd_ssi_probe_done;
1106
1107 i++;
1108 }
1109
1110 ret = 0;
1111
1112rsnd_ssi_probe_done:
1113 of_node_put(node);
1114
1115 return ret;
1116}
1117
1118void rsnd_ssi_remove(struct rsnd_priv *priv)
1119{
1120 struct rsnd_ssi *ssi;
1121 int i;
1122
1123 for_each_rsnd_ssi(ssi, priv, i) {
1124 rsnd_mod_quit(rsnd_mod_get(ssi));
1125 }
1126}
1127