xref: /openbmc/linux/sound/soc/img/img-spdif-in.c (revision 56a0eccd) 
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(&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");
807