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/arm/pxa2xx-ac97.c

  1 /*
  2  * linux/sound/pxa2xx-ac97.c -- AC97 support for the Intel PXA2xx chip.
  3  *
  4  * Author:      Nicolas Pitre
  5  * Created:     Dec 02, 2004
  6  * Copyright:   MontaVista Software Inc.
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License version 2 as
 10  * published by the Free Software Foundation.
 11  */
 12 
 13 #include <linux/init.h>
 14 #include <linux/io.h>
 15 #include <linux/module.h>
 16 #include <linux/platform_device.h>
 17 #include <linux/dmaengine.h>
 18 
 19 #include <sound/core.h>
 20 #include <sound/pcm.h>
 21 #include <sound/ac97_codec.h>
 22 #include <sound/initval.h>
 23 #include <sound/pxa2xx-lib.h>
 24 #include <sound/dmaengine_pcm.h>
 25 
 26 #include <mach/regs-ac97.h>
 27 #include <mach/audio.h>
 28 
 29 #include "pxa2xx-pcm.h"
 30 
 31 static void pxa2xx_ac97_reset(struct snd_ac97 *ac97)
 32 {
 33         if (!pxa2xx_ac97_try_cold_reset(ac97)) {
 34                 pxa2xx_ac97_try_warm_reset(ac97);
 35         }
 36 
 37         pxa2xx_ac97_finish_reset(ac97);
 38 }
 39 
 40 static struct snd_ac97_bus_ops pxa2xx_ac97_ops = {
 41         .read   = pxa2xx_ac97_read,
 42         .write  = pxa2xx_ac97_write,
 43         .reset  = pxa2xx_ac97_reset,
 44 };
 45 
 46 static unsigned long pxa2xx_ac97_pcm_out_req = 12;
 47 static struct snd_dmaengine_dai_dma_data pxa2xx_ac97_pcm_out = {
 48         .addr           = __PREG(PCDR),
 49         .addr_width     = DMA_SLAVE_BUSWIDTH_4_BYTES,
 50         .maxburst       = 32,
 51         .filter_data    = &pxa2xx_ac97_pcm_out_req,
 52 };
 53 
 54 static unsigned long pxa2xx_ac97_pcm_in_req = 11;
 55 static struct snd_dmaengine_dai_dma_data pxa2xx_ac97_pcm_in = {
 56         .addr           = __PREG(PCDR),
 57         .addr_width     = DMA_SLAVE_BUSWIDTH_4_BYTES,
 58         .maxburst       = 32,
 59         .filter_data    = &pxa2xx_ac97_pcm_in_req,
 60 };
 61 
 62 static struct snd_pcm *pxa2xx_ac97_pcm;
 63 static struct snd_ac97 *pxa2xx_ac97_ac97;
 64 
 65 static int pxa2xx_ac97_pcm_startup(struct snd_pcm_substream *substream)
 66 {
 67         struct snd_pcm_runtime *runtime = substream->runtime;
 68         pxa2xx_audio_ops_t *platform_ops;
 69         int r;
 70 
 71         runtime->hw.channels_min = 2;
 72         runtime->hw.channels_max = 2;
 73 
 74         r = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
 75             AC97_RATES_FRONT_DAC : AC97_RATES_ADC;
 76         runtime->hw.rates = pxa2xx_ac97_ac97->rates[r];
 77         snd_pcm_limit_hw_rates(runtime);
 78 
 79         platform_ops = substream->pcm->card->dev->platform_data;
 80         if (platform_ops && platform_ops->startup)
 81                 return platform_ops->startup(substream, platform_ops->priv);
 82         else
 83                 return 0;
 84 }
 85 
 86 static void pxa2xx_ac97_pcm_shutdown(struct snd_pcm_substream *substream)
 87 {
 88         pxa2xx_audio_ops_t *platform_ops;
 89 
 90         platform_ops = substream->pcm->card->dev->platform_data;
 91         if (platform_ops && platform_ops->shutdown)
 92                 platform_ops->shutdown(substream, platform_ops->priv);
 93 }
 94 
 95 static int pxa2xx_ac97_pcm_prepare(struct snd_pcm_substream *substream)
 96 {
 97         struct snd_pcm_runtime *runtime = substream->runtime;
 98         int reg = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
 99                   AC97_PCM_FRONT_DAC_RATE : AC97_PCM_LR_ADC_RATE;
100         return snd_ac97_set_rate(pxa2xx_ac97_ac97, reg, runtime->rate);
101 }
102 
103 static struct pxa2xx_pcm_client pxa2xx_ac97_pcm_client = {
104         .playback_params        = &pxa2xx_ac97_pcm_out,
105         .capture_params         = &pxa2xx_ac97_pcm_in,
106         .startup                = pxa2xx_ac97_pcm_startup,
107         .shutdown               = pxa2xx_ac97_pcm_shutdown,
108         .prepare                = pxa2xx_ac97_pcm_prepare,
109 };
110 
111 #ifdef CONFIG_PM_SLEEP
112 
113 static int pxa2xx_ac97_do_suspend(struct snd_card *card)
114 {
115         pxa2xx_audio_ops_t *platform_ops = card->dev->platform_data;
116 
117         snd_power_change_state(card, SNDRV_CTL_POWER_D3cold);
118         snd_pcm_suspend_all(pxa2xx_ac97_pcm);
119         snd_ac97_suspend(pxa2xx_ac97_ac97);
120         if (platform_ops && platform_ops->suspend)
121                 platform_ops->suspend(platform_ops->priv);
122 
123         return pxa2xx_ac97_hw_suspend();
124 }
125 
126 static int pxa2xx_ac97_do_resume(struct snd_card *card)
127 {
128         pxa2xx_audio_ops_t *platform_ops = card->dev->platform_data;
129         int rc;
130 
131         rc = pxa2xx_ac97_hw_resume();
132         if (rc)
133                 return rc;
134 
135         if (platform_ops && platform_ops->resume)
136                 platform_ops->resume(platform_ops->priv);
137         snd_ac97_resume(pxa2xx_ac97_ac97);
138         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
139 
140         return 0;
141 }
142 
143 static int pxa2xx_ac97_suspend(struct device *dev)
144 {
145         struct snd_card *card = dev_get_drvdata(dev);
146         int ret = 0;
147 
148         if (card)
149                 ret = pxa2xx_ac97_do_suspend(card);
150 
151         return ret;
152 }
153 
154 static int pxa2xx_ac97_resume(struct device *dev)
155 {
156         struct snd_card *card = dev_get_drvdata(dev);
157         int ret = 0;
158 
159         if (card)
160                 ret = pxa2xx_ac97_do_resume(card);
161 
162         return ret;
163 }
164 
165 static SIMPLE_DEV_PM_OPS(pxa2xx_ac97_pm_ops, pxa2xx_ac97_suspend, pxa2xx_ac97_resume);
166 #endif
167 
168 static int pxa2xx_ac97_probe(struct platform_device *dev)
169 {
170         struct snd_card *card;
171         struct snd_ac97_bus *ac97_bus;
172         struct snd_ac97_template ac97_template;
173         int ret;
174         pxa2xx_audio_ops_t *pdata = dev->dev.platform_data;
175 
176         if (dev->id >= 0) {
177                 dev_err(&dev->dev, "PXA2xx has only one AC97 port.\n");
178                 ret = -ENXIO;
179                 goto err_dev;
180         }
181 
182         ret = snd_card_new(&dev->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
183                            THIS_MODULE, 0, &card);
184         if (ret < 0)
185                 goto err;
186 
187         strlcpy(card->driver, dev->dev.driver->name, sizeof(card->driver));
188 
189         ret = pxa2xx_pcm_new(card, &pxa2xx_ac97_pcm_client, &pxa2xx_ac97_pcm);
190         if (ret)
191                 goto err;
192 
193         ret = pxa2xx_ac97_hw_probe(dev);
194         if (ret)
195                 goto err;
196 
197         ret = snd_ac97_bus(card, 0, &pxa2xx_ac97_ops, NULL, &ac97_bus);
198         if (ret)
199                 goto err_remove;
200         memset(&ac97_template, 0, sizeof(ac97_template));
201         ret = snd_ac97_mixer(ac97_bus, &ac97_template, &pxa2xx_ac97_ac97);
202         if (ret)
203                 goto err_remove;
204 
205         snprintf(card->shortname, sizeof(card->shortname),
206                  "%s", snd_ac97_get_short_name(pxa2xx_ac97_ac97));
207         snprintf(card->longname, sizeof(card->longname),
208                  "%s (%s)", dev->dev.driver->name, card->mixername);
209 
210         if (pdata && pdata->codec_pdata[0])
211                 snd_ac97_dev_add_pdata(ac97_bus->codec[0], pdata->codec_pdata[0]);
212         ret = snd_card_register(card);
213         if (ret == 0) {
214                 platform_set_drvdata(dev, card);
215                 return 0;
216         }
217 
218 err_remove:
219         pxa2xx_ac97_hw_remove(dev);
220 err:
221         if (card)
222                 snd_card_free(card);
223 err_dev:
224         return ret;
225 }
226 
227 static int pxa2xx_ac97_remove(struct platform_device *dev)
228 {
229         struct snd_card *card = platform_get_drvdata(dev);
230 
231         if (card) {
232                 snd_card_free(card);
233                 pxa2xx_ac97_hw_remove(dev);
234         }
235 
236         return 0;
237 }
238 
239 static struct platform_driver pxa2xx_ac97_driver = {
240         .probe          = pxa2xx_ac97_probe,
241         .remove         = pxa2xx_ac97_remove,
242         .driver         = {
243                 .name   = "pxa2xx-ac97",
244                 .owner  = THIS_MODULE,
245 #ifdef CONFIG_PM_SLEEP
246                 .pm     = &pxa2xx_ac97_pm_ops,
247 #endif
248         },
249 };
250 
251 module_platform_driver(pxa2xx_ac97_driver);
252 
253 MODULE_AUTHOR("Nicolas Pitre");
254 MODULE_DESCRIPTION("AC97 driver for the Intel PXA2xx chip");
255 MODULE_LICENSE("GPL");
256 MODULE_ALIAS("platform:pxa2xx-ac97");
257 

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