Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 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

Linux/sound/soc/codecs/ad1980.c

  1 /*
  2  * ad1980.c  --  ALSA Soc AD1980 codec support
  3  *
  4  * Copyright:   Analog Device Inc.
  5  * Author:      Roy Huang <roy.huang@analog.com>
  6  *              Cliff Cai <cliff.cai@analog.com>
  7  *
  8  *  This program is free software; you can redistribute  it and/or modify it
  9  *  under  the terms of  the GNU General  Public License as published by the
 10  *  Free Software Foundation;  either version 2 of the  License, or (at your
 11  *  option) any later version.
 12  */
 13 
 14 /*
 15  * WARNING:
 16  *
 17  * Because Analog Devices Inc. discontinued the ad1980 sound chip since
 18  * Sep. 2009, this ad1980 driver is not maintained, tested and supported
 19  * by ADI now.
 20  */
 21 
 22 #include <linux/init.h>
 23 #include <linux/slab.h>
 24 #include <linux/module.h>
 25 #include <linux/kernel.h>
 26 #include <linux/device.h>
 27 #include <sound/core.h>
 28 #include <sound/pcm.h>
 29 #include <sound/ac97_codec.h>
 30 #include <sound/initval.h>
 31 #include <sound/soc.h>
 32 
 33 #include "ad1980.h"
 34 
 35 /*
 36  * AD1980 register cache
 37  */
 38 static const u16 ad1980_reg[] = {
 39         0x0090, 0x8000, 0x8000, 0x8000, /* 0 - 6  */
 40         0x0000, 0x0000, 0x8008, 0x8008, /* 8 - e  */
 41         0x8808, 0x8808, 0x0000, 0x8808, /* 10 - 16 */
 42         0x8808, 0x0000, 0x8000, 0x0000, /* 18 - 1e */
 43         0x0000, 0x0000, 0x0000, 0x0000, /* 20 - 26 */
 44         0x03c7, 0x0000, 0xbb80, 0xbb80, /* 28 - 2e */
 45         0xbb80, 0xbb80, 0x0000, 0x8080, /* 30 - 36 */
 46         0x8080, 0x2000, 0x0000, 0x0000, /* 38 - 3e */
 47         0x0000, 0x0000, 0x0000, 0x0000, /* reserved */
 48         0x0000, 0x0000, 0x0000, 0x0000, /* reserved */
 49         0x0000, 0x0000, 0x0000, 0x0000, /* reserved */
 50         0x0000, 0x0000, 0x0000, 0x0000, /* reserved */
 51         0x8080, 0x0000, 0x0000, 0x0000, /* 60 - 66 */
 52         0x0000, 0x0000, 0x0000, 0x0000, /* reserved */
 53         0x0000, 0x0000, 0x1001, 0x0000, /* 70 - 76 */
 54         0x0000, 0x0000, 0x4144, 0x5370  /* 78 - 7e */
 55 };
 56 
 57 static const char *ad1980_rec_sel[] = {"Mic", "CD", "NC", "AUX", "Line",
 58                 "Stereo Mix", "Mono Mix", "Phone"};
 59 
 60 static SOC_ENUM_DOUBLE_DECL(ad1980_cap_src,
 61                             AC97_REC_SEL, 8, 0, ad1980_rec_sel);
 62 
 63 static const struct snd_kcontrol_new ad1980_snd_ac97_controls[] = {
 64 SOC_DOUBLE("Master Playback Volume", AC97_MASTER, 8, 0, 31, 1),
 65 SOC_SINGLE("Master Playback Switch", AC97_MASTER, 15, 1, 1),
 66 
 67 SOC_DOUBLE("Headphone Playback Volume", AC97_HEADPHONE, 8, 0, 31, 1),
 68 SOC_SINGLE("Headphone Playback Switch", AC97_HEADPHONE, 15, 1, 1),
 69 
 70 SOC_DOUBLE("PCM Playback Volume", AC97_PCM, 8, 0, 31, 1),
 71 SOC_SINGLE("PCM Playback Switch", AC97_PCM, 15, 1, 1),
 72 
 73 SOC_DOUBLE("PCM Capture Volume", AC97_REC_GAIN, 8, 0, 31, 0),
 74 SOC_SINGLE("PCM Capture Switch", AC97_REC_GAIN, 15, 1, 1),
 75 
 76 SOC_SINGLE("Mono Playback Volume", AC97_MASTER_MONO, 0, 31, 1),
 77 SOC_SINGLE("Mono Playback Switch", AC97_MASTER_MONO, 15, 1, 1),
 78 
 79 SOC_SINGLE("Phone Capture Volume", AC97_PHONE, 0, 31, 1),
 80 SOC_SINGLE("Phone Capture Switch", AC97_PHONE, 15, 1, 1),
 81 
 82 SOC_SINGLE("Mic Volume", AC97_MIC, 0, 31, 1),
 83 SOC_SINGLE("Mic Switch", AC97_MIC, 15, 1, 1),
 84 
 85 SOC_SINGLE("Stereo Mic Switch", AC97_AD_MISC, 6, 1, 0),
 86 SOC_DOUBLE("Line HP Swap Switch", AC97_AD_MISC, 10, 5, 1, 0),
 87 
 88 SOC_DOUBLE("Surround Playback Volume", AC97_SURROUND_MASTER, 8, 0, 31, 1),
 89 SOC_DOUBLE("Surround Playback Switch", AC97_SURROUND_MASTER, 15, 7, 1, 1),
 90 
 91 SOC_DOUBLE("Center/LFE Playback Volume", AC97_CENTER_LFE_MASTER, 8, 0, 31, 1),
 92 SOC_DOUBLE("Center/LFE Playback Switch", AC97_CENTER_LFE_MASTER, 15, 7, 1, 1),
 93 
 94 SOC_ENUM("Capture Source", ad1980_cap_src),
 95 
 96 SOC_SINGLE("Mic Boost Switch", AC97_MIC, 6, 1, 0),
 97 };
 98 
 99 static const struct snd_soc_dapm_widget ad1980_dapm_widgets[] = {
100 SND_SOC_DAPM_INPUT("MIC1"),
101 SND_SOC_DAPM_INPUT("MIC2"),
102 SND_SOC_DAPM_INPUT("CD_L"),
103 SND_SOC_DAPM_INPUT("CD_R"),
104 SND_SOC_DAPM_INPUT("AUX_L"),
105 SND_SOC_DAPM_INPUT("AUX_R"),
106 SND_SOC_DAPM_INPUT("LINE_IN_L"),
107 SND_SOC_DAPM_INPUT("LINE_IN_R"),
108 
109 SND_SOC_DAPM_OUTPUT("LFE_OUT"),
110 SND_SOC_DAPM_OUTPUT("CENTER_OUT"),
111 SND_SOC_DAPM_OUTPUT("LINE_OUT_L"),
112 SND_SOC_DAPM_OUTPUT("LINE_OUT_R"),
113 SND_SOC_DAPM_OUTPUT("MONO_OUT"),
114 SND_SOC_DAPM_OUTPUT("HP_OUT_L"),
115 SND_SOC_DAPM_OUTPUT("HP_OUT_R"),
116 };
117 
118 static const struct snd_soc_dapm_route ad1980_dapm_routes[] = {
119         { "Capture", NULL, "MIC1" },
120         { "Capture", NULL, "MIC2" },
121         { "Capture", NULL, "CD_L" },
122         { "Capture", NULL, "CD_R" },
123         { "Capture", NULL, "AUX_L" },
124         { "Capture", NULL, "AUX_R" },
125         { "Capture", NULL, "LINE_IN_L" },
126         { "Capture", NULL, "LINE_IN_R" },
127 
128         { "LFE_OUT", NULL, "Playback" },
129         { "CENTER_OUT", NULL, "Playback" },
130         { "LINE_OUT_L", NULL, "Playback" },
131         { "LINE_OUT_R", NULL, "Playback" },
132         { "MONO_OUT", NULL, "Playback" },
133         { "HP_OUT_L", NULL, "Playback" },
134         { "HP_OUT_R", NULL, "Playback" },
135 };
136 
137 static unsigned int ac97_read(struct snd_soc_codec *codec,
138         unsigned int reg)
139 {
140         u16 *cache = codec->reg_cache;
141 
142         switch (reg) {
143         case AC97_RESET:
144         case AC97_INT_PAGING:
145         case AC97_POWERDOWN:
146         case AC97_EXTENDED_STATUS:
147         case AC97_VENDOR_ID1:
148         case AC97_VENDOR_ID2:
149                 return soc_ac97_ops->read(codec->ac97, reg);
150         default:
151                 reg = reg >> 1;
152 
153                 if (reg >= ARRAY_SIZE(ad1980_reg))
154                         return -EINVAL;
155 
156                 return cache[reg];
157         }
158 }
159 
160 static int ac97_write(struct snd_soc_codec *codec, unsigned int reg,
161         unsigned int val)
162 {
163         u16 *cache = codec->reg_cache;
164 
165         soc_ac97_ops->write(codec->ac97, reg, val);
166         reg = reg >> 1;
167         if (reg < ARRAY_SIZE(ad1980_reg))
168                 cache[reg] = val;
169 
170         return 0;
171 }
172 
173 static struct snd_soc_dai_driver ad1980_dai = {
174         .name = "ad1980-hifi",
175         .ac97_control = 1,
176         .playback = {
177                 .stream_name = "Playback",
178                 .channels_min = 2,
179                 .channels_max = 6,
180                 .rates = SNDRV_PCM_RATE_48000,
181                 .formats = SND_SOC_STD_AC97_FMTS, },
182         .capture = {
183                 .stream_name = "Capture",
184                 .channels_min = 2,
185                 .channels_max = 2,
186                 .rates = SNDRV_PCM_RATE_48000,
187                 .formats = SND_SOC_STD_AC97_FMTS, },
188 };
189 
190 static int ad1980_reset(struct snd_soc_codec *codec, int try_warm)
191 {
192         u16 retry_cnt = 0;
193 
194 retry:
195         if (try_warm && soc_ac97_ops->warm_reset) {
196                 soc_ac97_ops->warm_reset(codec->ac97);
197                 if (ac97_read(codec, AC97_RESET) == 0x0090)
198                         return 1;
199         }
200 
201         soc_ac97_ops->reset(codec->ac97);
202         /* Set bit 16slot in register 74h, then every slot will has only 16
203          * bits. This command is sent out in 20bit mode, in which case the
204          * first nibble of data is eaten by the addr. (Tag is always 16 bit)*/
205         ac97_write(codec, AC97_AD_SERIAL_CFG, 0x9900);
206 
207         if (ac97_read(codec, AC97_RESET)  != 0x0090)
208                 goto err;
209         return 0;
210 
211 err:
212         while (retry_cnt++ < 10)
213                 goto retry;
214 
215         printk(KERN_ERR "AD1980 AC97 reset failed\n");
216         return -EIO;
217 }
218 
219 static int ad1980_soc_probe(struct snd_soc_codec *codec)
220 {
221         int ret;
222         u16 vendor_id2;
223         u16 ext_status;
224 
225         printk(KERN_INFO "AD1980 SoC Audio Codec\n");
226 
227         ret = snd_soc_new_ac97_codec(codec, soc_ac97_ops, 0);
228         if (ret < 0) {
229                 printk(KERN_ERR "ad1980: failed to register AC97 codec\n");
230                 return ret;
231         }
232 
233         ret = ad1980_reset(codec, 0);
234         if (ret < 0) {
235                 printk(KERN_ERR "Failed to reset AD1980: AC97 link error\n");
236                 goto reset_err;
237         }
238 
239         /* Read out vendor ID to make sure it is ad1980 */
240         if (ac97_read(codec, AC97_VENDOR_ID1) != 0x4144) {
241                 ret = -ENODEV;
242                 goto reset_err;
243         }
244 
245         vendor_id2 = ac97_read(codec, AC97_VENDOR_ID2);
246 
247         if (vendor_id2 != 0x5370) {
248                 if (vendor_id2 != 0x5374) {
249                         ret = -ENODEV;
250                         goto reset_err;
251                 } else {
252                         printk(KERN_WARNING "ad1980: "
253                                 "Found AD1981 - only 2/2 IN/OUT Channels "
254                                 "supported\n");
255                 }
256         }
257 
258         /* unmute captures and playbacks volume */
259         ac97_write(codec, AC97_MASTER, 0x0000);
260         ac97_write(codec, AC97_PCM, 0x0000);
261         ac97_write(codec, AC97_REC_GAIN, 0x0000);
262         ac97_write(codec, AC97_CENTER_LFE_MASTER, 0x0000);
263         ac97_write(codec, AC97_SURROUND_MASTER, 0x0000);
264 
265         /*power on LFE/CENTER/Surround DACs*/
266         ext_status = ac97_read(codec, AC97_EXTENDED_STATUS);
267         ac97_write(codec, AC97_EXTENDED_STATUS, ext_status&~0x3800);
268 
269         snd_soc_add_codec_controls(codec, ad1980_snd_ac97_controls,
270                                 ARRAY_SIZE(ad1980_snd_ac97_controls));
271 
272         return 0;
273 
274 reset_err:
275         snd_soc_free_ac97_codec(codec);
276         return ret;
277 }
278 
279 static int ad1980_soc_remove(struct snd_soc_codec *codec)
280 {
281         snd_soc_free_ac97_codec(codec);
282         return 0;
283 }
284 
285 static struct snd_soc_codec_driver soc_codec_dev_ad1980 = {
286         .probe =        ad1980_soc_probe,
287         .remove =       ad1980_soc_remove,
288         .reg_cache_size = ARRAY_SIZE(ad1980_reg),
289         .reg_word_size = sizeof(u16),
290         .reg_cache_default = ad1980_reg,
291         .reg_cache_step = 2,
292         .write = ac97_write,
293         .read = ac97_read,
294 
295         .dapm_widgets = ad1980_dapm_widgets,
296         .num_dapm_widgets = ARRAY_SIZE(ad1980_dapm_widgets),
297         .dapm_routes = ad1980_dapm_routes,
298         .num_dapm_routes = ARRAY_SIZE(ad1980_dapm_routes),
299 };
300 
301 static int ad1980_probe(struct platform_device *pdev)
302 {
303         return snd_soc_register_codec(&pdev->dev,
304                         &soc_codec_dev_ad1980, &ad1980_dai, 1);
305 }
306 
307 static int ad1980_remove(struct platform_device *pdev)
308 {
309         snd_soc_unregister_codec(&pdev->dev);
310         return 0;
311 }
312 
313 static struct platform_driver ad1980_codec_driver = {
314         .driver = {
315                         .name = "ad1980",
316                         .owner = THIS_MODULE,
317         },
318 
319         .probe = ad1980_probe,
320         .remove = ad1980_remove,
321 };
322 
323 module_platform_driver(ad1980_codec_driver);
324 
325 MODULE_DESCRIPTION("ASoC ad1980 driver (Obsolete)");
326 MODULE_AUTHOR("Roy Huang, Cliff Cai");
327 MODULE_LICENSE("GPL");
328 

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