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

TOMOYO Linux Cross Reference
Linux/sound/soc/au1x/psc-ac97.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  * Au12x0/Au1550 PSC ALSA ASoC audio support.
  3  *
  4  * (c) 2007-2009 MSC Vertriebsges.m.b.H.,
  5  *      Manuel Lauss <manuel.lauss@gmail.com>
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License version 2 as
  9  * published by the Free Software Foundation.
 10  *
 11  * Au1xxx-PSC AC97 glue.
 12  *
 13  */
 14 
 15 #include <linux/init.h>
 16 #include <linux/module.h>
 17 #include <linux/slab.h>
 18 #include <linux/device.h>
 19 #include <linux/delay.h>
 20 #include <linux/mutex.h>
 21 #include <linux/suspend.h>
 22 #include <sound/core.h>
 23 #include <sound/pcm.h>
 24 #include <sound/initval.h>
 25 #include <sound/soc.h>
 26 #include <asm/mach-au1x00/au1000.h>
 27 #include <asm/mach-au1x00/au1xxx_psc.h>
 28 
 29 #include "psc.h"
 30 
 31 /* how often to retry failed codec register reads/writes */
 32 #define AC97_RW_RETRIES 5
 33 
 34 #define AC97_DIR        \
 35         (SND_SOC_DAIDIR_PLAYBACK | SND_SOC_DAIDIR_CAPTURE)
 36 
 37 #define AC97_RATES      \
 38         SNDRV_PCM_RATE_8000_48000
 39 
 40 #define AC97_FMTS       \
 41         (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3BE)
 42 
 43 #define AC97PCR_START(stype)    \
 44         ((stype) == SNDRV_PCM_STREAM_PLAYBACK ? PSC_AC97PCR_TS : PSC_AC97PCR_RS)
 45 #define AC97PCR_STOP(stype)     \
 46         ((stype) == SNDRV_PCM_STREAM_PLAYBACK ? PSC_AC97PCR_TP : PSC_AC97PCR_RP)
 47 #define AC97PCR_CLRFIFO(stype)  \
 48         ((stype) == SNDRV_PCM_STREAM_PLAYBACK ? PSC_AC97PCR_TC : PSC_AC97PCR_RC)
 49 
 50 #define AC97STAT_BUSY(stype)    \
 51         ((stype) == SNDRV_PCM_STREAM_PLAYBACK ? PSC_AC97STAT_TB : PSC_AC97STAT_RB)
 52 
 53 /* instance data. There can be only one, MacLeod!!!! */
 54 static struct au1xpsc_audio_data *au1xpsc_ac97_workdata;
 55 
 56 #if 0
 57 
 58 /* this could theoretically work, but ac97->bus->card->private_data can be NULL
 59  * when snd_ac97_mixer() is called; I don't know if the rest further down the
 60  * chain are always valid either.
 61  */
 62 static inline struct au1xpsc_audio_data *ac97_to_pscdata(struct snd_ac97 *x)
 63 {
 64         struct snd_soc_card *c = x->bus->card->private_data;
 65         return snd_soc_dai_get_drvdata(c->rtd->cpu_dai);
 66 }
 67 
 68 #else
 69 
 70 #define ac97_to_pscdata(x)      au1xpsc_ac97_workdata
 71 
 72 #endif
 73 
 74 /* AC97 controller reads codec register */
 75 static unsigned short au1xpsc_ac97_read(struct snd_ac97 *ac97,
 76                                         unsigned short reg)
 77 {
 78         struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
 79         unsigned short retry, tmo;
 80         unsigned long data;
 81 
 82         au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
 83         au_sync();
 84 
 85         retry = AC97_RW_RETRIES;
 86         do {
 87                 mutex_lock(&pscdata->lock);
 88 
 89                 au_writel(PSC_AC97CDC_RD | PSC_AC97CDC_INDX(reg),
 90                           AC97_CDC(pscdata));
 91                 au_sync();
 92 
 93                 tmo = 20;
 94                 do {
 95                         udelay(21);
 96                         if (au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD)
 97                                 break;
 98                 } while (--tmo);
 99 
100                 data = au_readl(AC97_CDC(pscdata));
101 
102                 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
103                 au_sync();
104 
105                 mutex_unlock(&pscdata->lock);
106 
107                 if (reg != ((data >> 16) & 0x7f))
108                         tmo = 1;        /* wrong register, try again */
109 
110         } while (--retry && !tmo);
111 
112         return retry ? data & 0xffff : 0xffff;
113 }
114 
115 /* AC97 controller writes to codec register */
116 static void au1xpsc_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
117                                 unsigned short val)
118 {
119         struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
120         unsigned int tmo, retry;
121 
122         au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
123         au_sync();
124 
125         retry = AC97_RW_RETRIES;
126         do {
127                 mutex_lock(&pscdata->lock);
128 
129                 au_writel(PSC_AC97CDC_INDX(reg) | (val & 0xffff),
130                           AC97_CDC(pscdata));
131                 au_sync();
132 
133                 tmo = 20;
134                 do {
135                         udelay(21);
136                         if (au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD)
137                                 break;
138                 } while (--tmo);
139 
140                 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
141                 au_sync();
142 
143                 mutex_unlock(&pscdata->lock);
144         } while (--retry && !tmo);
145 }
146 
147 /* AC97 controller asserts a warm reset */
148 static void au1xpsc_ac97_warm_reset(struct snd_ac97 *ac97)
149 {
150         struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
151 
152         au_writel(PSC_AC97RST_SNC, AC97_RST(pscdata));
153         au_sync();
154         msleep(10);
155         au_writel(0, AC97_RST(pscdata));
156         au_sync();
157 }
158 
159 static void au1xpsc_ac97_cold_reset(struct snd_ac97 *ac97)
160 {
161         struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
162         int i;
163 
164         /* disable PSC during cold reset */
165         au_writel(0, AC97_CFG(au1xpsc_ac97_workdata));
166         au_sync();
167         au_writel(PSC_CTRL_DISABLE, PSC_CTRL(pscdata));
168         au_sync();
169 
170         /* issue cold reset */
171         au_writel(PSC_AC97RST_RST, AC97_RST(pscdata));
172         au_sync();
173         msleep(500);
174         au_writel(0, AC97_RST(pscdata));
175         au_sync();
176 
177         /* enable PSC */
178         au_writel(PSC_CTRL_ENABLE, PSC_CTRL(pscdata));
179         au_sync();
180 
181         /* wait for PSC to indicate it's ready */
182         i = 1000;
183         while (!((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_SR)) && (--i))
184                 msleep(1);
185 
186         if (i == 0) {
187                 printk(KERN_ERR "au1xpsc-ac97: PSC not ready!\n");
188                 return;
189         }
190 
191         /* enable the ac97 function */
192         au_writel(pscdata->cfg | PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
193         au_sync();
194 
195         /* wait for AC97 core to become ready */
196         i = 1000;
197         while (!((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR)) && (--i))
198                 msleep(1);
199         if (i == 0)
200                 printk(KERN_ERR "au1xpsc-ac97: AC97 ctrl not ready\n");
201 }
202 
203 /* AC97 controller operations */
204 struct snd_ac97_bus_ops soc_ac97_ops = {
205         .read           = au1xpsc_ac97_read,
206         .write          = au1xpsc_ac97_write,
207         .reset          = au1xpsc_ac97_cold_reset,
208         .warm_reset     = au1xpsc_ac97_warm_reset,
209 };
210 EXPORT_SYMBOL_GPL(soc_ac97_ops);
211 
212 static int au1xpsc_ac97_hw_params(struct snd_pcm_substream *substream,
213                                   struct snd_pcm_hw_params *params,
214                                   struct snd_soc_dai *dai)
215 {
216         struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai);
217         unsigned long r, ro, stat;
218         int chans, t, stype = substream->stream;
219 
220         chans = params_channels(params);
221 
222         r = ro = au_readl(AC97_CFG(pscdata));
223         stat = au_readl(AC97_STAT(pscdata));
224 
225         /* already active? */
226         if (stat & (PSC_AC97STAT_TB | PSC_AC97STAT_RB)) {
227                 /* reject parameters not currently set up */
228                 if ((PSC_AC97CFG_GET_LEN(r) != params->msbits) ||
229                     (pscdata->rate != params_rate(params)))
230                         return -EINVAL;
231         } else {
232 
233                 /* set sample bitdepth: REG[24:21]=(BITS-2)/2 */
234                 r &= ~PSC_AC97CFG_LEN_MASK;
235                 r |= PSC_AC97CFG_SET_LEN(params->msbits);
236 
237                 /* channels: enable slots for front L/R channel */
238                 if (stype == SNDRV_PCM_STREAM_PLAYBACK) {
239                         r &= ~PSC_AC97CFG_TXSLOT_MASK;
240                         r |= PSC_AC97CFG_TXSLOT_ENA(3);
241                         r |= PSC_AC97CFG_TXSLOT_ENA(4);
242                 } else {
243                         r &= ~PSC_AC97CFG_RXSLOT_MASK;
244                         r |= PSC_AC97CFG_RXSLOT_ENA(3);
245                         r |= PSC_AC97CFG_RXSLOT_ENA(4);
246                 }
247 
248                 /* do we need to poke the hardware? */
249                 if (!(r ^ ro))
250                         goto out;
251 
252                 /* ac97 engine is about to be disabled */
253                 mutex_lock(&pscdata->lock);
254 
255                 /* disable AC97 device controller first... */
256                 au_writel(r & ~PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
257                 au_sync();
258 
259                 /* ...wait for it... */
260                 t = 100;
261                 while ((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR) && --t)
262                         msleep(1);
263 
264                 if (!t)
265                         printk(KERN_ERR "PSC-AC97: can't disable!\n");
266 
267                 /* ...write config... */
268                 au_writel(r, AC97_CFG(pscdata));
269                 au_sync();
270 
271                 /* ...enable the AC97 controller again... */
272                 au_writel(r | PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
273                 au_sync();
274 
275                 /* ...and wait for ready bit */
276                 t = 100;
277                 while ((!(au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR)) && --t)
278                         msleep(1);
279 
280                 if (!t)
281                         printk(KERN_ERR "PSC-AC97: can't enable!\n");
282 
283                 mutex_unlock(&pscdata->lock);
284 
285                 pscdata->cfg = r;
286                 pscdata->rate = params_rate(params);
287         }
288 
289 out:
290         return 0;
291 }
292 
293 static int au1xpsc_ac97_trigger(struct snd_pcm_substream *substream,
294                                 int cmd, struct snd_soc_dai *dai)
295 {
296         struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai);
297         int ret, stype = substream->stream;
298 
299         ret = 0;
300 
301         switch (cmd) {
302         case SNDRV_PCM_TRIGGER_START:
303         case SNDRV_PCM_TRIGGER_RESUME:
304                 au_writel(AC97PCR_CLRFIFO(stype), AC97_PCR(pscdata));
305                 au_sync();
306                 au_writel(AC97PCR_START(stype), AC97_PCR(pscdata));
307                 au_sync();
308                 break;
309         case SNDRV_PCM_TRIGGER_STOP:
310         case SNDRV_PCM_TRIGGER_SUSPEND:
311                 au_writel(AC97PCR_STOP(stype), AC97_PCR(pscdata));
312                 au_sync();
313 
314                 while (au_readl(AC97_STAT(pscdata)) & AC97STAT_BUSY(stype))
315                         asm volatile ("nop");
316 
317                 au_writel(AC97PCR_CLRFIFO(stype), AC97_PCR(pscdata));
318                 au_sync();
319 
320                 break;
321         default:
322                 ret = -EINVAL;
323         }
324         return ret;
325 }
326 
327 static int au1xpsc_ac97_startup(struct snd_pcm_substream *substream,
328                                 struct snd_soc_dai *dai)
329 {
330         struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai);
331         snd_soc_dai_set_dma_data(dai, substream, &pscdata->dmaids[0]);
332         return 0;
333 }
334 
335 static int au1xpsc_ac97_probe(struct snd_soc_dai *dai)
336 {
337         return au1xpsc_ac97_workdata ? 0 : -ENODEV;
338 }
339 
340 static const struct snd_soc_dai_ops au1xpsc_ac97_dai_ops = {
341         .startup        = au1xpsc_ac97_startup,
342         .trigger        = au1xpsc_ac97_trigger,
343         .hw_params      = au1xpsc_ac97_hw_params,
344 };
345 
346 static const struct snd_soc_dai_driver au1xpsc_ac97_dai_template = {
347         .ac97_control           = 1,
348         .probe                  = au1xpsc_ac97_probe,
349         .playback = {
350                 .rates          = AC97_RATES,
351                 .formats        = AC97_FMTS,
352                 .channels_min   = 2,
353                 .channels_max   = 2,
354         },
355         .capture = {
356                 .rates          = AC97_RATES,
357                 .formats        = AC97_FMTS,
358                 .channels_min   = 2,
359                 .channels_max   = 2,
360         },
361         .ops = &au1xpsc_ac97_dai_ops,
362 };
363 
364 static const struct snd_soc_component_driver au1xpsc_ac97_component = {
365         .name           = "au1xpsc-ac97",
366 };
367 
368 static int au1xpsc_ac97_drvprobe(struct platform_device *pdev)
369 {
370         int ret;
371         struct resource *iores, *dmares;
372         unsigned long sel;
373         struct au1xpsc_audio_data *wd;
374 
375         wd = devm_kzalloc(&pdev->dev, sizeof(struct au1xpsc_audio_data),
376                           GFP_KERNEL);
377         if (!wd)
378                 return -ENOMEM;
379 
380         mutex_init(&wd->lock);
381 
382         iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
383         if (!iores)
384                 return -ENODEV;
385 
386         if (!devm_request_mem_region(&pdev->dev, iores->start,
387                                      resource_size(iores),
388                                      pdev->name))
389                 return -EBUSY;
390 
391         wd->mmio = devm_ioremap(&pdev->dev, iores->start,
392                                 resource_size(iores));
393         if (!wd->mmio)
394                 return -EBUSY;
395 
396         dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0);
397         if (!dmares)
398                 return -EBUSY;
399         wd->dmaids[SNDRV_PCM_STREAM_PLAYBACK] = dmares->start;
400 
401         dmares = platform_get_resource(pdev, IORESOURCE_DMA, 1);
402         if (!dmares)
403                 return -EBUSY;
404         wd->dmaids[SNDRV_PCM_STREAM_CAPTURE] = dmares->start;
405 
406         /* configuration: max dma trigger threshold, enable ac97 */
407         wd->cfg = PSC_AC97CFG_RT_FIFO8 | PSC_AC97CFG_TT_FIFO8 |
408                   PSC_AC97CFG_DE_ENABLE;
409 
410         /* preserve PSC clock source set up by platform  */
411         sel = au_readl(PSC_SEL(wd)) & PSC_SEL_CLK_MASK;
412         au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
413         au_sync();
414         au_writel(0, PSC_SEL(wd));
415         au_sync();
416         au_writel(PSC_SEL_PS_AC97MODE | sel, PSC_SEL(wd));
417         au_sync();
418 
419         /* name the DAI like this device instance ("au1xpsc-ac97.PSCINDEX") */
420         memcpy(&wd->dai_drv, &au1xpsc_ac97_dai_template,
421                sizeof(struct snd_soc_dai_driver));
422         wd->dai_drv.name = dev_name(&pdev->dev);
423 
424         platform_set_drvdata(pdev, wd);
425 
426         ret = snd_soc_register_component(&pdev->dev, &au1xpsc_ac97_component,
427                                          &wd->dai_drv, 1);
428         if (ret)
429                 return ret;
430 
431         au1xpsc_ac97_workdata = wd;
432         return 0;
433 }
434 
435 static int au1xpsc_ac97_drvremove(struct platform_device *pdev)
436 {
437         struct au1xpsc_audio_data *wd = platform_get_drvdata(pdev);
438 
439         snd_soc_unregister_component(&pdev->dev);
440 
441         /* disable PSC completely */
442         au_writel(0, AC97_CFG(wd));
443         au_sync();
444         au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
445         au_sync();
446 
447         au1xpsc_ac97_workdata = NULL;   /* MDEV */
448 
449         return 0;
450 }
451 
452 #ifdef CONFIG_PM
453 static int au1xpsc_ac97_drvsuspend(struct device *dev)
454 {
455         struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
456 
457         /* save interesting registers and disable PSC */
458         wd->pm[0] = au_readl(PSC_SEL(wd));
459 
460         au_writel(0, AC97_CFG(wd));
461         au_sync();
462         au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
463         au_sync();
464 
465         return 0;
466 }
467 
468 static int au1xpsc_ac97_drvresume(struct device *dev)
469 {
470         struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
471 
472         /* restore PSC clock config */
473         au_writel(wd->pm[0] | PSC_SEL_PS_AC97MODE, PSC_SEL(wd));
474         au_sync();
475 
476         /* after this point the ac97 core will cold-reset the codec.
477          * During cold-reset the PSC is reinitialized and the last
478          * configuration set up in hw_params() is restored.
479          */
480         return 0;
481 }
482 
483 static struct dev_pm_ops au1xpscac97_pmops = {
484         .suspend        = au1xpsc_ac97_drvsuspend,
485         .resume         = au1xpsc_ac97_drvresume,
486 };
487 
488 #define AU1XPSCAC97_PMOPS &au1xpscac97_pmops
489 
490 #else
491 
492 #define AU1XPSCAC97_PMOPS NULL
493 
494 #endif
495 
496 static struct platform_driver au1xpsc_ac97_driver = {
497         .driver = {
498                 .name   = "au1xpsc_ac97",
499                 .owner  = THIS_MODULE,
500                 .pm     = AU1XPSCAC97_PMOPS,
501         },
502         .probe          = au1xpsc_ac97_drvprobe,
503         .remove         = au1xpsc_ac97_drvremove,
504 };
505 
506 static int __init au1xpsc_ac97_load(void)
507 {
508         au1xpsc_ac97_workdata = NULL;
509         return platform_driver_register(&au1xpsc_ac97_driver);
510 }
511 
512 static void __exit au1xpsc_ac97_unload(void)
513 {
514         platform_driver_unregister(&au1xpsc_ac97_driver);
515 }
516 
517 module_init(au1xpsc_ac97_load);
518 module_exit(au1xpsc_ac97_unload);
519 
520 MODULE_LICENSE("GPL");
521 MODULE_DESCRIPTION("Au12x0/Au1550 PSC AC97 ALSA ASoC audio driver");
522 MODULE_AUTHOR("Manuel Lauss");
523 
524 

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