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