]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - sound/soc/sh/rcar/ssi.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ASoC: rsnd: fixup forever loop bug on SSI
[mirror_ubuntu-artful-kernel.git] / sound / soc / sh / rcar / ssi.c
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 */
14 #include <linux/delay.h>
15 #include "rsnd.h"
16 #define RSND_SSI_NAME_SIZE 16
17
18 /*
19 * SSICR
20 */
21 #define FORCE (1 << 31) /* Fixed */
22 #define DMEN (1 << 28) /* DMA Enable */
23 #define UIEN (1 << 27) /* Underflow Interrupt Enable */
24 #define OIEN (1 << 26) /* Overflow Interrupt Enable */
25 #define IIEN (1 << 25) /* Idle Mode Interrupt Enable */
26 #define DIEN (1 << 24) /* Data Interrupt Enable */
27 #define CHNL_4 (1 << 22) /* Channels */
28 #define CHNL_6 (2 << 22) /* Channels */
29 #define CHNL_8 (3 << 22) /* Channels */
30 #define DWL_8 (0 << 19) /* Data Word Length */
31 #define DWL_16 (1 << 19) /* Data Word Length */
32 #define DWL_18 (2 << 19) /* Data Word Length */
33 #define DWL_20 (3 << 19) /* Data Word Length */
34 #define DWL_22 (4 << 19) /* Data Word Length */
35 #define DWL_24 (5 << 19) /* Data Word Length */
36 #define DWL_32 (6 << 19) /* Data Word Length */
37
38 #define SWL_32 (3 << 16) /* R/W System Word Length */
39 #define SCKD (1 << 15) /* Serial Bit Clock Direction */
40 #define SWSD (1 << 14) /* Serial WS Direction */
41 #define SCKP (1 << 13) /* Serial Bit Clock Polarity */
42 #define SWSP (1 << 12) /* Serial WS Polarity */
43 #define SDTA (1 << 10) /* Serial Data Alignment */
44 #define PDTA (1 << 9) /* Parallel Data Alignment */
45 #define DEL (1 << 8) /* Serial Data Delay */
46 #define CKDV(v) (v << 4) /* Serial Clock Division Ratio */
47 #define TRMD (1 << 1) /* Transmit/Receive Mode Select */
48 #define EN (1 << 0) /* SSI Module Enable */
49
50 /*
51 * SSISR
52 */
53 #define UIRQ (1 << 27) /* Underflow Error Interrupt Status */
54 #define OIRQ (1 << 26) /* Overflow Error Interrupt Status */
55 #define IIRQ (1 << 25) /* Idle Mode Interrupt Status */
56 #define DIRQ (1 << 24) /* Data Interrupt Status Flag */
57
58 /*
59 * SSIWSR
60 */
61 #define CONT (1 << 8) /* WS Continue Function */
62 #define WS_MODE (1 << 0) /* WS Mode */
63
64 #define SSI_NAME "ssi"
65
66 struct rsnd_ssi {
67 struct rsnd_mod mod;
68 struct rsnd_mod *dma;
69
70 u32 flags;
71 u32 cr_own;
72 u32 cr_clk;
73 u32 cr_mode;
74 u32 wsr;
75 int chan;
76 int rate;
77 int irq;
78 unsigned int usrcnt;
79 };
80
81 /* flags */
82 #define RSND_SSI_CLK_PIN_SHARE (1 << 0)
83 #define RSND_SSI_NO_BUSIF (1 << 1) /* SSI+DMA without BUSIF */
84
85 #define for_each_rsnd_ssi(pos, priv, i) \
86 for (i = 0; \
87 (i < rsnd_ssi_nr(priv)) && \
88 ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i)); \
89 i++)
90
91 #define rsnd_ssi_get(priv, id) ((struct rsnd_ssi *)(priv->ssi) + id)
92 #define rsnd_ssi_to_dma(mod) ((ssi)->dma)
93 #define rsnd_ssi_nr(priv) ((priv)->ssi_nr)
94 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod)
95 #define rsnd_ssi_mode_flags(p) ((p)->flags)
96 #define rsnd_ssi_is_parent(ssi, io) ((ssi) == rsnd_io_to_mod_ssip(io))
97 #define rsnd_ssi_is_multi_slave(mod, io) \
98 (rsnd_ssi_multi_slaves(io) & (1 << rsnd_mod_id(mod)))
99
100 int rsnd_ssi_use_busif(struct rsnd_dai_stream *io)
101 {
102 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io);
103 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
104 int use_busif = 0;
105
106 if (!rsnd_ssi_is_dma_mode(mod))
107 return 0;
108
109 if (!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_NO_BUSIF))
110 use_busif = 1;
111 if (rsnd_io_to_mod_src(io))
112 use_busif = 1;
113
114 return use_busif;
115 }
116
117 static void rsnd_ssi_status_clear(struct rsnd_mod *mod)
118 {
119 rsnd_mod_write(mod, SSISR, 0);
120 }
121
122 static u32 rsnd_ssi_status_get(struct rsnd_mod *mod)
123 {
124 return rsnd_mod_read(mod, SSISR);
125 }
126
127 static void rsnd_ssi_status_check(struct rsnd_mod *mod,
128 u32 bit)
129 {
130 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
131 struct device *dev = rsnd_priv_to_dev(priv);
132 u32 status;
133 int i;
134
135 for (i = 0; i < 1024; i++) {
136 status = rsnd_ssi_status_get(mod);
137 if (status & bit)
138 return;
139
140 udelay(50);
141 }
142
143 dev_warn(dev, "%s[%d] status check failed\n",
144 rsnd_mod_name(mod), rsnd_mod_id(mod));
145 }
146
147 static int rsnd_ssi_irq(struct rsnd_mod *mod,
148 struct rsnd_dai_stream *io,
149 struct rsnd_priv *priv,
150 int enable)
151 {
152 u32 val = 0;
153
154 if (rsnd_is_gen1(priv))
155 return 0;
156
157 if (rsnd_ssi_is_parent(mod, io))
158 return 0;
159
160 if (enable)
161 val = rsnd_ssi_is_dma_mode(mod) ? 0x0e000000 : 0x0f000000;
162
163 rsnd_mod_write(mod, SSI_INT_ENABLE, val);
164
165 return 0;
166 }
167
168 u32 rsnd_ssi_multi_slaves(struct rsnd_dai_stream *io)
169 {
170 struct rsnd_mod *mod;
171 enum rsnd_mod_type types[] = {
172 RSND_MOD_SSIM1,
173 RSND_MOD_SSIM2,
174 RSND_MOD_SSIM3,
175 };
176 int i, mask;
177
178 mask = 0;
179 for (i = 0; i < ARRAY_SIZE(types); i++) {
180 mod = rsnd_io_to_mod(io, types[i]);
181 if (!mod)
182 continue;
183
184 mask |= 1 << rsnd_mod_id(mod);
185 }
186
187 return mask;
188 }
189
190 static int rsnd_ssi_master_clk_start(struct rsnd_mod *mod,
191 struct rsnd_dai_stream *io)
192 {
193 struct rsnd_priv *priv = rsnd_io_to_priv(io);
194 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
195 struct device *dev = rsnd_priv_to_dev(priv);
196 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
197 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
198 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
199 int slots = rsnd_get_slot_width(io);
200 int j, ret;
201 int ssi_clk_mul_table[] = {
202 1, 2, 4, 8, 16, 6, 12,
203 };
204 unsigned int main_rate;
205 unsigned int rate = rsnd_src_get_ssi_rate(priv, io, runtime);
206
207 if (!rsnd_rdai_is_clk_master(rdai))
208 return 0;
209
210 if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io))
211 return 0;
212
213 if (rsnd_ssi_is_multi_slave(mod, io))
214 return 0;
215
216 if (ssi->usrcnt > 1) {
217 if (ssi->rate != rate) {
218 dev_err(dev, "SSI parent/child should use same rate\n");
219 return -EINVAL;
220 }
221
222 return 0;
223 }
224
225 /*
226 * Find best clock, and try to start ADG
227 */
228 for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) {
229
230 /*
231 * this driver is assuming that
232 * system word is 32bit x slots
233 * see rsnd_ssi_init()
234 */
235 main_rate = rate * 32 * slots * ssi_clk_mul_table[j];
236
237 ret = rsnd_adg_ssi_clk_try_start(mod, main_rate);
238 if (0 == ret) {
239 ssi->cr_clk = FORCE | SWL_32 |
240 SCKD | SWSD | CKDV(j);
241 ssi->wsr = CONT;
242
243 ssi->rate = rate;
244
245 dev_dbg(dev, "%s[%d] outputs %u Hz\n",
246 rsnd_mod_name(mod),
247 rsnd_mod_id(mod), rate);
248
249 return 0;
250 }
251 }
252
253 dev_err(dev, "unsupported clock rate\n");
254 return -EIO;
255 }
256
257 static void rsnd_ssi_master_clk_stop(struct rsnd_mod *mod,
258 struct rsnd_dai_stream *io)
259 {
260 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
261 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
262 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
263
264 if (!rsnd_rdai_is_clk_master(rdai))
265 return;
266
267 if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io))
268 return;
269
270 if (ssi->usrcnt > 1)
271 return;
272
273 ssi->cr_clk = 0;
274 ssi->rate = 0;
275
276 rsnd_adg_ssi_clk_stop(mod);
277 }
278
279 static int rsnd_ssi_config_init(struct rsnd_mod *mod,
280 struct rsnd_dai_stream *io)
281 {
282 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
283 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
284 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
285 u32 cr_own;
286 u32 cr_mode;
287 u32 wsr;
288 int is_tdm;
289
290 is_tdm = (rsnd_get_slot_width(io) >= 6) ? 1 : 0;
291
292 /*
293 * always use 32bit system word.
294 * see also rsnd_ssi_master_clk_enable()
295 */
296 cr_own = FORCE | SWL_32 | PDTA;
297
298 if (rdai->bit_clk_inv)
299 cr_own |= SCKP;
300 if (rdai->frm_clk_inv ^ is_tdm)
301 cr_own |= SWSP;
302 if (rdai->data_alignment)
303 cr_own |= SDTA;
304 if (rdai->sys_delay)
305 cr_own |= DEL;
306 if (rsnd_io_is_play(io))
307 cr_own |= TRMD;
308
309 switch (runtime->sample_bits) {
310 case 16:
311 cr_own |= DWL_16;
312 break;
313 case 32:
314 cr_own |= DWL_24;
315 break;
316 default:
317 return -EINVAL;
318 }
319
320 if (rsnd_ssi_is_dma_mode(mod)) {
321 cr_mode = UIEN | OIEN | /* over/under run */
322 DMEN; /* DMA : enable DMA */
323 } else {
324 cr_mode = DIEN; /* PIO : enable Data interrupt */
325 }
326
327 /*
328 * TDM Extend Mode
329 * see
330 * rsnd_ssiu_init_gen2()
331 */
332 wsr = ssi->wsr;
333 if (is_tdm) {
334 wsr |= WS_MODE;
335 cr_own |= CHNL_8;
336 }
337
338 ssi->cr_own = cr_own;
339 ssi->cr_mode = cr_mode;
340 ssi->wsr = wsr;
341
342 return 0;
343 }
344
345 /*
346 * SSI mod common functions
347 */
348 static int rsnd_ssi_init(struct rsnd_mod *mod,
349 struct rsnd_dai_stream *io,
350 struct rsnd_priv *priv)
351 {
352 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
353 int ret;
354
355 ssi->usrcnt++;
356
357 rsnd_mod_power_on(mod);
358
359 ret = rsnd_ssi_master_clk_start(mod, io);
360 if (ret < 0)
361 return ret;
362
363 if (rsnd_ssi_is_parent(mod, io))
364 return 0;
365
366 ret = rsnd_ssi_config_init(mod, io);
367 if (ret < 0)
368 return ret;
369
370 /* clear error status */
371 rsnd_ssi_status_clear(mod);
372
373 return 0;
374 }
375
376 static int rsnd_ssi_quit(struct rsnd_mod *mod,
377 struct rsnd_dai_stream *io,
378 struct rsnd_priv *priv)
379 {
380 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
381 struct device *dev = rsnd_priv_to_dev(priv);
382
383 if (!ssi->usrcnt) {
384 dev_err(dev, "%s[%d] usrcnt error\n",
385 rsnd_mod_name(mod), rsnd_mod_id(mod));
386 return -EIO;
387 }
388
389 if (!rsnd_ssi_is_parent(mod, io))
390 ssi->cr_own = 0;
391
392 rsnd_ssi_master_clk_stop(mod, io);
393
394 rsnd_mod_power_off(mod);
395
396 ssi->usrcnt--;
397
398 return 0;
399 }
400
401 static int rsnd_ssi_hw_params(struct rsnd_mod *mod,
402 struct rsnd_dai_stream *io,
403 struct snd_pcm_substream *substream,
404 struct snd_pcm_hw_params *params)
405 {
406 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
407 int chan = params_channels(params);
408
409 /*
410 * Already working.
411 * It will happen if SSI has parent/child connection.
412 */
413 if (ssi->usrcnt > 1) {
414 /*
415 * it is error if child <-> parent SSI uses
416 * different channels.
417 */
418 if (ssi->chan != chan)
419 return -EIO;
420 }
421
422 ssi->chan = chan;
423
424 return 0;
425 }
426
427 static int rsnd_ssi_start(struct rsnd_mod *mod,
428 struct rsnd_dai_stream *io,
429 struct rsnd_priv *priv)
430 {
431 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
432 u32 cr;
433
434 cr = ssi->cr_own |
435 ssi->cr_clk |
436 ssi->cr_mode;
437
438 /*
439 * EN will be set via SSIU :: SSI_CONTROL
440 * if Multi channel mode
441 */
442 if (!rsnd_ssi_multi_slaves(io))
443 cr |= EN;
444
445 rsnd_mod_write(mod, SSICR, cr);
446 rsnd_mod_write(mod, SSIWSR, ssi->wsr);
447
448 return 0;
449 }
450
451 static int rsnd_ssi_stop(struct rsnd_mod *mod,
452 struct rsnd_dai_stream *io,
453 struct rsnd_priv *priv)
454 {
455 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
456 u32 cr;
457
458 /*
459 * don't stop if not last user
460 * see also
461 * rsnd_ssi_start
462 * rsnd_ssi_interrupt
463 */
464 if (ssi->usrcnt > 1)
465 return 0;
466
467 /*
468 * disable all IRQ,
469 * and, wait all data was sent
470 */
471 cr = ssi->cr_own |
472 ssi->cr_clk;
473
474 rsnd_mod_write(mod, SSICR, cr | EN);
475 rsnd_ssi_status_check(mod, DIRQ);
476
477 /*
478 * disable SSI,
479 * and, wait idle state
480 */
481 rsnd_mod_write(mod, SSICR, cr); /* disabled all */
482 rsnd_ssi_status_check(mod, IIRQ);
483
484 return 0;
485 }
486
487 static void __rsnd_ssi_interrupt(struct rsnd_mod *mod,
488 struct rsnd_dai_stream *io)
489 {
490 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
491 int is_dma = rsnd_ssi_is_dma_mode(mod);
492 u32 status;
493 bool elapsed = false;
494 bool stop = false;
495
496 spin_lock(&priv->lock);
497
498 /* ignore all cases if not working */
499 if (!rsnd_io_is_working(io))
500 goto rsnd_ssi_interrupt_out;
501
502 status = rsnd_ssi_status_get(mod);
503
504 /* PIO only */
505 if (!is_dma && (status & DIRQ)) {
506 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
507 u32 *buf = (u32 *)(runtime->dma_area +
508 rsnd_dai_pointer_offset(io, 0));
509
510 /*
511 * 8/16/32 data can be assesse to TDR/RDR register
512 * directly as 32bit data
513 * see rsnd_ssi_init()
514 */
515 if (rsnd_io_is_play(io))
516 rsnd_mod_write(mod, SSITDR, *buf);
517 else
518 *buf = rsnd_mod_read(mod, SSIRDR);
519
520 elapsed = rsnd_dai_pointer_update(io, sizeof(*buf));
521 }
522
523 /* DMA only */
524 if (is_dma && (status & (UIRQ | OIRQ)))
525 stop = true;
526
527 rsnd_ssi_status_clear(mod);
528 rsnd_ssi_interrupt_out:
529 spin_unlock(&priv->lock);
530
531 if (elapsed)
532 rsnd_dai_period_elapsed(io);
533
534 if (stop)
535 snd_pcm_stop_xrun(io->substream);
536
537 }
538
539 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
540 {
541 struct rsnd_mod *mod = data;
542
543 rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt);
544
545 return IRQ_HANDLED;
546 }
547
548 /*
549 * SSI PIO
550 */
551 static void rsnd_ssi_parent_attach(struct rsnd_mod *mod,
552 struct rsnd_dai_stream *io,
553 struct rsnd_priv *priv)
554 {
555 if (!__rsnd_ssi_is_pin_sharing(mod))
556 return;
557
558 switch (rsnd_mod_id(mod)) {
559 case 1:
560 case 2:
561 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP);
562 break;
563 case 4:
564 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP);
565 break;
566 case 8:
567 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP);
568 break;
569 }
570 }
571
572 static int rsnd_ssi_common_probe(struct rsnd_mod *mod,
573 struct rsnd_dai_stream *io,
574 struct rsnd_priv *priv)
575 {
576 struct device *dev = rsnd_priv_to_dev(priv);
577 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
578 int ret;
579
580 /*
581 * SSIP/SSIU/IRQ are not needed on
582 * SSI Multi slaves
583 */
584 if (rsnd_ssi_is_multi_slave(mod, io))
585 return 0;
586
587 rsnd_ssi_parent_attach(mod, io, priv);
588
589 ret = rsnd_ssiu_attach(io, mod);
590 if (ret < 0)
591 return ret;
592
593 ret = devm_request_irq(dev, ssi->irq,
594 rsnd_ssi_interrupt,
595 IRQF_SHARED,
596 dev_name(dev), mod);
597
598 return ret;
599 }
600
601 static struct rsnd_mod_ops rsnd_ssi_pio_ops = {
602 .name = SSI_NAME,
603 .probe = rsnd_ssi_common_probe,
604 .init = rsnd_ssi_init,
605 .quit = rsnd_ssi_quit,
606 .start = rsnd_ssi_start,
607 .stop = rsnd_ssi_stop,
608 .irq = rsnd_ssi_irq,
609 .hw_params = rsnd_ssi_hw_params,
610 };
611
612 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
613 struct rsnd_dai_stream *io,
614 struct rsnd_priv *priv)
615 {
616 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
617 int dma_id = 0; /* not needed */
618 int ret;
619
620 /*
621 * SSIP/SSIU/IRQ/DMA are not needed on
622 * SSI Multi slaves
623 */
624 if (rsnd_ssi_is_multi_slave(mod, io))
625 return 0;
626
627 ret = rsnd_ssi_common_probe(mod, io, priv);
628 if (ret)
629 return ret;
630
631 /* SSI probe might be called many times in MUX multi path */
632 ret = rsnd_dma_attach(io, mod, &ssi->dma, dma_id);
633
634 return ret;
635 }
636
637 static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,
638 struct rsnd_dai_stream *io,
639 struct rsnd_priv *priv)
640 {
641 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
642 struct device *dev = rsnd_priv_to_dev(priv);
643 int irq = ssi->irq;
644
645 /* PIO will request IRQ again */
646 devm_free_irq(dev, irq, mod);
647
648 return 0;
649 }
650
651 static int rsnd_ssi_fallback(struct rsnd_mod *mod,
652 struct rsnd_dai_stream *io,
653 struct rsnd_priv *priv)
654 {
655 struct device *dev = rsnd_priv_to_dev(priv);
656
657 /*
658 * fallback to PIO
659 *
660 * SSI .probe might be called again.
661 * see
662 * rsnd_rdai_continuance_probe()
663 */
664 mod->ops = &rsnd_ssi_pio_ops;
665
666 dev_info(dev, "%s[%d] fallback to PIO mode\n",
667 rsnd_mod_name(mod), rsnd_mod_id(mod));
668
669 return 0;
670 }
671
672 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io,
673 struct rsnd_mod *mod)
674 {
675 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
676 int is_play = rsnd_io_is_play(io);
677 char *name;
678
679 if (rsnd_ssi_use_busif(io))
680 name = is_play ? "rxu" : "txu";
681 else
682 name = is_play ? "rx" : "tx";
683
684 return rsnd_dma_request_channel(rsnd_ssi_of_node(priv),
685 mod, name);
686 }
687
688 static struct rsnd_mod_ops rsnd_ssi_dma_ops = {
689 .name = SSI_NAME,
690 .dma_req = rsnd_ssi_dma_req,
691 .probe = rsnd_ssi_dma_probe,
692 .remove = rsnd_ssi_dma_remove,
693 .init = rsnd_ssi_init,
694 .quit = rsnd_ssi_quit,
695 .start = rsnd_ssi_start,
696 .stop = rsnd_ssi_stop,
697 .fallback = rsnd_ssi_fallback,
698 .hw_params = rsnd_ssi_hw_params,
699 };
700
701 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod)
702 {
703 return mod->ops == &rsnd_ssi_dma_ops;
704 }
705
706
707 /*
708 * Non SSI
709 */
710 static struct rsnd_mod_ops rsnd_ssi_non_ops = {
711 .name = SSI_NAME,
712 };
713
714 /*
715 * ssi mod function
716 */
717 static void rsnd_ssi_connect(struct rsnd_mod *mod,
718 struct rsnd_dai_stream *io)
719 {
720 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
721 enum rsnd_mod_type types[] = {
722 RSND_MOD_SSI,
723 RSND_MOD_SSIM1,
724 RSND_MOD_SSIM2,
725 RSND_MOD_SSIM3,
726 };
727 enum rsnd_mod_type type;
728 int i;
729
730 /* try SSI -> SSIM1 -> SSIM2 -> SSIM3 */
731 for (i = 0; i < ARRAY_SIZE(types); i++) {
732 type = types[i];
733 if (!rsnd_io_to_mod(io, type)) {
734 rsnd_dai_connect(mod, io, type);
735 rsnd_set_slot(rdai, 2 * (i + 1), (i + 1));
736 return;
737 }
738 }
739 }
740
741 void rsnd_parse_connect_ssi(struct rsnd_dai *rdai,
742 struct device_node *playback,
743 struct device_node *capture)
744 {
745 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);
746 struct device_node *node;
747 struct device_node *np;
748 struct rsnd_mod *mod;
749 int i;
750
751 node = rsnd_ssi_of_node(priv);
752 if (!node)
753 return;
754
755 i = 0;
756 for_each_child_of_node(node, np) {
757 mod = rsnd_ssi_mod_get(priv, i);
758 if (np == playback)
759 rsnd_ssi_connect(mod, &rdai->playback);
760 if (np == capture)
761 rsnd_ssi_connect(mod, &rdai->capture);
762 i++;
763 }
764
765 of_node_put(node);
766 }
767
768 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id)
769 {
770 if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv)))
771 id = 0;
772
773 return rsnd_mod_get(rsnd_ssi_get(priv, id));
774 }
775
776 int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod)
777 {
778 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
779
780 return !!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_CLK_PIN_SHARE);
781 }
782
783 static u32 *rsnd_ssi_get_status(struct rsnd_dai_stream *io,
784 struct rsnd_mod *mod,
785 enum rsnd_mod_type type)
786 {
787 /*
788 * SSIP (= SSI parent) needs to be special, otherwise,
789 * 2nd SSI might doesn't start. see also rsnd_mod_call()
790 *
791 * We can't include parent SSI status on SSI, because we don't know
792 * how many SSI requests parent SSI. Thus, it is localed on "io" now.
793 * ex) trouble case
794 * Playback: SSI0
795 * Capture : SSI1 (needs SSI0)
796 *
797 * 1) start Capture -> SSI0/SSI1 are started.
798 * 2) start Playback -> SSI0 doesn't work, because it is already
799 * marked as "started" on 1)
800 *
801 * OTOH, using each mod's status is good for MUX case.
802 * It doesn't need to start in 2nd start
803 * ex)
804 * IO-0: SRC0 -> CTU1 -+-> MUX -> DVC -> SSIU -> SSI0
805 * |
806 * IO-1: SRC1 -> CTU2 -+
807 *
808 * 1) start IO-0 -> start SSI0
809 * 2) start IO-1 -> SSI0 doesn't need to start, because it is
810 * already started on 1)
811 */
812 if (type == RSND_MOD_SSIP)
813 return &io->parent_ssi_status;
814
815 return rsnd_mod_get_status(io, mod, type);
816 }
817
818 int rsnd_ssi_probe(struct rsnd_priv *priv)
819 {
820 struct device_node *node;
821 struct device_node *np;
822 struct device *dev = rsnd_priv_to_dev(priv);
823 struct rsnd_mod_ops *ops;
824 struct clk *clk;
825 struct rsnd_ssi *ssi;
826 char name[RSND_SSI_NAME_SIZE];
827 int i, nr, ret;
828
829 node = rsnd_ssi_of_node(priv);
830 if (!node)
831 return -EINVAL;
832
833 nr = of_get_child_count(node);
834 if (!nr) {
835 ret = -EINVAL;
836 goto rsnd_ssi_probe_done;
837 }
838
839 ssi = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL);
840 if (!ssi) {
841 ret = -ENOMEM;
842 goto rsnd_ssi_probe_done;
843 }
844
845 priv->ssi = ssi;
846 priv->ssi_nr = nr;
847
848 i = 0;
849 for_each_child_of_node(node, np) {
850 ssi = rsnd_ssi_get(priv, i);
851
852 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d",
853 SSI_NAME, i);
854
855 clk = devm_clk_get(dev, name);
856 if (IS_ERR(clk)) {
857 ret = PTR_ERR(clk);
858 goto rsnd_ssi_probe_done;
859 }
860
861 if (of_get_property(np, "shared-pin", NULL))
862 ssi->flags |= RSND_SSI_CLK_PIN_SHARE;
863
864 if (of_get_property(np, "no-busif", NULL))
865 ssi->flags |= RSND_SSI_NO_BUSIF;
866
867 ssi->irq = irq_of_parse_and_map(np, 0);
868 if (!ssi->irq) {
869 ret = -EINVAL;
870 goto rsnd_ssi_probe_done;
871 }
872
873 ops = &rsnd_ssi_non_ops;
874 if (of_get_property(np, "pio-transfer", NULL))
875 ops = &rsnd_ssi_pio_ops;
876 else
877 ops = &rsnd_ssi_dma_ops;
878
879 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk,
880 rsnd_ssi_get_status, RSND_MOD_SSI, i);
881 if (ret)
882 goto rsnd_ssi_probe_done;
883
884 i++;
885 }
886
887 ret = 0;
888
889 rsnd_ssi_probe_done:
890 of_node_put(node);
891
892 return ret;
893 }
894
895 void rsnd_ssi_remove(struct rsnd_priv *priv)
896 {
897 struct rsnd_ssi *ssi;
898 int i;
899
900 for_each_rsnd_ssi(ssi, priv, i) {
901 rsnd_mod_quit(rsnd_mod_get(ssi));
902 }
903 }
Ubuntu Artful kernel mirror