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