~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/img/img-spdif-in.c

Version: ~ [ linux-5.10-rc6 ] ~ [ linux-5.9.12 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.81 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.161 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.210 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.247 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.247 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp