Merge remote-tracking branches 'asoc/topic/dwc', 'asoc/topic/fallthrough', 'asoc...
[sfrench/cifs-2.6.git] / sound / soc / img / img-spdif-in.c
1 /*
2  * IMG SPDIF input controller driver
3  *
4  * Copyright (C) 2015 Imagination Technologies Ltd.
5  *
6  * Author: Damien Horsley <Damien.Horsley@imgtec.com>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms and conditions of the GNU General Public License,
10  * version 2, as published by the Free Software Foundation.
11  */
12
13 #include <linux/clk.h>
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/platform_device.h>
19 #include <linux/reset.h>
20
21 #include <sound/core.h>
22 #include <sound/dmaengine_pcm.h>
23 #include <sound/initval.h>
24 #include <sound/pcm.h>
25 #include <sound/pcm_params.h>
26 #include <sound/soc.h>
27
28 #define IMG_SPDIF_IN_RX_FIFO_OFFSET             0
29
30 #define IMG_SPDIF_IN_CTL                        0x4
31 #define IMG_SPDIF_IN_CTL_LOCKLO_MASK            0xff
32 #define IMG_SPDIF_IN_CTL_LOCKLO_SHIFT           0
33 #define IMG_SPDIF_IN_CTL_LOCKHI_MASK            0xff00
34 #define IMG_SPDIF_IN_CTL_LOCKHI_SHIFT           8
35 #define IMG_SPDIF_IN_CTL_TRK_MASK               0xff0000
36 #define IMG_SPDIF_IN_CTL_TRK_SHIFT              16
37 #define IMG_SPDIF_IN_CTL_SRD_MASK               0x70000000
38 #define IMG_SPDIF_IN_CTL_SRD_SHIFT              28
39 #define IMG_SPDIF_IN_CTL_SRT_MASK               BIT(31)
40
41 #define IMG_SPDIF_IN_STATUS                     0x8
42 #define IMG_SPDIF_IN_STATUS_SAM_MASK            0x7000
43 #define IMG_SPDIF_IN_STATUS_SAM_SHIFT           12
44 #define IMG_SPDIF_IN_STATUS_LOCK_MASK           BIT(15)
45 #define IMG_SPDIF_IN_STATUS_LOCK_SHIFT          15
46
47 #define IMG_SPDIF_IN_CLKGEN                     0x1c
48 #define IMG_SPDIF_IN_CLKGEN_NOM_MASK            0x3ff
49 #define IMG_SPDIF_IN_CLKGEN_NOM_SHIFT           0
50 #define IMG_SPDIF_IN_CLKGEN_HLD_MASK            0x3ff0000
51 #define IMG_SPDIF_IN_CLKGEN_HLD_SHIFT           16
52
53 #define IMG_SPDIF_IN_CSL                        0x20
54
55 #define IMG_SPDIF_IN_CSH                        0x24
56 #define IMG_SPDIF_IN_CSH_MASK                   0xff
57 #define IMG_SPDIF_IN_CSH_SHIFT                  0
58
59 #define IMG_SPDIF_IN_SOFT_RESET                 0x28
60 #define IMG_SPDIF_IN_SOFT_RESET_MASK            BIT(0)
61
62 #define IMG_SPDIF_IN_ACLKGEN_START              0x2c
63 #define IMG_SPDIF_IN_ACLKGEN_NOM_MASK           0x3ff
64 #define IMG_SPDIF_IN_ACLKGEN_NOM_SHIFT          0
65 #define IMG_SPDIF_IN_ACLKGEN_HLD_MASK           0xffc00
66 #define IMG_SPDIF_IN_ACLKGEN_HLD_SHIFT          10
67 #define IMG_SPDIF_IN_ACLKGEN_TRK_MASK           0xff00000
68 #define IMG_SPDIF_IN_ACLKGEN_TRK_SHIFT          20
69
70 #define IMG_SPDIF_IN_NUM_ACLKGEN                4
71
72 struct img_spdif_in {
73         spinlock_t lock;
74         void __iomem *base;
75         struct clk *clk_sys;
76         struct snd_dmaengine_dai_dma_data dma_data;
77         struct device *dev;
78         unsigned int trk;
79         bool multi_freq;
80         int lock_acquire;
81         int lock_release;
82         unsigned int single_freq;
83         unsigned int multi_freqs[IMG_SPDIF_IN_NUM_ACLKGEN];
84         bool active;
85
86         /* Write-only registers */
87         unsigned int aclkgen_regs[IMG_SPDIF_IN_NUM_ACLKGEN];
88 };
89
90 static inline void img_spdif_in_writel(struct img_spdif_in *spdif,
91                                         u32 val, u32 reg)
92 {
93         writel(val, spdif->base + reg);
94 }
95
96 static inline u32 img_spdif_in_readl(struct img_spdif_in *spdif, u32 reg)
97 {
98         return readl(spdif->base + reg);
99 }
100
101 static inline void img_spdif_in_aclkgen_writel(struct img_spdif_in *spdif,
102                                                 u32 index)
103 {
104         img_spdif_in_writel(spdif, spdif->aclkgen_regs[index],
105                         IMG_SPDIF_IN_ACLKGEN_START + (index * 0x4));
106 }
107
108 static int img_spdif_in_check_max_rate(struct img_spdif_in *spdif,
109                 unsigned int sample_rate, unsigned long *actual_freq)
110 {
111         unsigned long min_freq, freq_t;
112
113         /* Clock rate must be at least 24x the bit rate */
114         min_freq = sample_rate * 2 * 32 * 24;
115
116         freq_t = clk_get_rate(spdif->clk_sys);
117
118         if (freq_t < min_freq)
119                 return -EINVAL;
120
121         *actual_freq = freq_t;
122
123         return 0;
124 }
125
126 static int img_spdif_in_do_clkgen_calc(unsigned int rate, unsigned int *pnom,
127                 unsigned int *phld, unsigned long clk_rate)
128 {
129         unsigned int ori, nom, hld;
130
131         /*
132          * Calculate oversampling ratio, nominal phase increment and hold
133          * increment for the given rate / frequency
134          */
135
136         if (!rate)
137                 return -EINVAL;
138
139         ori = clk_rate / (rate * 64);
140
141         if (!ori)
142                 return -EINVAL;
143
144         nom = (4096 / ori) + 1;
145         do
146                 hld = 4096 - (--nom * (ori - 1));
147         while (hld < 120);
148
149         *pnom = nom;
150         *phld = hld;
151
152         return 0;
153 }
154
155 static int img_spdif_in_do_clkgen_single(struct img_spdif_in *spdif,
156                 unsigned int rate)
157 {
158         unsigned int nom, hld;
159         unsigned long flags, clk_rate;
160         int ret = 0;
161         u32 reg;
162
163         ret = img_spdif_in_check_max_rate(spdif, rate, &clk_rate);
164         if (ret)
165                 return ret;
166
167         ret = img_spdif_in_do_clkgen_calc(rate, &nom, &hld, clk_rate);
168         if (ret)
169                 return ret;
170
171         reg = (nom << IMG_SPDIF_IN_CLKGEN_NOM_SHIFT) &
172                 IMG_SPDIF_IN_CLKGEN_NOM_MASK;
173         reg |= (hld << IMG_SPDIF_IN_CLKGEN_HLD_SHIFT) &
174                 IMG_SPDIF_IN_CLKGEN_HLD_MASK;
175
176         spin_lock_irqsave(&spdif->lock, flags);
177
178         if (spdif->active) {
179                 spin_unlock_irqrestore(&spdif->lock, flags);
180                 return -EBUSY;
181         }
182
183         img_spdif_in_writel(spdif, reg, IMG_SPDIF_IN_CLKGEN);
184
185         spdif->single_freq = rate;
186
187         spin_unlock_irqrestore(&spdif->lock, flags);
188
189         return 0;
190 }
191
192 static int img_spdif_in_do_clkgen_multi(struct img_spdif_in *spdif,
193                 unsigned int multi_freqs[])
194 {
195         unsigned int nom, hld, rate, max_rate = 0;
196         unsigned long flags, clk_rate;
197         int i, ret = 0;
198         u32 reg, trk_reg, temp_regs[IMG_SPDIF_IN_NUM_ACLKGEN];
199
200         for (i = 0; i < IMG_SPDIF_IN_NUM_ACLKGEN; i++)
201                 if (multi_freqs[i] > max_rate)
202                         max_rate = multi_freqs[i];
203
204         ret = img_spdif_in_check_max_rate(spdif, max_rate, &clk_rate);
205         if (ret)
206                 return ret;
207
208         for (i = 0; i < IMG_SPDIF_IN_NUM_ACLKGEN; i++) {
209                 rate = multi_freqs[i];
210
211                 ret = img_spdif_in_do_clkgen_calc(rate, &nom, &hld, clk_rate);
212                 if (ret)
213                         return ret;
214
215                 reg = (nom << IMG_SPDIF_IN_ACLKGEN_NOM_SHIFT) &
216                         IMG_SPDIF_IN_ACLKGEN_NOM_MASK;
217                 reg |= (hld << IMG_SPDIF_IN_ACLKGEN_HLD_SHIFT) &
218                         IMG_SPDIF_IN_ACLKGEN_HLD_MASK;
219                 temp_regs[i] = reg;
220         }
221
222         spin_lock_irqsave(&spdif->lock, flags);
223
224         if (spdif->active) {
225                 spin_unlock_irqrestore(&spdif->lock, flags);
226                 return -EBUSY;
227         }
228
229         trk_reg = spdif->trk << IMG_SPDIF_IN_ACLKGEN_TRK_SHIFT;
230
231         for (i = 0; i < IMG_SPDIF_IN_NUM_ACLKGEN; i++) {
232                 spdif->aclkgen_regs[i] = temp_regs[i] | trk_reg;
233                 img_spdif_in_aclkgen_writel(spdif, i);
234         }
235
236         spdif->multi_freq = true;
237         spdif->multi_freqs[0] = multi_freqs[0];
238         spdif->multi_freqs[1] = multi_freqs[1];
239         spdif->multi_freqs[2] = multi_freqs[2];
240         spdif->multi_freqs[3] = multi_freqs[3];
241
242         spin_unlock_irqrestore(&spdif->lock, flags);
243
244         return 0;
245 }
246
247 static int img_spdif_in_iec958_info(struct snd_kcontrol *kcontrol,
248                 struct snd_ctl_elem_info *uinfo)
249 {
250         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
251         uinfo->count = 1;
252
253         return 0;
254 }
255
256 static int img_spdif_in_get_status_mask(struct snd_kcontrol *kcontrol,
257                                        struct snd_ctl_elem_value *ucontrol)
258 {
259         ucontrol->value.iec958.status[0] = 0xff;
260         ucontrol->value.iec958.status[1] = 0xff;
261         ucontrol->value.iec958.status[2] = 0xff;
262         ucontrol->value.iec958.status[3] = 0xff;
263         ucontrol->value.iec958.status[4] = 0xff;
264
265         return 0;
266 }
267
268 static int img_spdif_in_get_status(struct snd_kcontrol *kcontrol,
269                                   struct snd_ctl_elem_value *ucontrol)
270 {
271         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
272         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
273         u32 reg;
274
275         reg = img_spdif_in_readl(spdif, IMG_SPDIF_IN_CSL);
276         ucontrol->value.iec958.status[0] = reg & 0xff;
277         ucontrol->value.iec958.status[1] = (reg >> 8) & 0xff;
278         ucontrol->value.iec958.status[2] = (reg >> 16) & 0xff;
279         ucontrol->value.iec958.status[3] = (reg >> 24) & 0xff;
280         reg = img_spdif_in_readl(spdif, IMG_SPDIF_IN_CSH);
281         ucontrol->value.iec958.status[4] = (reg & IMG_SPDIF_IN_CSH_MASK)
282                 >> IMG_SPDIF_IN_CSH_SHIFT;
283
284         return 0;
285 }
286
287 static int img_spdif_in_info_multi_freq(struct snd_kcontrol *kcontrol,
288                 struct snd_ctl_elem_info *uinfo)
289 {
290         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
291         uinfo->count = IMG_SPDIF_IN_NUM_ACLKGEN;
292         uinfo->value.integer.min = 0;
293         uinfo->value.integer.max = LONG_MAX;
294
295         return 0;
296 }
297
298 static int img_spdif_in_get_multi_freq(struct snd_kcontrol *kcontrol,
299                                   struct snd_ctl_elem_value *ucontrol)
300 {
301         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
302         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
303         unsigned long flags;
304
305         spin_lock_irqsave(&spdif->lock, flags);
306         if (spdif->multi_freq) {
307                 ucontrol->value.integer.value[0] = spdif->multi_freqs[0];
308                 ucontrol->value.integer.value[1] = spdif->multi_freqs[1];
309                 ucontrol->value.integer.value[2] = spdif->multi_freqs[2];
310                 ucontrol->value.integer.value[3] = spdif->multi_freqs[3];
311         } else {
312                 ucontrol->value.integer.value[0] = 0;
313                 ucontrol->value.integer.value[1] = 0;
314                 ucontrol->value.integer.value[2] = 0;
315                 ucontrol->value.integer.value[3] = 0;
316         }
317         spin_unlock_irqrestore(&spdif->lock, flags);
318
319         return 0;
320 }
321
322 static int img_spdif_in_set_multi_freq(struct snd_kcontrol *kcontrol,
323                                   struct snd_ctl_elem_value *ucontrol)
324 {
325         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
326         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
327         unsigned int multi_freqs[IMG_SPDIF_IN_NUM_ACLKGEN];
328         bool multi_freq;
329         unsigned long flags;
330
331         if ((ucontrol->value.integer.value[0] == 0) &&
332                         (ucontrol->value.integer.value[1] == 0) &&
333                         (ucontrol->value.integer.value[2] == 0) &&
334                         (ucontrol->value.integer.value[3] == 0)) {
335                 multi_freq = false;
336         } else {
337                 multi_freqs[0] = ucontrol->value.integer.value[0];
338                 multi_freqs[1] = ucontrol->value.integer.value[1];
339                 multi_freqs[2] = ucontrol->value.integer.value[2];
340                 multi_freqs[3] = ucontrol->value.integer.value[3];
341                 multi_freq = true;
342         }
343
344         if (multi_freq)
345                 return img_spdif_in_do_clkgen_multi(spdif, multi_freqs);
346
347         spin_lock_irqsave(&spdif->lock, flags);
348
349         if (spdif->active) {
350                 spin_unlock_irqrestore(&spdif->lock, flags);
351                 return -EBUSY;
352         }
353
354         spdif->multi_freq = false;
355
356         spin_unlock_irqrestore(&spdif->lock, flags);
357
358         return 0;
359 }
360
361 static int img_spdif_in_info_lock_freq(struct snd_kcontrol *kcontrol,
362                 struct snd_ctl_elem_info *uinfo)
363 {
364         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
365         uinfo->count = 1;
366         uinfo->value.integer.min = 0;
367         uinfo->value.integer.max = LONG_MAX;
368
369         return 0;
370 }
371
372 static int img_spdif_in_get_lock_freq(struct snd_kcontrol *kcontrol,
373                                   struct snd_ctl_elem_value *uc)
374 {
375         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
376         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
377         u32 reg;
378         int i;
379         unsigned long flags;
380
381         spin_lock_irqsave(&spdif->lock, flags);
382
383         reg = img_spdif_in_readl(spdif, IMG_SPDIF_IN_STATUS);
384         if (reg & IMG_SPDIF_IN_STATUS_LOCK_MASK) {
385                 if (spdif->multi_freq) {
386                         i = ((reg & IMG_SPDIF_IN_STATUS_SAM_MASK) >>
387                                         IMG_SPDIF_IN_STATUS_SAM_SHIFT) - 1;
388                         uc->value.integer.value[0] = spdif->multi_freqs[i];
389                 } else {
390                         uc->value.integer.value[0] = spdif->single_freq;
391                 }
392         } else {
393                 uc->value.integer.value[0] = 0;
394         }
395
396         spin_unlock_irqrestore(&spdif->lock, flags);
397
398         return 0;
399 }
400
401 static int img_spdif_in_info_trk(struct snd_kcontrol *kcontrol,
402                 struct snd_ctl_elem_info *uinfo)
403 {
404         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
405         uinfo->count = 1;
406         uinfo->value.integer.min = 0;
407         uinfo->value.integer.max = 255;
408
409         return 0;
410 }
411
412 static int img_spdif_in_get_trk(struct snd_kcontrol *kcontrol,
413                                   struct snd_ctl_elem_value *ucontrol)
414 {
415         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
416         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
417
418         ucontrol->value.integer.value[0] = spdif->trk;
419
420         return 0;
421 }
422
423 static int img_spdif_in_set_trk(struct snd_kcontrol *kcontrol,
424                                   struct snd_ctl_elem_value *ucontrol)
425 {
426         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
427         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
428         unsigned long flags;
429         int i;
430         u32 reg;
431
432         spin_lock_irqsave(&spdif->lock, flags);
433
434         if (spdif->active) {
435                 spin_unlock_irqrestore(&spdif->lock, flags);
436                 return -EBUSY;
437         }
438
439         spdif->trk = ucontrol->value.integer.value[0];
440
441         reg = img_spdif_in_readl(spdif, IMG_SPDIF_IN_CTL);
442         reg &= ~IMG_SPDIF_IN_CTL_TRK_MASK;
443         reg |= spdif->trk << IMG_SPDIF_IN_CTL_TRK_SHIFT;
444         img_spdif_in_writel(spdif, reg, IMG_SPDIF_IN_CTL);
445
446         for (i = 0; i < IMG_SPDIF_IN_NUM_ACLKGEN; i++) {
447                 spdif->aclkgen_regs[i] = (spdif->aclkgen_regs[i] &
448                         ~IMG_SPDIF_IN_ACLKGEN_TRK_MASK) |
449                         (spdif->trk << IMG_SPDIF_IN_ACLKGEN_TRK_SHIFT);
450
451                 img_spdif_in_aclkgen_writel(spdif, i);
452         }
453
454         spin_unlock_irqrestore(&spdif->lock, flags);
455
456         return 0;
457 }
458
459 static int img_spdif_in_info_lock(struct snd_kcontrol *kcontrol,
460                 struct snd_ctl_elem_info *uinfo)
461 {
462         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
463         uinfo->count = 1;
464         uinfo->value.integer.min = -128;
465         uinfo->value.integer.max = 127;
466
467         return 0;
468 }
469
470 static int img_spdif_in_get_lock_acquire(struct snd_kcontrol *kcontrol,
471                                   struct snd_ctl_elem_value *ucontrol)
472 {
473         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
474         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
475
476         ucontrol->value.integer.value[0] = spdif->lock_acquire;
477
478         return 0;
479 }
480
481 static int img_spdif_in_set_lock_acquire(struct snd_kcontrol *kcontrol,
482                                   struct snd_ctl_elem_value *ucontrol)
483 {
484         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
485         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
486         unsigned long flags;
487         u32 reg;
488
489         spin_lock_irqsave(&spdif->lock, flags);
490
491         if (spdif->active) {
492                 spin_unlock_irqrestore(&spdif->lock, flags);
493                 return -EBUSY;
494         }
495
496         spdif->lock_acquire = ucontrol->value.integer.value[0];
497
498         reg = img_spdif_in_readl(spdif, IMG_SPDIF_IN_CTL);
499         reg &= ~IMG_SPDIF_IN_CTL_LOCKHI_MASK;
500         reg |= (spdif->lock_acquire << IMG_SPDIF_IN_CTL_LOCKHI_SHIFT) &
501                 IMG_SPDIF_IN_CTL_LOCKHI_MASK;
502         img_spdif_in_writel(spdif, reg, IMG_SPDIF_IN_CTL);
503
504         spin_unlock_irqrestore(&spdif->lock, flags);
505
506         return 0;
507 }
508
509 static int img_spdif_in_get_lock_release(struct snd_kcontrol *kcontrol,
510                                   struct snd_ctl_elem_value *ucontrol)
511 {
512         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
513         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
514
515         ucontrol->value.integer.value[0] = spdif->lock_release;
516
517         return 0;
518 }
519
520 static int img_spdif_in_set_lock_release(struct snd_kcontrol *kcontrol,
521                                   struct snd_ctl_elem_value *ucontrol)
522 {
523         struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
524         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(cpu_dai);
525         unsigned long flags;
526         u32 reg;
527
528         spin_lock_irqsave(&spdif->lock, flags);
529
530         if (spdif->active) {
531                 spin_unlock_irqrestore(&spdif->lock, flags);
532                 return -EBUSY;
533         }
534
535         spdif->lock_release = ucontrol->value.integer.value[0];
536
537         reg = img_spdif_in_readl(spdif, IMG_SPDIF_IN_CTL);
538         reg &= ~IMG_SPDIF_IN_CTL_LOCKLO_MASK;
539         reg |= (spdif->lock_release << IMG_SPDIF_IN_CTL_LOCKLO_SHIFT) &
540                 IMG_SPDIF_IN_CTL_LOCKLO_MASK;
541         img_spdif_in_writel(spdif, reg, IMG_SPDIF_IN_CTL);
542
543         spin_unlock_irqrestore(&spdif->lock, flags);
544
545         return 0;
546 }
547
548 static struct snd_kcontrol_new img_spdif_in_controls[] = {
549         {
550                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
551                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
552                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK),
553                 .info = img_spdif_in_iec958_info,
554                 .get = img_spdif_in_get_status_mask
555         },
556         {
557                 .access = SNDRV_CTL_ELEM_ACCESS_READ |
558                         SNDRV_CTL_ELEM_ACCESS_VOLATILE,
559                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
560                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
561                 .info = img_spdif_in_iec958_info,
562                 .get = img_spdif_in_get_status
563         },
564         {
565                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
566                 .name = "SPDIF In Multi Frequency Acquire",
567                 .info = img_spdif_in_info_multi_freq,
568                 .get = img_spdif_in_get_multi_freq,
569                 .put = img_spdif_in_set_multi_freq
570         },
571         {
572                 .access = SNDRV_CTL_ELEM_ACCESS_READ |
573                         SNDRV_CTL_ELEM_ACCESS_VOLATILE,
574                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
575                 .name = "SPDIF In Lock Frequency",
576                 .info = img_spdif_in_info_lock_freq,
577                 .get = img_spdif_in_get_lock_freq
578         },
579         {
580                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
581                 .name = "SPDIF In Lock TRK",
582                 .info = img_spdif_in_info_trk,
583                 .get = img_spdif_in_get_trk,
584                 .put = img_spdif_in_set_trk
585         },
586         {
587                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
588                 .name = "SPDIF In Lock Acquire Threshold",
589                 .info = img_spdif_in_info_lock,
590                 .get = img_spdif_in_get_lock_acquire,
591                 .put = img_spdif_in_set_lock_acquire
592         },
593         {
594                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
595                 .name = "SPDIF In Lock Release Threshold",
596                 .info = img_spdif_in_info_lock,
597                 .get = img_spdif_in_get_lock_release,
598                 .put = img_spdif_in_set_lock_release
599         }
600 };
601
602 static int img_spdif_in_trigger(struct snd_pcm_substream *substream, int cmd,
603         struct snd_soc_dai *dai)
604 {
605         unsigned long flags;
606         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(dai);
607         int ret = 0;
608         u32 reg;
609
610         spin_lock_irqsave(&spdif->lock, flags);
611
612         switch (cmd) {
613         case SNDRV_PCM_TRIGGER_START:
614         case SNDRV_PCM_TRIGGER_RESUME:
615         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
616                 reg = img_spdif_in_readl(spdif, IMG_SPDIF_IN_CTL);
617                 if (spdif->multi_freq)
618                         reg &= ~IMG_SPDIF_IN_CTL_SRD_MASK;
619                 else
620                         reg |= (1UL << IMG_SPDIF_IN_CTL_SRD_SHIFT);
621                 reg |= IMG_SPDIF_IN_CTL_SRT_MASK;
622                 img_spdif_in_writel(spdif, reg, IMG_SPDIF_IN_CTL);
623                 spdif->active = true;
624                 break;
625         case SNDRV_PCM_TRIGGER_STOP:
626         case SNDRV_PCM_TRIGGER_SUSPEND:
627         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
628                 reg = img_spdif_in_readl(spdif, IMG_SPDIF_IN_CTL);
629                 reg &= ~IMG_SPDIF_IN_CTL_SRT_MASK;
630                 img_spdif_in_writel(spdif, reg, IMG_SPDIF_IN_CTL);
631                 spdif->active = false;
632                 break;
633         default:
634                 ret = -EINVAL;
635         }
636
637         spin_unlock_irqrestore(&spdif->lock, flags);
638
639         return ret;
640 }
641
642 static int img_spdif_in_hw_params(struct snd_pcm_substream *substream,
643         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
644 {
645         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(dai);
646         unsigned int rate, channels;
647         snd_pcm_format_t format;
648
649         rate = params_rate(params);
650         channels = params_channels(params);
651         format = params_format(params);
652
653         if (format != SNDRV_PCM_FORMAT_S32_LE)
654                 return -EINVAL;
655
656         if (channels != 2)
657                 return -EINVAL;
658
659         return img_spdif_in_do_clkgen_single(spdif, rate);
660 }
661
662 static const struct snd_soc_dai_ops img_spdif_in_dai_ops = {
663         .trigger = img_spdif_in_trigger,
664         .hw_params = img_spdif_in_hw_params
665 };
666
667 static int img_spdif_in_dai_probe(struct snd_soc_dai *dai)
668 {
669         struct img_spdif_in *spdif = snd_soc_dai_get_drvdata(dai);
670
671         snd_soc_dai_init_dma_data(dai, NULL, &spdif->dma_data);
672
673         snd_soc_add_dai_controls(dai, img_spdif_in_controls,
674                         ARRAY_SIZE(img_spdif_in_controls));
675
676         return 0;
677 }
678
679 static struct snd_soc_dai_driver img_spdif_in_dai = {
680         .probe = img_spdif_in_dai_probe,
681         .capture = {
682                 .channels_min = 2,
683                 .channels_max = 2,
684                 .rates = SNDRV_PCM_RATE_8000_192000,
685                 .formats = SNDRV_PCM_FMTBIT_S32_LE
686         },
687         .ops = &img_spdif_in_dai_ops
688 };
689
690 static const struct snd_soc_component_driver img_spdif_in_component = {
691         .name = "img-spdif-in"
692 };
693
694 static int img_spdif_in_probe(struct platform_device *pdev)
695 {
696         struct img_spdif_in *spdif;
697         struct resource *res;
698         void __iomem *base;
699         int ret;
700         struct reset_control *rst;
701         u32 reg;
702         struct device *dev = &pdev->dev;
703
704         spdif = devm_kzalloc(&pdev->dev, sizeof(*spdif), GFP_KERNEL);
705         if (!spdif)
706                 return -ENOMEM;
707
708         platform_set_drvdata(pdev, spdif);
709
710         spdif->dev = &pdev->dev;
711
712         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
713         base = devm_ioremap_resource(&pdev->dev, res);
714         if (IS_ERR(base))
715                 return PTR_ERR(base);
716
717         spdif->base = base;
718
719         spdif->clk_sys = devm_clk_get(dev, "sys");
720         if (IS_ERR(spdif->clk_sys)) {
721                 if (PTR_ERR(spdif->clk_sys) != -EPROBE_DEFER)
722                         dev_err(dev, "Failed to acquire clock 'sys'\n");
723                 return PTR_ERR(spdif->clk_sys);
724         }
725
726         ret = clk_prepare_enable(spdif->clk_sys);
727         if (ret)
728                 return ret;
729
730         rst = devm_reset_control_get_exclusive(&pdev->dev, "rst");
731         if (IS_ERR(rst)) {
732                 if (PTR_ERR(rst) == -EPROBE_DEFER) {
733                         ret = -EPROBE_DEFER;
734                         goto err_clk_disable;
735                 }
736                 dev_dbg(dev, "No top level reset found\n");
737                 img_spdif_in_writel(spdif, IMG_SPDIF_IN_SOFT_RESET_MASK,
738                                 IMG_SPDIF_IN_SOFT_RESET);
739                 img_spdif_in_writel(spdif, 0, IMG_SPDIF_IN_SOFT_RESET);
740         } else {
741                 reset_control_assert(rst);
742                 reset_control_deassert(rst);
743         }
744
745         spin_lock_init(&spdif->lock);
746
747         spdif->dma_data.addr = res->start + IMG_SPDIF_IN_RX_FIFO_OFFSET;
748         spdif->dma_data.addr_width = 4;
749         spdif->dma_data.maxburst = 4;
750         spdif->trk = 0x80;
751         spdif->lock_acquire = 4;
752         spdif->lock_release = -128;
753
754         reg = (spdif->lock_acquire << IMG_SPDIF_IN_CTL_LOCKHI_SHIFT) &
755                 IMG_SPDIF_IN_CTL_LOCKHI_MASK;
756         reg |= (spdif->lock_release << IMG_SPDIF_IN_CTL_LOCKLO_SHIFT) &
757                 IMG_SPDIF_IN_CTL_LOCKLO_MASK;
758         reg |= (spdif->trk << IMG_SPDIF_IN_CTL_TRK_SHIFT) &
759                 IMG_SPDIF_IN_CTL_TRK_MASK;
760         img_spdif_in_writel(spdif, reg, IMG_SPDIF_IN_CTL);
761
762         ret = devm_snd_soc_register_component(&pdev->dev,
763                         &img_spdif_in_component, &img_spdif_in_dai, 1);
764         if (ret)
765                 goto err_clk_disable;
766
767         ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0);
768         if (ret)
769                 goto err_clk_disable;
770
771         return 0;
772
773 err_clk_disable:
774         clk_disable_unprepare(spdif->clk_sys);
775
776         return ret;
777 }
778
779 static int img_spdif_in_dev_remove(struct platform_device *pdev)
780 {
781         struct img_spdif_in *spdif = platform_get_drvdata(pdev);
782
783         clk_disable_unprepare(spdif->clk_sys);
784
785         return 0;
786 }
787
788 static const struct of_device_id img_spdif_in_of_match[] = {
789         { .compatible = "img,spdif-in" },
790         {}
791 };
792 MODULE_DEVICE_TABLE(of, img_spdif_in_of_match);
793
794 static struct platform_driver img_spdif_in_driver = {
795         .driver = {
796                 .name = "img-spdif-in",
797                 .of_match_table = img_spdif_in_of_match
798         },
799         .probe = img_spdif_in_probe,
800         .remove = img_spdif_in_dev_remove
801 };
802 module_platform_driver(img_spdif_in_driver);
803
804 MODULE_AUTHOR("Damien Horsley <Damien.Horsley@imgtec.com>");
805 MODULE_DESCRIPTION("IMG SPDIF Input driver");
806 MODULE_LICENSE("GPL v2");