Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
spdif_in.c
Go to the documentation of this file.
1 /*
2  * ALSA SoC SPDIF In Audio Layer for spear processors
3  *
4  * Copyright (C) 2012 ST Microelectronics
5  * Vipin Kumar <[email protected]>
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/pcm.h>
22 #include <sound/pcm_params.h>
23 #include <sound/soc.h>
24 #include <sound/spear_dma.h>
25 #include <sound/spear_spdif.h>
26 #include "spdif_in_regs.h"
27 
30 };
31 
32 struct spdif_in_dev {
33  struct clk *clk;
36  void *io_base;
37  struct device *dev;
39  int irq;
40 };
41 
42 static void spdif_in_configure(struct spdif_in_dev *host)
43 {
47 
48  writel(ctrl, host->io_base + SPDIF_IN_CTRL);
49  writel(0xF, host->io_base + SPDIF_IN_IRQ_MASK);
50 }
51 
52 static int spdif_in_startup(struct snd_pcm_substream *substream,
53  struct snd_soc_dai *cpu_dai)
54 {
55  struct spdif_in_dev *host = snd_soc_dai_get_drvdata(cpu_dai);
56 
57  if (substream->stream != SNDRV_PCM_STREAM_CAPTURE)
58  return -EINVAL;
59 
60  snd_soc_dai_set_dma_data(cpu_dai, substream, (void *)&host->dma_params);
61  return 0;
62 }
63 
64 static void spdif_in_shutdown(struct snd_pcm_substream *substream,
65  struct snd_soc_dai *dai)
66 {
67  struct spdif_in_dev *host = snd_soc_dai_get_drvdata(dai);
68 
69  if (substream->stream != SNDRV_PCM_STREAM_CAPTURE)
70  return;
71 
72  writel(0x0, host->io_base + SPDIF_IN_IRQ_MASK);
73  snd_soc_dai_set_dma_data(dai, substream, NULL);
74 }
75 
76 static void spdif_in_format(struct spdif_in_dev *host, u32 format)
77 {
78  u32 ctrl = readl(host->io_base + SPDIF_IN_CTRL);
79 
80  switch (format) {
82  ctrl |= SPDIF_XTRACT_16BIT;
83  break;
84 
86  ctrl &= ~SPDIF_XTRACT_16BIT;
87  break;
88  }
89 
90  writel(ctrl, host->io_base + SPDIF_IN_CTRL);
91 }
92 
93 static int spdif_in_hw_params(struct snd_pcm_substream *substream,
94  struct snd_pcm_hw_params *params,
95  struct snd_soc_dai *dai)
96 {
97  struct spdif_in_dev *host = snd_soc_dai_get_drvdata(dai);
98  u32 format;
99 
100  if (substream->stream != SNDRV_PCM_STREAM_CAPTURE)
101  return -EINVAL;
102 
103  format = params_format(params);
104  host->saved_params.format = format;
105 
106  return 0;
107 }
108 
109 static int spdif_in_trigger(struct snd_pcm_substream *substream, int cmd,
110  struct snd_soc_dai *dai)
111 {
112  struct spdif_in_dev *host = snd_soc_dai_get_drvdata(dai);
113  u32 ctrl;
114  int ret = 0;
115 
116  if (substream->stream != SNDRV_PCM_STREAM_CAPTURE)
117  return -EINVAL;
118 
119  switch (cmd) {
123  clk_enable(host->clk);
124  spdif_in_configure(host);
125  spdif_in_format(host, host->saved_params.format);
126 
127  ctrl = readl(host->io_base + SPDIF_IN_CTRL);
128  ctrl |= SPDIF_IN_SAMPLE | SPDIF_IN_ENB;
129  writel(ctrl, host->io_base + SPDIF_IN_CTRL);
130  writel(0xF, host->io_base + SPDIF_IN_IRQ_MASK);
131  break;
132 
136  ctrl = readl(host->io_base + SPDIF_IN_CTRL);
137  ctrl &= ~(SPDIF_IN_SAMPLE | SPDIF_IN_ENB);
138  writel(ctrl, host->io_base + SPDIF_IN_CTRL);
139  writel(0x0, host->io_base + SPDIF_IN_IRQ_MASK);
140 
141  if (host->reset_perip)
142  host->reset_perip();
143  clk_disable(host->clk);
144  break;
145 
146  default:
147  ret = -EINVAL;
148  break;
149  }
150  return ret;
151 }
152 
153 static struct snd_soc_dai_ops spdif_in_dai_ops = {
154  .startup = spdif_in_startup,
155  .shutdown = spdif_in_shutdown,
156  .trigger = spdif_in_trigger,
157  .hw_params = spdif_in_hw_params,
158 };
159 
161  .capture = {
162  .channels_min = 2,
163  .channels_max = 2,
165  SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \
166  SNDRV_PCM_RATE_192000),
169  },
170  .ops = &spdif_in_dai_ops,
171 };
172 
173 static irqreturn_t spdif_in_irq(int irq, void *arg)
174 {
175  struct spdif_in_dev *host = (struct spdif_in_dev *)arg;
176 
177  u32 irq_status = readl(host->io_base + SPDIF_IN_IRQ);
178 
179  if (!irq_status)
180  return IRQ_NONE;
181 
182  if (irq_status & SPDIF_IRQ_FIFOWRITE)
183  dev_err(host->dev, "spdif in: fifo write error");
184  if (irq_status & SPDIF_IRQ_EMPTYFIFOREAD)
185  dev_err(host->dev, "spdif in: empty fifo read error");
186  if (irq_status & SPDIF_IRQ_FIFOFULL)
187  dev_err(host->dev, "spdif in: fifo full error");
188  if (irq_status & SPDIF_IRQ_OUTOFRANGE)
189  dev_err(host->dev, "spdif in: out of range error");
190 
191  writel(0, host->io_base + SPDIF_IN_IRQ);
192 
193  return IRQ_HANDLED;
194 }
195 
196 static int spdif_in_probe(struct platform_device *pdev)
197 {
198  struct spdif_in_dev *host;
200  struct resource *res, *res_fifo;
201  int ret;
202 
203  res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
204  if (!res)
205  return -EINVAL;
206 
207  res_fifo = platform_get_resource(pdev, IORESOURCE_IO, 0);
208  if (!res_fifo)
209  return -EINVAL;
210 
211  if (!devm_request_mem_region(&pdev->dev, res->start,
212  resource_size(res), pdev->name)) {
213  dev_warn(&pdev->dev, "Failed to get memory resourse\n");
214  return -ENOENT;
215  }
216 
217  host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL);
218  if (!host) {
219  dev_warn(&pdev->dev, "kzalloc fail\n");
220  return -ENOMEM;
221  }
222 
223  host->io_base = devm_ioremap(&pdev->dev, res->start,
224  resource_size(res));
225  if (!host->io_base) {
226  dev_warn(&pdev->dev, "ioremap failed\n");
227  return -ENOMEM;
228  }
229 
230  host->irq = platform_get_irq(pdev, 0);
231  if (host->irq < 0)
232  return -EINVAL;
233 
234  host->clk = clk_get(&pdev->dev, NULL);
235  if (IS_ERR(host->clk))
236  return PTR_ERR(host->clk);
237 
238  pdata = dev_get_platdata(&pdev->dev);
239 
240  if (!pdata)
241  return -EINVAL;
242 
243  host->dma_params.data = pdata->dma_params;
244  host->dma_params.addr = res_fifo->start;
245  host->dma_params.max_burst = 16;
246  host->dma_params.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
247  host->dma_params.filter = pdata->filter;
248  host->reset_perip = pdata->reset_perip;
249 
250  host->dev = &pdev->dev;
251  dev_set_drvdata(&pdev->dev, host);
252 
253  ret = devm_request_irq(&pdev->dev, host->irq, spdif_in_irq, 0,
254  "spdif-in", host);
255  if (ret) {
256  clk_put(host->clk);
257  dev_warn(&pdev->dev, "request_irq failed\n");
258  return ret;
259  }
260 
261  ret = snd_soc_register_dai(&pdev->dev, &spdif_in_dai);
262  if (ret != 0) {
263  clk_put(host->clk);
264  return ret;
265  }
266 
267  return 0;
268 }
269 
270 static int spdif_in_remove(struct platform_device *pdev)
271 {
272  struct spdif_in_dev *host = dev_get_drvdata(&pdev->dev);
273 
274  snd_soc_unregister_dai(&pdev->dev);
275  dev_set_drvdata(&pdev->dev, NULL);
276 
277  clk_put(host->clk);
278 
279  return 0;
280 }
281 
282 
283 static struct platform_driver spdif_in_driver = {
284  .probe = spdif_in_probe,
285  .remove = spdif_in_remove,
286  .driver = {
287  .name = "spdif-in",
288  .owner = THIS_MODULE,
289  },
290 };
291 
292 module_platform_driver(spdif_in_driver);
293 
294 MODULE_AUTHOR("Vipin Kumar <[email protected]>");
295 MODULE_DESCRIPTION("SPEAr SPDIF IN SoC Interface");
296 MODULE_LICENSE("GPL");
297 MODULE_ALIAS("platform:spdif_in");