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

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

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ 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/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");
895 

~ [ 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