Version:  2.0.40 2.2.26 2.4.37 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6

Linux/sound/soc/codecs/stac9766.c

  1 /*
  2  * stac9766.c  --  ALSA SoC STAC9766 codec support
  3  *
  4  * Copyright 2009 Jon Smirl, Digispeaker
  5  * Author: Jon Smirl <jonsmirl@gmail.com>
  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  *  Features:-
 13  *
 14  *   o Support for AC97 Codec, S/PDIF
 15  */
 16 
 17 #include <linux/init.h>
 18 #include <linux/slab.h>
 19 #include <linux/module.h>
 20 #include <linux/device.h>
 21 #include <sound/core.h>
 22 #include <sound/pcm.h>
 23 #include <sound/ac97_codec.h>
 24 #include <sound/initval.h>
 25 #include <sound/pcm_params.h>
 26 #include <sound/soc.h>
 27 #include <sound/tlv.h>
 28 
 29 #include "stac9766.h"
 30 
 31 #define STAC9766_VENDOR_ID 0x83847666
 32 #define STAC9766_VENDOR_ID_MASK 0xffffffff
 33 
 34 /*
 35  * STAC9766 register cache
 36  */
 37 static const u16 stac9766_reg[] = {
 38         0x6A90, 0x8000, 0x8000, 0x8000, /* 6 */
 39         0x0000, 0x0000, 0x8008, 0x8008, /* e */
 40         0x8808, 0x8808, 0x8808, 0x8808, /* 16 */
 41         0x8808, 0x0000, 0x8000, 0x0000, /* 1e */
 42         0x0000, 0x0000, 0x0000, 0x000f, /* 26 */
 43         0x0a05, 0x0400, 0xbb80, 0x0000, /* 2e */
 44         0x0000, 0xbb80, 0x0000, 0x0000, /* 36 */
 45         0x0000, 0x2000, 0x0000, 0x0100, /* 3e */
 46         0x0000, 0x0000, 0x0080, 0x0000, /* 46 */
 47         0x0000, 0x0000, 0x0003, 0xffff, /* 4e */
 48         0x0000, 0x0000, 0x0000, 0x0000, /* 56 */
 49         0x4000, 0x0000, 0x0000, 0x0000, /* 5e */
 50         0x1201, 0xFFFF, 0xFFFF, 0x0000, /* 66 */
 51         0x0000, 0x0000, 0x0000, 0x0000, /* 6e */
 52         0x0000, 0x0000, 0x0000, 0x0006, /* 76 */
 53         0x0000, 0x0000, 0x0000, 0x0000, /* 7e */
 54 };
 55 
 56 static const char *stac9766_record_mux[] = {"Mic", "CD", "Video", "AUX",
 57                         "Line", "Stereo Mix", "Mono Mix", "Phone"};
 58 static const char *stac9766_mono_mux[] = {"Mix", "Mic"};
 59 static const char *stac9766_mic_mux[] = {"Mic1", "Mic2"};
 60 static const char *stac9766_SPDIF_mux[] = {"PCM", "ADC Record"};
 61 static const char *stac9766_popbypass_mux[] = {"Normal", "Bypass Mixer"};
 62 static const char *stac9766_record_all_mux[] = {"All analog",
 63         "Analog plus DAC"};
 64 static const char *stac9766_boost1[] = {"0dB", "10dB"};
 65 static const char *stac9766_boost2[] = {"0dB", "20dB"};
 66 static const char *stac9766_stereo_mic[] = {"Off", "On"};
 67 
 68 static SOC_ENUM_DOUBLE_DECL(stac9766_record_enum,
 69                             AC97_REC_SEL, 8, 0, stac9766_record_mux);
 70 static SOC_ENUM_SINGLE_DECL(stac9766_mono_enum,
 71                             AC97_GENERAL_PURPOSE, 9, stac9766_mono_mux);
 72 static SOC_ENUM_SINGLE_DECL(stac9766_mic_enum,
 73                             AC97_GENERAL_PURPOSE, 8, stac9766_mic_mux);
 74 static SOC_ENUM_SINGLE_DECL(stac9766_SPDIF_enum,
 75                             AC97_STAC_DA_CONTROL, 1, stac9766_SPDIF_mux);
 76 static SOC_ENUM_SINGLE_DECL(stac9766_popbypass_enum,
 77                             AC97_GENERAL_PURPOSE, 15, stac9766_popbypass_mux);
 78 static SOC_ENUM_SINGLE_DECL(stac9766_record_all_enum,
 79                             AC97_STAC_ANALOG_SPECIAL, 12,
 80                             stac9766_record_all_mux);
 81 static SOC_ENUM_SINGLE_DECL(stac9766_boost1_enum,
 82                             AC97_MIC, 6, stac9766_boost1); /* 0/10dB */
 83 static SOC_ENUM_SINGLE_DECL(stac9766_boost2_enum,
 84                             AC97_STAC_ANALOG_SPECIAL, 2, stac9766_boost2); /* 0/20dB */
 85 static SOC_ENUM_SINGLE_DECL(stac9766_stereo_mic_enum,
 86                             AC97_STAC_STEREO_MIC, 2, stac9766_stereo_mic);
 87 
 88 static const DECLARE_TLV_DB_LINEAR(master_tlv, -4600, 0);
 89 static const DECLARE_TLV_DB_LINEAR(record_tlv, 0, 2250);
 90 static const DECLARE_TLV_DB_LINEAR(beep_tlv, -4500, 0);
 91 static const DECLARE_TLV_DB_LINEAR(mix_tlv, -3450, 1200);
 92 
 93 static const struct snd_kcontrol_new stac9766_snd_ac97_controls[] = {
 94         SOC_DOUBLE_TLV("Speaker Volume", AC97_MASTER, 8, 0, 31, 1, master_tlv),
 95         SOC_SINGLE("Speaker Switch", AC97_MASTER, 15, 1, 1),
 96         SOC_DOUBLE_TLV("Headphone Volume", AC97_HEADPHONE, 8, 0, 31, 1,
 97                        master_tlv),
 98         SOC_SINGLE("Headphone Switch", AC97_HEADPHONE, 15, 1, 1),
 99         SOC_SINGLE_TLV("Mono Out Volume", AC97_MASTER_MONO, 0, 31, 1,
100                        master_tlv),
101         SOC_SINGLE("Mono Out Switch", AC97_MASTER_MONO, 15, 1, 1),
102 
103         SOC_DOUBLE_TLV("Record Volume", AC97_REC_GAIN, 8, 0, 15, 0, record_tlv),
104         SOC_SINGLE("Record Switch", AC97_REC_GAIN, 15, 1, 1),
105 
106 
107         SOC_SINGLE_TLV("Beep Volume", AC97_PC_BEEP, 1, 15, 1, beep_tlv),
108         SOC_SINGLE("Beep Switch", AC97_PC_BEEP, 15, 1, 1),
109         SOC_SINGLE("Beep Frequency", AC97_PC_BEEP, 5, 127, 1),
110         SOC_SINGLE_TLV("Phone Volume", AC97_PHONE, 0, 31, 1, mix_tlv),
111         SOC_SINGLE("Phone Switch", AC97_PHONE, 15, 1, 1),
112 
113         SOC_ENUM("Mic Boost1", stac9766_boost1_enum),
114         SOC_ENUM("Mic Boost2", stac9766_boost2_enum),
115         SOC_SINGLE_TLV("Mic Volume", AC97_MIC, 0, 31, 1, mix_tlv),
116         SOC_SINGLE("Mic Switch", AC97_MIC, 15, 1, 1),
117         SOC_ENUM("Stereo Mic", stac9766_stereo_mic_enum),
118 
119         SOC_DOUBLE_TLV("Line Volume", AC97_LINE, 8, 0, 31, 1, mix_tlv),
120         SOC_SINGLE("Line Switch", AC97_LINE, 15, 1, 1),
121         SOC_DOUBLE_TLV("CD Volume", AC97_CD, 8, 0, 31, 1, mix_tlv),
122         SOC_SINGLE("CD Switch", AC97_CD, 15, 1, 1),
123         SOC_DOUBLE_TLV("AUX Volume", AC97_AUX, 8, 0, 31, 1, mix_tlv),
124         SOC_SINGLE("AUX Switch", AC97_AUX, 15, 1, 1),
125         SOC_DOUBLE_TLV("Video Volume", AC97_VIDEO, 8, 0, 31, 1, mix_tlv),
126         SOC_SINGLE("Video Switch", AC97_VIDEO, 15, 1, 1),
127 
128         SOC_DOUBLE_TLV("DAC Volume", AC97_PCM, 8, 0, 31, 1, mix_tlv),
129         SOC_SINGLE("DAC Switch", AC97_PCM, 15, 1, 1),
130         SOC_SINGLE("Loopback Test Switch", AC97_GENERAL_PURPOSE, 7, 1, 0),
131         SOC_SINGLE("3D Volume", AC97_3D_CONTROL, 3, 2, 1),
132         SOC_SINGLE("3D Switch", AC97_GENERAL_PURPOSE, 13, 1, 0),
133 
134         SOC_ENUM("SPDIF Mux", stac9766_SPDIF_enum),
135         SOC_ENUM("Mic1/2 Mux", stac9766_mic_enum),
136         SOC_ENUM("Record All Mux", stac9766_record_all_enum),
137         SOC_ENUM("Record Mux", stac9766_record_enum),
138         SOC_ENUM("Mono Mux", stac9766_mono_enum),
139         SOC_ENUM("Pop Bypass Mux", stac9766_popbypass_enum),
140 };
141 
142 static int stac9766_ac97_write(struct snd_soc_codec *codec, unsigned int reg,
143                                unsigned int val)
144 {
145         struct snd_ac97 *ac97 = snd_soc_codec_get_drvdata(codec);
146         u16 *cache = codec->reg_cache;
147 
148         if (reg > AC97_STAC_PAGE0) {
149                 stac9766_ac97_write(codec, AC97_INT_PAGING, 0);
150                 soc_ac97_ops->write(ac97, reg, val);
151                 stac9766_ac97_write(codec, AC97_INT_PAGING, 1);
152                 return 0;
153         }
154         if (reg / 2 >= ARRAY_SIZE(stac9766_reg))
155                 return -EIO;
156 
157         soc_ac97_ops->write(ac97, reg, val);
158         cache[reg / 2] = val;
159         return 0;
160 }
161 
162 static unsigned int stac9766_ac97_read(struct snd_soc_codec *codec,
163                                        unsigned int reg)
164 {
165         struct snd_ac97 *ac97 = snd_soc_codec_get_drvdata(codec);
166         u16 val = 0, *cache = codec->reg_cache;
167 
168         if (reg > AC97_STAC_PAGE0) {
169                 stac9766_ac97_write(codec, AC97_INT_PAGING, 0);
170                 val = soc_ac97_ops->read(ac97, reg - AC97_STAC_PAGE0);
171                 stac9766_ac97_write(codec, AC97_INT_PAGING, 1);
172                 return val;
173         }
174         if (reg / 2 >= ARRAY_SIZE(stac9766_reg))
175                 return -EIO;
176 
177         if (reg == AC97_RESET || reg == AC97_GPIO_STATUS ||
178                 reg == AC97_INT_PAGING || reg == AC97_VENDOR_ID1 ||
179                 reg == AC97_VENDOR_ID2) {
180 
181                 val = soc_ac97_ops->read(ac97, reg);
182                 return val;
183         }
184         return cache[reg / 2];
185 }
186 
187 static int ac97_analog_prepare(struct snd_pcm_substream *substream,
188                                struct snd_soc_dai *dai)
189 {
190         struct snd_soc_codec *codec = dai->codec;
191         struct snd_pcm_runtime *runtime = substream->runtime;
192         unsigned short reg, vra;
193 
194         vra = stac9766_ac97_read(codec, AC97_EXTENDED_STATUS);
195 
196         vra |= 0x1; /* enable variable rate audio */
197         vra &= ~0x4; /* disable SPDIF output */
198 
199         stac9766_ac97_write(codec, AC97_EXTENDED_STATUS, vra);
200 
201         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
202                 reg = AC97_PCM_FRONT_DAC_RATE;
203         else
204                 reg = AC97_PCM_LR_ADC_RATE;
205 
206         return stac9766_ac97_write(codec, reg, runtime->rate);
207 }
208 
209 static int ac97_digital_prepare(struct snd_pcm_substream *substream,
210                                 struct snd_soc_dai *dai)
211 {
212         struct snd_soc_codec *codec = dai->codec;
213         struct snd_pcm_runtime *runtime = substream->runtime;
214         unsigned short reg, vra;
215 
216         stac9766_ac97_write(codec, AC97_SPDIF, 0x2002);
217 
218         vra = stac9766_ac97_read(codec, AC97_EXTENDED_STATUS);
219         vra |= 0x5; /* Enable VRA and SPDIF out */
220 
221         stac9766_ac97_write(codec, AC97_EXTENDED_STATUS, vra);
222 
223         reg = AC97_PCM_FRONT_DAC_RATE;
224 
225         return stac9766_ac97_write(codec, reg, runtime->rate);
226 }
227 
228 static int stac9766_set_bias_level(struct snd_soc_codec *codec,
229                                    enum snd_soc_bias_level level)
230 {
231         switch (level) {
232         case SND_SOC_BIAS_ON: /* full On */
233         case SND_SOC_BIAS_PREPARE: /* partial On */
234         case SND_SOC_BIAS_STANDBY: /* Off, with power */
235                 stac9766_ac97_write(codec, AC97_POWERDOWN, 0x0000);
236                 break;
237         case SND_SOC_BIAS_OFF: /* Off, without power */
238                 /* disable everything including AC link */
239                 stac9766_ac97_write(codec, AC97_POWERDOWN, 0xffff);
240                 break;
241         }
242         return 0;
243 }
244 
245 static int stac9766_codec_resume(struct snd_soc_codec *codec)
246 {
247         struct snd_ac97 *ac97 = snd_soc_codec_get_drvdata(codec);
248 
249         return snd_ac97_reset(ac97, true, STAC9766_VENDOR_ID,
250                 STAC9766_VENDOR_ID_MASK);
251 }
252 
253 static const struct snd_soc_dai_ops stac9766_dai_ops_analog = {
254         .prepare = ac97_analog_prepare,
255 };
256 
257 static const struct snd_soc_dai_ops stac9766_dai_ops_digital = {
258         .prepare = ac97_digital_prepare,
259 };
260 
261 static struct snd_soc_dai_driver stac9766_dai[] = {
262 {
263         .name = "stac9766-hifi-analog",
264 
265         /* stream cababilities */
266         .playback = {
267                 .stream_name = "stac9766 analog",
268                 .channels_min = 1,
269                 .channels_max = 2,
270                 .rates = SNDRV_PCM_RATE_8000_48000,
271                 .formats = SND_SOC_STD_AC97_FMTS,
272         },
273         .capture = {
274                 .stream_name = "stac9766 analog",
275                 .channels_min = 1,
276                 .channels_max = 2,
277                 .rates = SNDRV_PCM_RATE_8000_48000,
278                 .formats = SND_SOC_STD_AC97_FMTS,
279         },
280         /* alsa ops */
281         .ops = &stac9766_dai_ops_analog,
282 },
283 {
284         .name = "stac9766-hifi-IEC958",
285 
286         /* stream cababilities */
287         .playback = {
288                 .stream_name = "stac9766 IEC958",
289                 .channels_min = 1,
290                 .channels_max = 2,
291                 .rates = SNDRV_PCM_RATE_32000 | \
292                         SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
293                 .formats = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
294         },
295         /* alsa ops */
296         .ops = &stac9766_dai_ops_digital,
297 }
298 };
299 
300 static int stac9766_codec_probe(struct snd_soc_codec *codec)
301 {
302         struct snd_ac97 *ac97;
303 
304         ac97 = snd_soc_new_ac97_codec(codec, STAC9766_VENDOR_ID,
305                         STAC9766_VENDOR_ID_MASK);
306         if (IS_ERR(ac97))
307                 return PTR_ERR(ac97);
308 
309         snd_soc_codec_set_drvdata(codec, ac97);
310 
311         return 0;
312 }
313 
314 static int stac9766_codec_remove(struct snd_soc_codec *codec)
315 {
316         struct snd_ac97 *ac97 = snd_soc_codec_get_drvdata(codec);
317 
318         snd_soc_free_ac97_codec(ac97);
319         return 0;
320 }
321 
322 static struct snd_soc_codec_driver soc_codec_dev_stac9766 = {
323         .controls = stac9766_snd_ac97_controls,
324         .num_controls = ARRAY_SIZE(stac9766_snd_ac97_controls),
325         .write = stac9766_ac97_write,
326         .read = stac9766_ac97_read,
327         .set_bias_level = stac9766_set_bias_level,
328         .suspend_bias_off = true,
329         .probe = stac9766_codec_probe,
330         .remove = stac9766_codec_remove,
331         .resume = stac9766_codec_resume,
332         .reg_cache_size = ARRAY_SIZE(stac9766_reg),
333         .reg_word_size = sizeof(u16),
334         .reg_cache_step = 2,
335         .reg_cache_default = stac9766_reg,
336 };
337 
338 static int stac9766_probe(struct platform_device *pdev)
339 {
340         return snd_soc_register_codec(&pdev->dev,
341                         &soc_codec_dev_stac9766, stac9766_dai, ARRAY_SIZE(stac9766_dai));
342 }
343 
344 static int stac9766_remove(struct platform_device *pdev)
345 {
346         snd_soc_unregister_codec(&pdev->dev);
347         return 0;
348 }
349 
350 static struct platform_driver stac9766_codec_driver = {
351         .driver = {
352                         .name = "stac9766-codec",
353         },
354 
355         .probe = stac9766_probe,
356         .remove = stac9766_remove,
357 };
358 
359 module_platform_driver(stac9766_codec_driver);
360 
361 MODULE_DESCRIPTION("ASoC stac9766 driver");
362 MODULE_AUTHOR("Jon Smirl <jonsmirl@gmail.com>");
363 MODULE_LICENSE("GPL");
364 

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