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/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         unsigned int retry_cnt = 0;
193 
194         do {
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                 /*
203                  * Set bit 16slot in register 74h, then every slot will has only
204                  * 16 bits. This command is sent out in 20bit mode, in which
205                  * case the first nibble of data is eaten by the addr. (Tag is
206                  * always 16 bit)
207                  */
208                 ac97_write(codec, AC97_AD_SERIAL_CFG, 0x9900);
209 
210                 if (ac97_read(codec, AC97_RESET)  == 0x0090)
211                         return 0;
212         } while (retry_cnt++ < 10);
213 
214         printk(KERN_ERR "AD1980 AC97 reset failed\n");
215         return -EIO;
216 }
217 
218 static int ad1980_soc_probe(struct snd_soc_codec *codec)
219 {
220         int ret;
221         u16 vendor_id2;
222         u16 ext_status;
223 
224         printk(KERN_INFO "AD1980 SoC Audio Codec\n");
225 
226         ret = snd_soc_new_ac97_codec(codec, soc_ac97_ops, 0);
227         if (ret < 0) {
228                 printk(KERN_ERR "ad1980: failed to register AC97 codec\n");
229                 return ret;
230         }
231 
232         ret = ad1980_reset(codec, 0);
233         if (ret < 0) {
234                 printk(KERN_ERR "Failed to reset AD1980: AC97 link error\n");
235                 goto reset_err;
236         }
237 
238         /* Read out vendor ID to make sure it is ad1980 */
239         if (ac97_read(codec, AC97_VENDOR_ID1) != 0x4144) {
240                 ret = -ENODEV;
241                 goto reset_err;
242         }
243 
244         vendor_id2 = ac97_read(codec, AC97_VENDOR_ID2);
245 
246         if (vendor_id2 != 0x5370) {
247                 if (vendor_id2 != 0x5374) {
248                         ret = -ENODEV;
249                         goto reset_err;
250                 } else {
251                         printk(KERN_WARNING "ad1980: "
252                                 "Found AD1981 - only 2/2 IN/OUT Channels "
253                                 "supported\n");
254                 }
255         }
256 
257         /* unmute captures and playbacks volume */
258         ac97_write(codec, AC97_MASTER, 0x0000);
259         ac97_write(codec, AC97_PCM, 0x0000);
260         ac97_write(codec, AC97_REC_GAIN, 0x0000);
261         ac97_write(codec, AC97_CENTER_LFE_MASTER, 0x0000);
262         ac97_write(codec, AC97_SURROUND_MASTER, 0x0000);
263 
264         /*power on LFE/CENTER/Surround DACs*/
265         ext_status = ac97_read(codec, AC97_EXTENDED_STATUS);
266         ac97_write(codec, AC97_EXTENDED_STATUS, ext_status&~0x3800);
267 
268         snd_soc_add_codec_controls(codec, ad1980_snd_ac97_controls,
269                                 ARRAY_SIZE(ad1980_snd_ac97_controls));
270 
271         return 0;
272 
273 reset_err:
274         snd_soc_free_ac97_codec(codec);
275         return ret;
276 }
277 
278 static int ad1980_soc_remove(struct snd_soc_codec *codec)
279 {
280         snd_soc_free_ac97_codec(codec);
281         return 0;
282 }
283 
284 static struct snd_soc_codec_driver soc_codec_dev_ad1980 = {
285         .probe =        ad1980_soc_probe,
286         .remove =       ad1980_soc_remove,
287         .reg_cache_size = ARRAY_SIZE(ad1980_reg),
288         .reg_word_size = sizeof(u16),
289         .reg_cache_default = ad1980_reg,
290         .reg_cache_step = 2,
291         .write = ac97_write,
292         .read = ac97_read,
293 
294         .dapm_widgets = ad1980_dapm_widgets,
295         .num_dapm_widgets = ARRAY_SIZE(ad1980_dapm_widgets),
296         .dapm_routes = ad1980_dapm_routes,
297         .num_dapm_routes = ARRAY_SIZE(ad1980_dapm_routes),
298 };
299 
300 static int ad1980_probe(struct platform_device *pdev)
301 {
302         return snd_soc_register_codec(&pdev->dev,
303                         &soc_codec_dev_ad1980, &ad1980_dai, 1);
304 }
305 
306 static int ad1980_remove(struct platform_device *pdev)
307 {
308         snd_soc_unregister_codec(&pdev->dev);
309         return 0;
310 }
311 
312 static struct platform_driver ad1980_codec_driver = {
313         .driver = {
314                         .name = "ad1980",
315                         .owner = THIS_MODULE,
316         },
317 
318         .probe = ad1980_probe,
319         .remove = ad1980_remove,
320 };
321 
322 module_platform_driver(ad1980_codec_driver);
323 
324 MODULE_DESCRIPTION("ASoC ad1980 driver (Obsolete)");
325 MODULE_AUTHOR("Roy Huang, Cliff Cai");
326 MODULE_LICENSE("GPL");
327 

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