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