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

TOMOYO Linux Cross Reference
Linux/sound/soc/spear/spdif_out.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ 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.77 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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  * ALSA SoC SPDIF Out Audio Layer for spear processors
  3  *
  4  * Copyright (C) 2012 ST Microelectronics
  5  * Vipin Kumar <vipin.kumar@st.com>
  6  *
  7  * This file is licensed under the terms of the GNU General Public
  8  * License version 2. This program is licensed "as is" without any
  9  * warranty of any kind, whether express or implied.
 10  */
 11 
 12 #include <linux/clk.h>
 13 #include <linux/delay.h>
 14 #include <linux/device.h>
 15 #include <linux/kernel.h>
 16 #include <linux/init.h>
 17 #include <linux/io.h>
 18 #include <linux/ioport.h>
 19 #include <linux/module.h>
 20 #include <linux/platform_device.h>
 21 #include <sound/soc.h>
 22 #include <sound/spear_dma.h>
 23 #include <sound/spear_spdif.h>
 24 #include "spdif_out_regs.h"
 25 
 26 struct spdif_out_params {
 27         u32 rate;
 28         u32 core_freq;
 29         u32 mute;
 30 };
 31 
 32 struct spdif_out_dev {
 33         struct clk *clk;
 34         struct spear_dma_data dma_params;
 35         struct spdif_out_params saved_params;
 36         u32 running;
 37         void __iomem *io_base;
 38 };
 39 
 40 static void spdif_out_configure(struct spdif_out_dev *host)
 41 {
 42         writel(SPDIF_OUT_RESET, host->io_base + SPDIF_OUT_SOFT_RST);
 43         mdelay(1);
 44         writel(readl(host->io_base + SPDIF_OUT_SOFT_RST) & ~SPDIF_OUT_RESET,
 45                         host->io_base + SPDIF_OUT_SOFT_RST);
 46 
 47         writel(SPDIF_OUT_FDMA_TRIG_16 | SPDIF_OUT_MEMFMT_16_16 |
 48                         SPDIF_OUT_VALID_HW | SPDIF_OUT_USER_HW |
 49                         SPDIF_OUT_CHNLSTA_HW | SPDIF_OUT_PARITY_HW,
 50                         host->io_base + SPDIF_OUT_CFG);
 51 
 52         writel(0x7F, host->io_base + SPDIF_OUT_INT_STA_CLR);
 53         writel(0x7F, host->io_base + SPDIF_OUT_INT_EN_CLR);
 54 }
 55 
 56 static int spdif_out_startup(struct snd_pcm_substream *substream,
 57                 struct snd_soc_dai *cpu_dai)
 58 {
 59         struct spdif_out_dev *host = snd_soc_dai_get_drvdata(cpu_dai);
 60         int ret;
 61 
 62         if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK)
 63                 return -EINVAL;
 64 
 65         snd_soc_dai_set_dma_data(cpu_dai, substream, (void *)&host->dma_params);
 66 
 67         ret = clk_enable(host->clk);
 68         if (ret)
 69                 return ret;
 70 
 71         host->running = true;
 72         spdif_out_configure(host);
 73 
 74         return 0;
 75 }
 76 
 77 static void spdif_out_shutdown(struct snd_pcm_substream *substream,
 78                 struct snd_soc_dai *dai)
 79 {
 80         struct spdif_out_dev *host = snd_soc_dai_get_drvdata(dai);
 81 
 82         if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK)
 83                 return;
 84 
 85         clk_disable(host->clk);
 86         host->running = false;
 87         snd_soc_dai_set_dma_data(dai, substream, NULL);
 88 }
 89 
 90 static void spdif_out_clock(struct spdif_out_dev *host, u32 core_freq,
 91                 u32 rate)
 92 {
 93         u32 divider, ctrl;
 94 
 95         clk_set_rate(host->clk, core_freq);
 96         divider = DIV_ROUND_CLOSEST(clk_get_rate(host->clk), (rate * 128));
 97 
 98         ctrl = readl(host->io_base + SPDIF_OUT_CTRL);
 99         ctrl &= ~SPDIF_DIVIDER_MASK;
100         ctrl |= (divider << SPDIF_DIVIDER_SHIFT) & SPDIF_DIVIDER_MASK;
101         writel(ctrl, host->io_base + SPDIF_OUT_CTRL);
102 }
103 
104 static int spdif_out_hw_params(struct snd_pcm_substream *substream,
105                 struct snd_pcm_hw_params *params,
106                 struct snd_soc_dai *dai)
107 {
108         struct spdif_out_dev *host = snd_soc_dai_get_drvdata(dai);
109         u32 rate, core_freq;
110 
111         if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK)
112                 return -EINVAL;
113 
114         rate = params_rate(params);
115 
116         switch (rate) {
117         case 8000:
118         case 16000:
119         case 32000:
120         case 64000:
121                 /*
122                  * The clock is multiplied by 10 to bring it to feasible range
123                  * of frequencies for sscg
124                  */
125                 core_freq = 64000 * 128 * 10;   /* 81.92 MHz */
126                 break;
127         case 5512:
128         case 11025:
129         case 22050:
130         case 44100:
131         case 88200:
132         case 176400:
133                 core_freq = 176400 * 128;       /* 22.5792 MHz */
134                 break;
135         case 48000:
136         case 96000:
137         case 192000:
138         default:
139                 core_freq = 192000 * 128;       /* 24.576 MHz */
140                 break;
141         }
142 
143         spdif_out_clock(host, core_freq, rate);
144         host->saved_params.core_freq = core_freq;
145         host->saved_params.rate = rate;
146 
147         return 0;
148 }
149 
150 static int spdif_out_trigger(struct snd_pcm_substream *substream, int cmd,
151                 struct snd_soc_dai *dai)
152 {
153         struct spdif_out_dev *host = snd_soc_dai_get_drvdata(dai);
154         u32 ctrl;
155         int ret = 0;
156 
157         if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK)
158                 return -EINVAL;
159 
160         switch (cmd) {
161         case SNDRV_PCM_TRIGGER_START:
162         case SNDRV_PCM_TRIGGER_RESUME:
163         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
164                         ctrl = readl(host->io_base + SPDIF_OUT_CTRL);
165                         ctrl &= ~SPDIF_OPMODE_MASK;
166                         if (!host->saved_params.mute)
167                                 ctrl |= SPDIF_OPMODE_AUD_DATA |
168                                         SPDIF_STATE_NORMAL;
169                         else
170                                 ctrl |= SPDIF_OPMODE_MUTE_PCM;
171                         writel(ctrl, host->io_base + SPDIF_OUT_CTRL);
172                 break;
173 
174         case SNDRV_PCM_TRIGGER_STOP:
175         case SNDRV_PCM_TRIGGER_SUSPEND:
176         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
177                 ctrl = readl(host->io_base + SPDIF_OUT_CTRL);
178                 ctrl &= ~SPDIF_OPMODE_MASK;
179                 ctrl |= SPDIF_OPMODE_OFF;
180                 writel(ctrl, host->io_base + SPDIF_OUT_CTRL);
181                 break;
182 
183         default:
184                 ret = -EINVAL;
185                 break;
186         }
187         return ret;
188 }
189 
190 static int spdif_digital_mute(struct snd_soc_dai *dai, int mute)
191 {
192         struct spdif_out_dev *host = snd_soc_dai_get_drvdata(dai);
193         u32 val;
194 
195         host->saved_params.mute = mute;
196         val = readl(host->io_base + SPDIF_OUT_CTRL);
197         val &= ~SPDIF_OPMODE_MASK;
198 
199         if (mute)
200                 val |= SPDIF_OPMODE_MUTE_PCM;
201         else {
202                 if (host->running)
203                         val |= SPDIF_OPMODE_AUD_DATA | SPDIF_STATE_NORMAL;
204                 else
205                         val |= SPDIF_OPMODE_OFF;
206         }
207 
208         writel(val, host->io_base + SPDIF_OUT_CTRL);
209         return 0;
210 }
211 
212 static int spdif_mute_get(struct snd_kcontrol *kcontrol,
213                 struct snd_ctl_elem_value *ucontrol)
214 {
215         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
216         struct snd_soc_card *card = codec->card;
217         struct snd_soc_pcm_runtime *rtd = card->rtd;
218         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
219         struct spdif_out_dev *host = snd_soc_dai_get_drvdata(cpu_dai);
220 
221         ucontrol->value.integer.value[0] = host->saved_params.mute;
222         return 0;
223 }
224 
225 static int spdif_mute_put(struct snd_kcontrol *kcontrol,
226                 struct snd_ctl_elem_value *ucontrol)
227 {
228         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
229         struct snd_soc_card *card = codec->card;
230         struct snd_soc_pcm_runtime *rtd = card->rtd;
231         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
232         struct spdif_out_dev *host = snd_soc_dai_get_drvdata(cpu_dai);
233 
234         if (host->saved_params.mute == ucontrol->value.integer.value[0])
235                 return 0;
236 
237         spdif_digital_mute(cpu_dai, ucontrol->value.integer.value[0]);
238 
239         return 1;
240 }
241 static const struct snd_kcontrol_new spdif_out_controls[] = {
242         SOC_SINGLE_BOOL_EXT("IEC958 Playback Switch", 0,
243                         spdif_mute_get, spdif_mute_put),
244 };
245 
246 int spdif_soc_dai_probe(struct snd_soc_dai *dai)
247 {
248         return snd_soc_add_dai_controls(dai, spdif_out_controls,
249                                 ARRAY_SIZE(spdif_out_controls));
250 }
251 
252 static const struct snd_soc_dai_ops spdif_out_dai_ops = {
253         .digital_mute   = spdif_digital_mute,
254         .startup        = spdif_out_startup,
255         .shutdown       = spdif_out_shutdown,
256         .trigger        = spdif_out_trigger,
257         .hw_params      = spdif_out_hw_params,
258 };
259 
260 static struct snd_soc_dai_driver spdif_out_dai = {
261         .playback = {
262                 .channels_min = 2,
263                 .channels_max = 2,
264                 .rates = (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
265                                  SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \
266                                  SNDRV_PCM_RATE_192000),
267                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
268         },
269         .probe = spdif_soc_dai_probe,
270         .ops = &spdif_out_dai_ops,
271 };
272 
273 static int spdif_out_probe(struct platform_device *pdev)
274 {
275         struct spdif_out_dev *host;
276         struct spear_spdif_platform_data *pdata;
277         struct resource *res;
278         int ret;
279 
280         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
281         if (!res)
282                 return -EINVAL;
283 
284         if (!devm_request_mem_region(&pdev->dev, res->start,
285                                 resource_size(res), pdev->name)) {
286                 dev_warn(&pdev->dev, "Failed to get memory resourse\n");
287                 return -ENOENT;
288         }
289 
290         host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL);
291         if (!host) {
292                 dev_warn(&pdev->dev, "kzalloc fail\n");
293                 return -ENOMEM;
294         }
295 
296         host->io_base = devm_ioremap(&pdev->dev, res->start,
297                                 resource_size(res));
298         if (!host->io_base) {
299                 dev_warn(&pdev->dev, "ioremap failed\n");
300                 return -ENOMEM;
301         }
302 
303         host->clk = clk_get(&pdev->dev, NULL);
304         if (IS_ERR(host->clk))
305                 return PTR_ERR(host->clk);
306 
307         pdata = dev_get_platdata(&pdev->dev);
308 
309         host->dma_params.data = pdata->dma_params;
310         host->dma_params.addr = res->start + SPDIF_OUT_FIFO_DATA;
311         host->dma_params.max_burst = 16;
312         host->dma_params.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
313         host->dma_params.filter = pdata->filter;
314 
315         dev_set_drvdata(&pdev->dev, host);
316 
317         ret = snd_soc_register_dai(&pdev->dev, &spdif_out_dai);
318         if (ret != 0) {
319                 clk_put(host->clk);
320                 return ret;
321         }
322 
323         return 0;
324 }
325 
326 static int spdif_out_remove(struct platform_device *pdev)
327 {
328         struct spdif_out_dev *host = dev_get_drvdata(&pdev->dev);
329 
330         snd_soc_unregister_dai(&pdev->dev);
331         dev_set_drvdata(&pdev->dev, NULL);
332 
333         clk_put(host->clk);
334 
335         return 0;
336 }
337 
338 #ifdef CONFIG_PM
339 static int spdif_out_suspend(struct device *dev)
340 {
341         struct platform_device *pdev = to_platform_device(dev);
342         struct spdif_out_dev *host = dev_get_drvdata(&pdev->dev);
343 
344         if (host->running)
345                 clk_disable(host->clk);
346 
347         return 0;
348 }
349 
350 static int spdif_out_resume(struct device *dev)
351 {
352         struct platform_device *pdev = to_platform_device(dev);
353         struct spdif_out_dev *host = dev_get_drvdata(&pdev->dev);
354 
355         if (host->running) {
356                 clk_enable(host->clk);
357                 spdif_out_configure(host);
358                 spdif_out_clock(host, host->saved_params.core_freq,
359                                 host->saved_params.rate);
360         }
361         return 0;
362 }
363 
364 static SIMPLE_DEV_PM_OPS(spdif_out_dev_pm_ops, spdif_out_suspend, \
365                 spdif_out_resume);
366 
367 #define SPDIF_OUT_DEV_PM_OPS (&spdif_out_dev_pm_ops)
368 
369 #else
370 #define SPDIF_OUT_DEV_PM_OPS NULL
371 
372 #endif
373 
374 static struct platform_driver spdif_out_driver = {
375         .probe          = spdif_out_probe,
376         .remove         = spdif_out_remove,
377         .driver         = {
378                 .name   = "spdif-out",
379                 .owner  = THIS_MODULE,
380                 .pm     = SPDIF_OUT_DEV_PM_OPS,
381         },
382 };
383 
384 module_platform_driver(spdif_out_driver);
385 
386 MODULE_AUTHOR("Vipin Kumar <vipin.kumar@st.com>");
387 MODULE_DESCRIPTION("SPEAr SPDIF OUT SoC Interface");
388 MODULE_LICENSE("GPL");
389 MODULE_ALIAS("platform:spdif_out");
390 

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