Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/sound/soc/kirkwood/kirkwood-i2s.c

  1 /*
  2  * kirkwood-i2s.c
  3  *
  4  * (c) 2010 Arnaud Patard <apatard@mandriva.com>
  5  * (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
  6  *
  7  *  This program is free software; you can redistribute  it and/or modify it
  8  *  under  the terms of  the GNU General  Public License as published by the
  9  *  Free Software Foundation;  either version 2 of the  License, or (at your
 10  *  option) any later version.
 11  */
 12 
 13 #include <linux/init.h>
 14 #include <linux/module.h>
 15 #include <linux/platform_device.h>
 16 #include <linux/io.h>
 17 #include <linux/slab.h>
 18 #include <linux/mbus.h>
 19 #include <linux/delay.h>
 20 #include <linux/clk.h>
 21 #include <sound/pcm.h>
 22 #include <sound/pcm_params.h>
 23 #include <sound/soc.h>
 24 #include <linux/platform_data/asoc-kirkwood.h>
 25 #include <linux/of.h>
 26 
 27 #include "kirkwood.h"
 28 
 29 #define DRV_NAME        "mvebu-audio"
 30 
 31 #define KIRKWOOD_I2S_FORMATS \
 32         (SNDRV_PCM_FMTBIT_S16_LE | \
 33          SNDRV_PCM_FMTBIT_S24_LE | \
 34          SNDRV_PCM_FMTBIT_S32_LE)
 35 
 36 #define KIRKWOOD_SPDIF_FORMATS \
 37         (SNDRV_PCM_FMTBIT_S16_LE | \
 38          SNDRV_PCM_FMTBIT_S24_LE)
 39 
 40 static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
 41                 unsigned int fmt)
 42 {
 43         struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(cpu_dai);
 44         unsigned long mask;
 45         unsigned long value;
 46 
 47         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 48         case SND_SOC_DAIFMT_RIGHT_J:
 49                 mask = KIRKWOOD_I2S_CTL_RJ;
 50                 break;
 51         case SND_SOC_DAIFMT_LEFT_J:
 52                 mask = KIRKWOOD_I2S_CTL_LJ;
 53                 break;
 54         case SND_SOC_DAIFMT_I2S:
 55                 mask = KIRKWOOD_I2S_CTL_I2S;
 56                 break;
 57         default:
 58                 return -EINVAL;
 59         }
 60 
 61         /*
 62          * Set same format for playback and record
 63          * This avoids some troubles.
 64          */
 65         value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
 66         value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
 67         value |= mask;
 68         writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);
 69 
 70         value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
 71         value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
 72         value |= mask;
 73         writel(value, priv->io+KIRKWOOD_I2S_RECCTL);
 74 
 75         return 0;
 76 }
 77 
 78 static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
 79 {
 80         unsigned long value;
 81 
 82         value = KIRKWOOD_DCO_CTL_OFFSET_0;
 83         switch (rate) {
 84         default:
 85         case 44100:
 86                 value |= KIRKWOOD_DCO_CTL_FREQ_11;
 87                 break;
 88         case 48000:
 89                 value |= KIRKWOOD_DCO_CTL_FREQ_12;
 90                 break;
 91         case 96000:
 92                 value |= KIRKWOOD_DCO_CTL_FREQ_24;
 93                 break;
 94         }
 95         writel(value, io + KIRKWOOD_DCO_CTL);
 96 
 97         /* wait for dco locked */
 98         do {
 99                 cpu_relax();
100                 value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
101                 value &= KIRKWOOD_DCO_SPCR_STATUS_DCO_LOCK;
102         } while (value == 0);
103 }
104 
105 static void kirkwood_set_rate(struct snd_soc_dai *dai,
106         struct kirkwood_dma_data *priv, unsigned long rate)
107 {
108         uint32_t clks_ctrl;
109 
110         if (IS_ERR(priv->extclk)) {
111                 /* use internal dco for the supported rates
112                  * defined in kirkwood_i2s_dai */
113                 dev_dbg(dai->dev, "%s: dco set rate = %lu\n",
114                         __func__, rate);
115                 kirkwood_set_dco(priv->io, rate);
116 
117                 clks_ctrl = KIRKWOOD_MCLK_SOURCE_DCO;
118         } else {
119                 /* use the external clock for the other rates
120                  * defined in kirkwood_i2s_dai_extclk */
121                 dev_dbg(dai->dev, "%s: extclk set rate = %lu -> %lu\n",
122                         __func__, rate, 256 * rate);
123                 clk_set_rate(priv->extclk, 256 * rate);
124 
125                 clks_ctrl = KIRKWOOD_MCLK_SOURCE_EXTCLK;
126         }
127         writel(clks_ctrl, priv->io + KIRKWOOD_CLOCKS_CTRL);
128 }
129 
130 static int kirkwood_i2s_startup(struct snd_pcm_substream *substream,
131                 struct snd_soc_dai *dai)
132 {
133         struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
134 
135         snd_soc_dai_set_dma_data(dai, substream, priv);
136         return 0;
137 }
138 
139 static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
140                                  struct snd_pcm_hw_params *params,
141                                  struct snd_soc_dai *dai)
142 {
143         struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
144         uint32_t ctl_play, ctl_rec;
145         unsigned int i2s_reg;
146         unsigned long i2s_value;
147 
148         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
149                 i2s_reg = KIRKWOOD_I2S_PLAYCTL;
150         } else {
151                 i2s_reg = KIRKWOOD_I2S_RECCTL;
152         }
153 
154         kirkwood_set_rate(dai, priv, params_rate(params));
155 
156         i2s_value = readl(priv->io+i2s_reg);
157         i2s_value &= ~KIRKWOOD_I2S_CTL_SIZE_MASK;
158 
159         /*
160          * Size settings in play/rec i2s control regs and play/rec control
161          * regs must be the same.
162          */
163         switch (params_format(params)) {
164         case SNDRV_PCM_FORMAT_S16_LE:
165                 i2s_value |= KIRKWOOD_I2S_CTL_SIZE_16;
166                 ctl_play = KIRKWOOD_PLAYCTL_SIZE_16_C |
167                            KIRKWOOD_PLAYCTL_I2S_EN |
168                            KIRKWOOD_PLAYCTL_SPDIF_EN;
169                 ctl_rec = KIRKWOOD_RECCTL_SIZE_16_C |
170                           KIRKWOOD_RECCTL_I2S_EN |
171                           KIRKWOOD_RECCTL_SPDIF_EN;
172                 break;
173         /*
174          * doesn't work... S20_3LE != kirkwood 20bit format ?
175          *
176         case SNDRV_PCM_FORMAT_S20_3LE:
177                 i2s_value |= KIRKWOOD_I2S_CTL_SIZE_20;
178                 ctl_play = KIRKWOOD_PLAYCTL_SIZE_20 |
179                            KIRKWOOD_PLAYCTL_I2S_EN;
180                 ctl_rec = KIRKWOOD_RECCTL_SIZE_20 |
181                           KIRKWOOD_RECCTL_I2S_EN;
182                 break;
183         */
184         case SNDRV_PCM_FORMAT_S24_LE:
185                 i2s_value |= KIRKWOOD_I2S_CTL_SIZE_24;
186                 ctl_play = KIRKWOOD_PLAYCTL_SIZE_24 |
187                            KIRKWOOD_PLAYCTL_I2S_EN |
188                            KIRKWOOD_PLAYCTL_SPDIF_EN;
189                 ctl_rec = KIRKWOOD_RECCTL_SIZE_24 |
190                           KIRKWOOD_RECCTL_I2S_EN |
191                           KIRKWOOD_RECCTL_SPDIF_EN;
192                 break;
193         case SNDRV_PCM_FORMAT_S32_LE:
194                 i2s_value |= KIRKWOOD_I2S_CTL_SIZE_32;
195                 ctl_play = KIRKWOOD_PLAYCTL_SIZE_32 |
196                            KIRKWOOD_PLAYCTL_I2S_EN;
197                 ctl_rec = KIRKWOOD_RECCTL_SIZE_32 |
198                           KIRKWOOD_RECCTL_I2S_EN;
199                 break;
200         default:
201                 return -EINVAL;
202         }
203 
204         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
205                 if (params_channels(params) == 1)
206                         ctl_play |= KIRKWOOD_PLAYCTL_MONO_BOTH;
207                 else
208                         ctl_play |= KIRKWOOD_PLAYCTL_MONO_OFF;
209 
210                 priv->ctl_play &= ~(KIRKWOOD_PLAYCTL_MONO_MASK |
211                                     KIRKWOOD_PLAYCTL_ENABLE_MASK |
212                                     KIRKWOOD_PLAYCTL_SIZE_MASK);
213                 priv->ctl_play |= ctl_play;
214         } else {
215                 priv->ctl_rec &= ~(KIRKWOOD_RECCTL_ENABLE_MASK |
216                                    KIRKWOOD_RECCTL_SIZE_MASK);
217                 priv->ctl_rec |= ctl_rec;
218         }
219 
220         writel(i2s_value, priv->io+i2s_reg);
221 
222         return 0;
223 }
224 
225 static unsigned kirkwood_i2s_play_mute(unsigned ctl)
226 {
227         if (!(ctl & KIRKWOOD_PLAYCTL_I2S_EN))
228                 ctl |= KIRKWOOD_PLAYCTL_I2S_MUTE;
229         if (!(ctl & KIRKWOOD_PLAYCTL_SPDIF_EN))
230                 ctl |= KIRKWOOD_PLAYCTL_SPDIF_MUTE;
231         return ctl;
232 }
233 
234 static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
235                                 int cmd, struct snd_soc_dai *dai)
236 {
237         struct snd_pcm_runtime *runtime = substream->runtime;
238         struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
239         uint32_t ctl, value;
240 
241         ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
242         if ((ctl & KIRKWOOD_PLAYCTL_ENABLE_MASK) == 0) {
243                 unsigned timeout = 5000;
244                 /*
245                  * The Armada510 spec says that if we enter pause mode, the
246                  * busy bit must be read back as clear _twice_.  Make sure
247                  * we respect that otherwise we get DMA underruns.
248                  */
249                 do {
250                         value = ctl;
251                         ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
252                         if (!((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY))
253                                 break;
254                         udelay(1);
255                 } while (timeout--);
256 
257                 if ((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY)
258                         dev_notice(dai->dev, "timed out waiting for busy to deassert: %08x\n",
259                                    ctl);
260         }
261 
262         switch (cmd) {
263         case SNDRV_PCM_TRIGGER_START:
264                 /* configure */
265                 ctl = priv->ctl_play;
266                 if (dai->id == 0)
267                         ctl &= ~KIRKWOOD_PLAYCTL_SPDIF_EN;      /* i2s */
268                 else
269                         ctl &= ~KIRKWOOD_PLAYCTL_I2S_EN;        /* spdif */
270                 ctl = kirkwood_i2s_play_mute(ctl);
271                 value = ctl & ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
272                 writel(value, priv->io + KIRKWOOD_PLAYCTL);
273 
274                 /* enable interrupts */
275                 if (!runtime->no_period_wakeup) {
276                         value = readl(priv->io + KIRKWOOD_INT_MASK);
277                         value |= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
278                         writel(value, priv->io + KIRKWOOD_INT_MASK);
279                 }
280 
281                 /* enable playback */
282                 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
283                 break;
284 
285         case SNDRV_PCM_TRIGGER_STOP:
286                 /* stop audio, disable interrupts */
287                 ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
288                                 KIRKWOOD_PLAYCTL_SPDIF_MUTE;
289                 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
290 
291                 value = readl(priv->io + KIRKWOOD_INT_MASK);
292                 value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
293                 writel(value, priv->io + KIRKWOOD_INT_MASK);
294 
295                 /* disable all playbacks */
296                 ctl &= ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
297                 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
298                 break;
299 
300         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
301         case SNDRV_PCM_TRIGGER_SUSPEND:
302                 ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
303                                 KIRKWOOD_PLAYCTL_SPDIF_MUTE;
304                 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
305                 break;
306 
307         case SNDRV_PCM_TRIGGER_RESUME:
308         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
309                 ctl &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
310                                 KIRKWOOD_PLAYCTL_SPDIF_MUTE);
311                 ctl = kirkwood_i2s_play_mute(ctl);
312                 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
313                 break;
314 
315         default:
316                 return -EINVAL;
317         }
318 
319         return 0;
320 }
321 
322 static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
323                                 int cmd, struct snd_soc_dai *dai)
324 {
325         struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
326         uint32_t ctl, value;
327 
328         value = readl(priv->io + KIRKWOOD_RECCTL);
329 
330         switch (cmd) {
331         case SNDRV_PCM_TRIGGER_START:
332                 /* configure */
333                 ctl = priv->ctl_rec;
334                 if (dai->id == 0)
335                         ctl &= ~KIRKWOOD_RECCTL_SPDIF_EN;       /* i2s */
336                 else
337                         ctl &= ~KIRKWOOD_RECCTL_I2S_EN;         /* spdif */
338 
339                 value = ctl & ~KIRKWOOD_RECCTL_ENABLE_MASK;
340                 writel(value, priv->io + KIRKWOOD_RECCTL);
341 
342                 /* enable interrupts */
343                 value = readl(priv->io + KIRKWOOD_INT_MASK);
344                 value |= KIRKWOOD_INT_CAUSE_REC_BYTES;
345                 writel(value, priv->io + KIRKWOOD_INT_MASK);
346 
347                 /* enable record */
348                 writel(ctl, priv->io + KIRKWOOD_RECCTL);
349                 break;
350 
351         case SNDRV_PCM_TRIGGER_STOP:
352                 /* stop audio, disable interrupts */
353                 value = readl(priv->io + KIRKWOOD_RECCTL);
354                 value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
355                 writel(value, priv->io + KIRKWOOD_RECCTL);
356 
357                 value = readl(priv->io + KIRKWOOD_INT_MASK);
358                 value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
359                 writel(value, priv->io + KIRKWOOD_INT_MASK);
360 
361                 /* disable all records */
362                 value = readl(priv->io + KIRKWOOD_RECCTL);
363                 value &= ~KIRKWOOD_RECCTL_ENABLE_MASK;
364                 writel(value, priv->io + KIRKWOOD_RECCTL);
365                 break;
366 
367         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
368         case SNDRV_PCM_TRIGGER_SUSPEND:
369                 value = readl(priv->io + KIRKWOOD_RECCTL);
370                 value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
371                 writel(value, priv->io + KIRKWOOD_RECCTL);
372                 break;
373 
374         case SNDRV_PCM_TRIGGER_RESUME:
375         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
376                 value = readl(priv->io + KIRKWOOD_RECCTL);
377                 value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE);
378                 writel(value, priv->io + KIRKWOOD_RECCTL);
379                 break;
380 
381         default:
382                 return -EINVAL;
383         }
384 
385         return 0;
386 }
387 
388 static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
389                                struct snd_soc_dai *dai)
390 {
391         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
392                 return kirkwood_i2s_play_trigger(substream, cmd, dai);
393         else
394                 return kirkwood_i2s_rec_trigger(substream, cmd, dai);
395 
396         return 0;
397 }
398 
399 static int kirkwood_i2s_init(struct kirkwood_dma_data *priv)
400 {
401         unsigned long value;
402         unsigned int reg_data;
403 
404         /* put system in a "safe" state : */
405         /* disable audio interrupts */
406         writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
407         writel(0, priv->io + KIRKWOOD_INT_MASK);
408 
409         reg_data = readl(priv->io + 0x1200);
410         reg_data &= (~(0x333FF8));
411         reg_data |= 0x111D18;
412         writel(reg_data, priv->io + 0x1200);
413 
414         msleep(500);
415 
416         reg_data = readl(priv->io + 0x1200);
417         reg_data &= (~(0x333FF8));
418         reg_data |= 0x111D18;
419         writel(reg_data, priv->io + 0x1200);
420 
421         /* disable playback/record */
422         value = readl(priv->io + KIRKWOOD_PLAYCTL);
423         value &= ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
424         writel(value, priv->io + KIRKWOOD_PLAYCTL);
425 
426         value = readl(priv->io + KIRKWOOD_RECCTL);
427         value &= ~KIRKWOOD_RECCTL_ENABLE_MASK;
428         writel(value, priv->io + KIRKWOOD_RECCTL);
429 
430         return 0;
431 
432 }
433 
434 static const struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
435         .startup        = kirkwood_i2s_startup,
436         .trigger        = kirkwood_i2s_trigger,
437         .hw_params      = kirkwood_i2s_hw_params,
438         .set_fmt        = kirkwood_i2s_set_fmt,
439 };
440 
441 static struct snd_soc_dai_driver kirkwood_i2s_dai[2] = {
442     {
443         .name = "i2s",
444         .id = 0,
445         .playback = {
446                 .channels_min = 1,
447                 .channels_max = 2,
448                 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
449                                 SNDRV_PCM_RATE_96000,
450                 .formats = KIRKWOOD_I2S_FORMATS,
451         },
452         .capture = {
453                 .channels_min = 1,
454                 .channels_max = 2,
455                 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
456                                 SNDRV_PCM_RATE_96000,
457                 .formats = KIRKWOOD_I2S_FORMATS,
458         },
459         .ops = &kirkwood_i2s_dai_ops,
460     },
461     {
462         .name = "spdif",
463         .id = 1,
464         .playback = {
465                 .channels_min = 1,
466                 .channels_max = 2,
467                 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
468                                 SNDRV_PCM_RATE_96000,
469                 .formats = KIRKWOOD_SPDIF_FORMATS,
470         },
471         .capture = {
472                 .channels_min = 1,
473                 .channels_max = 2,
474                 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
475                                 SNDRV_PCM_RATE_96000,
476                 .formats = KIRKWOOD_SPDIF_FORMATS,
477         },
478         .ops = &kirkwood_i2s_dai_ops,
479     },
480 };
481 
482 static struct snd_soc_dai_driver kirkwood_i2s_dai_extclk[2] = {
483     {
484         .name = "i2s",
485         .id = 0,
486         .playback = {
487                 .channels_min = 1,
488                 .channels_max = 2,
489                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
490                 .rate_min = 5512,
491                 .rate_max = 192000,
492                 .formats = KIRKWOOD_I2S_FORMATS,
493         },
494         .capture = {
495                 .channels_min = 1,
496                 .channels_max = 2,
497                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
498                 .rate_min = 5512,
499                 .rate_max = 192000,
500                 .formats = KIRKWOOD_I2S_FORMATS,
501         },
502         .ops = &kirkwood_i2s_dai_ops,
503     },
504     {
505         .name = "spdif",
506         .id = 1,
507         .playback = {
508                 .channels_min = 1,
509                 .channels_max = 2,
510                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
511                 .rate_min = 5512,
512                 .rate_max = 192000,
513                 .formats = KIRKWOOD_SPDIF_FORMATS,
514         },
515         .capture = {
516                 .channels_min = 1,
517                 .channels_max = 2,
518                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
519                 .rate_min = 5512,
520                 .rate_max = 192000,
521                 .formats = KIRKWOOD_SPDIF_FORMATS,
522         },
523         .ops = &kirkwood_i2s_dai_ops,
524     },
525 };
526 
527 static const struct snd_soc_component_driver kirkwood_i2s_component = {
528         .name           = DRV_NAME,
529 };
530 
531 static int kirkwood_i2s_dev_probe(struct platform_device *pdev)
532 {
533         struct kirkwood_asoc_platform_data *data = pdev->dev.platform_data;
534         struct snd_soc_dai_driver *soc_dai = kirkwood_i2s_dai;
535         struct kirkwood_dma_data *priv;
536         struct resource *mem;
537         struct device_node *np = pdev->dev.of_node;
538         int err;
539 
540         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
541         if (!priv) {
542                 dev_err(&pdev->dev, "allocation failed\n");
543                 return -ENOMEM;
544         }
545         dev_set_drvdata(&pdev->dev, priv);
546 
547         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
548         priv->io = devm_ioremap_resource(&pdev->dev, mem);
549         if (IS_ERR(priv->io))
550                 return PTR_ERR(priv->io);
551 
552         priv->irq = platform_get_irq(pdev, 0);
553         if (priv->irq <= 0) {
554                 dev_err(&pdev->dev, "platform_get_irq failed\n");
555                 return -ENXIO;
556         }
557 
558         if (np) {
559                 priv->burst = 128;              /* might be 32 or 128 */
560         } else if (data) {
561                 priv->burst = data->burst;
562         } else {
563                 dev_err(&pdev->dev, "no DT nor platform data ?!\n");
564                 return -EINVAL;
565         }
566 
567         priv->clk = devm_clk_get(&pdev->dev, np ? "internal" : NULL);
568         if (IS_ERR(priv->clk)) {
569                 dev_err(&pdev->dev, "no clock\n");
570                 return PTR_ERR(priv->clk);
571         }
572 
573         err = clk_prepare_enable(priv->clk);
574         if (err < 0)
575                 return err;
576 
577         priv->extclk = devm_clk_get(&pdev->dev, "extclk");
578         if (IS_ERR(priv->extclk)) {
579                 if (PTR_ERR(priv->extclk) == -EPROBE_DEFER)
580                         return -EPROBE_DEFER;
581         } else {
582                 if (priv->extclk == priv->clk) {
583                         devm_clk_put(&pdev->dev, priv->extclk);
584                         priv->extclk = ERR_PTR(-EINVAL);
585                 } else {
586                         dev_info(&pdev->dev, "found external clock\n");
587                         clk_prepare_enable(priv->extclk);
588                         soc_dai = kirkwood_i2s_dai_extclk;
589                 }
590         }
591 
592         /* Some sensible defaults - this reflects the powerup values */
593         priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24;
594         priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24;
595 
596         /* Select the burst size */
597         if (priv->burst == 32) {
598                 priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_32;
599                 priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_32;
600         } else {
601                 priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_128;
602                 priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_128;
603         }
604 
605         err = snd_soc_register_component(&pdev->dev, &kirkwood_i2s_component,
606                                          soc_dai, 2);
607         if (err) {
608                 dev_err(&pdev->dev, "snd_soc_register_component failed\n");
609                 goto err_component;
610         }
611 
612         err = snd_soc_register_platform(&pdev->dev, &kirkwood_soc_platform);
613         if (err) {
614                 dev_err(&pdev->dev, "snd_soc_register_platform failed\n");
615                 goto err_platform;
616         }
617 
618         kirkwood_i2s_init(priv);
619 
620         return 0;
621  err_platform:
622         snd_soc_unregister_component(&pdev->dev);
623  err_component:
624         if (!IS_ERR(priv->extclk))
625                 clk_disable_unprepare(priv->extclk);
626         clk_disable_unprepare(priv->clk);
627 
628         return err;
629 }
630 
631 static int kirkwood_i2s_dev_remove(struct platform_device *pdev)
632 {
633         struct kirkwood_dma_data *priv = dev_get_drvdata(&pdev->dev);
634 
635         snd_soc_unregister_platform(&pdev->dev);
636         snd_soc_unregister_component(&pdev->dev);
637 
638         if (!IS_ERR(priv->extclk))
639                 clk_disable_unprepare(priv->extclk);
640         clk_disable_unprepare(priv->clk);
641 
642         return 0;
643 }
644 
645 #ifdef CONFIG_OF
646 static struct of_device_id mvebu_audio_of_match[] = {
647         { .compatible = "marvell,kirkwood-audio" },
648         { .compatible = "marvell,dove-audio" },
649         { .compatible = "marvell,armada370-audio" },
650         { }
651 };
652 MODULE_DEVICE_TABLE(of, mvebu_audio_of_match);
653 #endif
654 
655 static struct platform_driver kirkwood_i2s_driver = {
656         .probe  = kirkwood_i2s_dev_probe,
657         .remove = kirkwood_i2s_dev_remove,
658         .driver = {
659                 .name = DRV_NAME,
660                 .owner = THIS_MODULE,
661                 .of_match_table = of_match_ptr(mvebu_audio_of_match),
662         },
663 };
664 
665 module_platform_driver(kirkwood_i2s_driver);
666 
667 /* Module information */
668 MODULE_AUTHOR("Arnaud Patard, <arnaud.patard@rtp-net.org>");
669 MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
670 MODULE_LICENSE("GPL");
671 MODULE_ALIAS("platform:mvebu-audio");
672 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us