aboutsummaryrefslogtreecommitdiffstats
path: root/sound/pci/ac97
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /sound/pci/ac97
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'sound/pci/ac97')
-rw-r--r--sound/pci/ac97/Makefile18
-rw-r--r--sound/pci/ac97/ac97_codec.c2579
-rw-r--r--sound/pci/ac97/ac97_id.h62
-rw-r--r--sound/pci/ac97/ac97_local.h83
-rw-r--r--sound/pci/ac97/ac97_patch.c2309
-rw-r--r--sound/pci/ac97/ac97_patch.h59
-rw-r--r--sound/pci/ac97/ac97_pcm.c700
-rw-r--r--sound/pci/ac97/ac97_proc.c449
-rw-r--r--sound/pci/ac97/ak4531_codec.c437
9 files changed, 6696 insertions, 0 deletions
diff --git a/sound/pci/ac97/Makefile b/sound/pci/ac97/Makefile
new file mode 100644
index 000000000000..3c3222122d8b
--- /dev/null
+++ b/sound/pci/ac97/Makefile
@@ -0,0 +1,18 @@
1#
2# Makefile for ALSA
3# Copyright (c) 2001 by Jaroslav Kysela <perex@suse.cz>
4#
5
6snd-ac97-codec-objs := ac97_codec.o ac97_pcm.o ac97_patch.o
7
8ifneq ($(CONFIG_PROC_FS),)
9snd-ac97-codec-objs += ac97_proc.o
10endif
11
12snd-ak4531-codec-objs := ak4531_codec.o
13
14# Toplevel Module Dependency
15obj-$(CONFIG_SND_AC97_CODEC) += snd-ac97-codec.o
16obj-$(CONFIG_SND_ENS1370) += snd-ak4531-codec.o
17
18obj-m := $(sort $(obj-m))
diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
new file mode 100644
index 000000000000..0b024ec1f709
--- /dev/null
+++ b/sound/pci/ac97/ac97_codec.c
@@ -0,0 +1,2579 @@
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Universal interface for Audio Codec '97
4 *
5 * For more details look to AC '97 component specification revision 2.2
6 * by Intel Corporation (http://developer.intel.com).
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 */
24
25#include <sound/driver.h>
26#include <linux/delay.h>
27#include <linux/init.h>
28#include <linux/slab.h>
29#include <linux/pci.h>
30#include <linux/moduleparam.h>
31#include <sound/core.h>
32#include <sound/pcm.h>
33#include <sound/ac97_codec.h>
34#include <sound/asoundef.h>
35#include <sound/initval.h>
36#include "ac97_local.h"
37#include "ac97_id.h"
38#include "ac97_patch.h"
39
40MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
41MODULE_DESCRIPTION("Universal interface for Audio Codec '97");
42MODULE_LICENSE("GPL");
43
44static int enable_loopback;
45
46module_param(enable_loopback, bool, 0444);
47MODULE_PARM_DESC(enable_loopback, "Enable AC97 ADC/DAC Loopback Control");
48
49/*
50
51 */
52
53typedef struct {
54 unsigned int id;
55 unsigned int mask;
56 const char *name;
57 int (*patch)(ac97_t *ac97);
58 int (*mpatch)(ac97_t *ac97);
59 unsigned int flags;
60} ac97_codec_id_t;
61
62static const ac97_codec_id_t snd_ac97_codec_id_vendors[] = {
63{ 0x414b4d00, 0xffffff00, "Asahi Kasei", NULL, NULL },
64{ 0x41445300, 0xffffff00, "Analog Devices", NULL, NULL },
65{ 0x414c4300, 0xffffff00, "Realtek", NULL, NULL },
66{ 0x414c4700, 0xffffff00, "Realtek", NULL, NULL },
67{ 0x434d4900, 0xffffff00, "C-Media Electronics", NULL, NULL },
68{ 0x43525900, 0xffffff00, "Cirrus Logic", NULL, NULL },
69{ 0x43585400, 0xffffff00, "Conexant", NULL, NULL },
70{ 0x44543000, 0xffffff00, "Diamond Technology", NULL, NULL },
71{ 0x454d4300, 0xffffff00, "eMicro", NULL, NULL },
72{ 0x45838300, 0xffffff00, "ESS Technology", NULL, NULL },
73{ 0x48525300, 0xffffff00, "Intersil", NULL, NULL },
74{ 0x49434500, 0xffffff00, "ICEnsemble", NULL, NULL },
75{ 0x49544500, 0xffffff00, "ITE Tech.Inc", NULL, NULL },
76{ 0x4e534300, 0xffffff00, "National Semiconductor", NULL, NULL },
77{ 0x50534300, 0xffffff00, "Philips", NULL, NULL },
78{ 0x53494c00, 0xffffff00, "Silicon Laboratory", NULL, NULL },
79{ 0x54524100, 0xffffff00, "TriTech", NULL, NULL },
80{ 0x54584e00, 0xffffff00, "Texas Instruments", NULL, NULL },
81{ 0x56494100, 0xffffff00, "VIA Technologies", NULL, NULL },
82{ 0x57454300, 0xffffff00, "Winbond", NULL, NULL },
83{ 0x574d4c00, 0xffffff00, "Wolfson", NULL, NULL },
84{ 0x594d4800, 0xffffff00, "Yamaha", NULL, NULL },
85{ 0x83847600, 0xffffff00, "SigmaTel", NULL, NULL },
86{ 0, 0, NULL, NULL, NULL }
87};
88
89static const ac97_codec_id_t snd_ac97_codec_ids[] = {
90{ 0x414b4d00, 0xffffffff, "AK4540", NULL, NULL },
91{ 0x414b4d01, 0xffffffff, "AK4542", NULL, NULL },
92{ 0x414b4d02, 0xffffffff, "AK4543", NULL, NULL },
93{ 0x414b4d06, 0xffffffff, "AK4544A", NULL, NULL },
94{ 0x414b4d07, 0xffffffff, "AK4545", NULL, NULL },
95{ 0x41445303, 0xffffffff, "AD1819", patch_ad1819, NULL },
96{ 0x41445340, 0xffffffff, "AD1881", patch_ad1881, NULL },
97{ 0x41445348, 0xffffffff, "AD1881A", patch_ad1881, NULL },
98{ 0x41445360, 0xffffffff, "AD1885", patch_ad1885, NULL },
99{ 0x41445361, 0xffffffff, "AD1886", patch_ad1886, NULL },
100{ 0x41445362, 0xffffffff, "AD1887", patch_ad1881, NULL },
101{ 0x41445363, 0xffffffff, "AD1886A", patch_ad1881, NULL },
102{ 0x41445368, 0xffffffff, "AD1888", patch_ad1888, NULL },
103{ 0x41445370, 0xffffffff, "AD1980", patch_ad1980, NULL },
104{ 0x41445372, 0xffffffff, "AD1981A", patch_ad1981a, NULL },
105{ 0x41445374, 0xffffffff, "AD1981B", patch_ad1981b, NULL },
106{ 0x41445375, 0xffffffff, "AD1985", patch_ad1985, NULL },
107{ 0x41445378, 0xffffffff, "AD1986", patch_ad1985, NULL },
108{ 0x414c4300, 0xffffff00, "ALC100,100P", NULL, NULL },
109{ 0x414c4710, 0xfffffff0, "ALC200,200P", NULL, NULL },
110{ 0x414c4721, 0xffffffff, "ALC650D", NULL, NULL }, /* already patched */
111{ 0x414c4722, 0xffffffff, "ALC650E", NULL, NULL }, /* already patched */
112{ 0x414c4723, 0xffffffff, "ALC650F", NULL, NULL }, /* already patched */
113{ 0x414c4720, 0xfffffff0, "ALC650", patch_alc650, NULL },
114{ 0x414c4760, 0xfffffff0, "ALC655", patch_alc655, NULL },
115{ 0x414c4780, 0xfffffff0, "ALC658", patch_alc655, NULL },
116{ 0x414c4790, 0xfffffff0, "ALC850", patch_alc850, NULL },
117{ 0x414c4730, 0xffffffff, "ALC101", NULL, NULL },
118{ 0x414c4740, 0xfffffff0, "ALC202", NULL, NULL },
119{ 0x414c4750, 0xfffffff0, "ALC250", NULL, NULL },
120{ 0x414c4770, 0xfffffff0, "ALC203", NULL, NULL },
121{ 0x434d4941, 0xffffffff, "CMI9738", patch_cm9738, NULL },
122{ 0x434d4961, 0xffffffff, "CMI9739", patch_cm9739, NULL },
123{ 0x434d4978, 0xffffffff, "CMI9761", patch_cm9761, NULL },
124{ 0x434d4982, 0xffffffff, "CMI9761", patch_cm9761, NULL },
125{ 0x434d4983, 0xffffffff, "CMI9761", patch_cm9761, NULL },
126{ 0x43525900, 0xfffffff8, "CS4297", NULL, NULL },
127{ 0x43525910, 0xfffffff8, "CS4297A", patch_cirrus_spdif, NULL },
128{ 0x43525920, 0xfffffff8, "CS4298", patch_cirrus_spdif, NULL },
129{ 0x43525928, 0xfffffff8, "CS4294", NULL, NULL },
130{ 0x43525930, 0xfffffff8, "CS4299", patch_cirrus_cs4299, NULL },
131{ 0x43525948, 0xfffffff8, "CS4201", NULL, NULL },
132{ 0x43525958, 0xfffffff8, "CS4205", patch_cirrus_spdif, NULL },
133{ 0x43525960, 0xfffffff8, "CS4291", NULL, NULL },
134{ 0x43525970, 0xfffffff8, "CS4202", NULL, NULL },
135{ 0x43585421, 0xffffffff, "HSD11246", NULL, NULL }, // SmartMC II
136{ 0x43585428, 0xfffffff8, "Cx20468", patch_conexant, NULL }, // SmartAMC fixme: the mask might be different
137{ 0x44543031, 0xfffffff0, "DT0398", NULL, NULL },
138{ 0x454d4328, 0xffffffff, "28028", NULL, NULL }, // same as TR28028?
139{ 0x45838308, 0xffffffff, "ESS1988", NULL, NULL },
140{ 0x48525300, 0xffffff00, "HMP9701", NULL, NULL },
141{ 0x49434501, 0xffffffff, "ICE1230", NULL, NULL },
142{ 0x49434511, 0xffffffff, "ICE1232", NULL, NULL }, // alias VIA VT1611A?
143{ 0x49434514, 0xffffffff, "ICE1232A", NULL, NULL },
144{ 0x49434551, 0xffffffff, "VT1616", patch_vt1616, NULL },
145{ 0x49434552, 0xffffffff, "VT1616i", patch_vt1616, NULL }, // VT1616 compatible (chipset integrated)
146{ 0x49544520, 0xffffffff, "IT2226E", NULL, NULL },
147{ 0x49544561, 0xffffffff, "IT2646E", patch_it2646, NULL },
148{ 0x4e534300, 0xffffffff, "LM4540,43,45,46,48", NULL, NULL }, // only guess --jk
149{ 0x4e534331, 0xffffffff, "LM4549", NULL, NULL },
150{ 0x4e534350, 0xffffffff, "LM4550", NULL, NULL },
151{ 0x50534304, 0xffffffff, "UCB1400", NULL, NULL },
152{ 0x53494c20, 0xffffffe0, "Si3036,8", NULL, mpatch_si3036 },
153{ 0x54524102, 0xffffffff, "TR28022", NULL, NULL },
154{ 0x54524106, 0xffffffff, "TR28026", NULL, NULL },
155{ 0x54524108, 0xffffffff, "TR28028", patch_tritech_tr28028, NULL }, // added by xin jin [07/09/99]
156{ 0x54524123, 0xffffffff, "TR28602", NULL, NULL }, // only guess --jk [TR28023 = eMicro EM28023 (new CT1297)]
157{ 0x54584e20, 0xffffffff, "TLC320AD9xC", NULL, NULL },
158{ 0x56494161, 0xffffffff, "VIA1612A", NULL, NULL }, // modified ICE1232 with S/PDIF
159{ 0x57454301, 0xffffffff, "W83971D", NULL, NULL },
160{ 0x574d4c00, 0xffffffff, "WM9701A", NULL, NULL },
161{ 0x574d4C03, 0xffffffff, "WM9703,WM9707,WM9708,WM9717", patch_wolfson03, NULL},
162{ 0x574d4C04, 0xffffffff, "WM9704M,WM9704Q", patch_wolfson04, NULL},
163{ 0x574d4C05, 0xffffffff, "WM9705,WM9710", patch_wolfson05, NULL},
164{ 0x574d4C09, 0xffffffff, "WM9709", NULL, NULL},
165{ 0x574d4C12, 0xffffffff, "WM9711,WM9712", patch_wolfson11, NULL},
166{ 0x574d4c13, 0xffffffff, "WM9713,WM9714", patch_wolfson13, NULL, AC97_DEFAULT_POWER_OFF},
167{ 0x594d4800, 0xffffffff, "YMF743", NULL, NULL },
168{ 0x594d4802, 0xffffffff, "YMF752", NULL, NULL },
169{ 0x594d4803, 0xffffffff, "YMF753", patch_yamaha_ymf753, NULL },
170{ 0x83847600, 0xffffffff, "STAC9700,83,84", patch_sigmatel_stac9700, NULL },
171{ 0x83847604, 0xffffffff, "STAC9701,3,4,5", NULL, NULL },
172{ 0x83847605, 0xffffffff, "STAC9704", NULL, NULL },
173{ 0x83847608, 0xffffffff, "STAC9708,11", patch_sigmatel_stac9708, NULL },
174{ 0x83847609, 0xffffffff, "STAC9721,23", patch_sigmatel_stac9721, NULL },
175{ 0x83847644, 0xffffffff, "STAC9744", patch_sigmatel_stac9744, NULL },
176{ 0x83847650, 0xffffffff, "STAC9750,51", NULL, NULL }, // patch?
177{ 0x83847652, 0xffffffff, "STAC9752,53", NULL, NULL }, // patch?
178{ 0x83847656, 0xffffffff, "STAC9756,57", patch_sigmatel_stac9756, NULL },
179{ 0x83847658, 0xffffffff, "STAC9758,59", patch_sigmatel_stac9758, NULL },
180{ 0x83847666, 0xffffffff, "STAC9766,67", NULL, NULL }, // patch?
181{ 0, 0, NULL, NULL, NULL }
182};
183
184const char *snd_ac97_stereo_enhancements[] =
185{
186 /* 0 */ "No 3D Stereo Enhancement",
187 /* 1 */ "Analog Devices Phat Stereo",
188 /* 2 */ "Creative Stereo Enhancement",
189 /* 3 */ "National Semi 3D Stereo Enhancement",
190 /* 4 */ "YAMAHA Ymersion",
191 /* 5 */ "BBE 3D Stereo Enhancement",
192 /* 6 */ "Crystal Semi 3D Stereo Enhancement",
193 /* 7 */ "Qsound QXpander",
194 /* 8 */ "Spatializer 3D Stereo Enhancement",
195 /* 9 */ "SRS 3D Stereo Enhancement",
196 /* 10 */ "Platform Tech 3D Stereo Enhancement",
197 /* 11 */ "AKM 3D Audio",
198 /* 12 */ "Aureal Stereo Enhancement",
199 /* 13 */ "Aztech 3D Enhancement",
200 /* 14 */ "Binaura 3D Audio Enhancement",
201 /* 15 */ "ESS Technology Stereo Enhancement",
202 /* 16 */ "Harman International VMAx",
203 /* 17 */ "Nvidea/IC Ensemble/KS Waves 3D Stereo Enhancement",
204 /* 18 */ "Philips Incredible Sound",
205 /* 19 */ "Texas Instruments 3D Stereo Enhancement",
206 /* 20 */ "VLSI Technology 3D Stereo Enhancement",
207 /* 21 */ "TriTech 3D Stereo Enhancement",
208 /* 22 */ "Realtek 3D Stereo Enhancement",
209 /* 23 */ "Samsung 3D Stereo Enhancement",
210 /* 24 */ "Wolfson Microelectronics 3D Enhancement",
211 /* 25 */ "Delta Integration 3D Enhancement",
212 /* 26 */ "SigmaTel 3D Enhancement",
213 /* 27 */ "IC Ensemble/KS Waves",
214 /* 28 */ "Rockwell 3D Stereo Enhancement",
215 /* 29 */ "Reserved 29",
216 /* 30 */ "Reserved 30",
217 /* 31 */ "Reserved 31"
218};
219
220/*
221 * Shared AC97 controllers (ICH, ATIIXP...)
222 */
223static DECLARE_MUTEX(shared_codec_mutex);
224static ac97_t *shared_codec[AC97_SHARED_TYPES][4];
225
226
227/*
228 * I/O routines
229 */
230
231static int snd_ac97_valid_reg(ac97_t *ac97, unsigned short reg)
232{
233 if (ac97->limited_regs && ! test_bit(reg, ac97->reg_accessed))
234 return 0;
235
236 /* filter some registers for buggy codecs */
237 switch (ac97->id) {
238 case AC97_ID_AK4540:
239 case AC97_ID_AK4542:
240 if (reg <= 0x1c || reg == 0x20 || reg == 0x26 || reg >= 0x7c)
241 return 1;
242 return 0;
243 case AC97_ID_AD1819: /* AD1819 */
244 case AC97_ID_AD1881: /* AD1881 */
245 case AC97_ID_AD1881A: /* AD1881A */
246 if (reg >= 0x3a && reg <= 0x6e) /* 0x59 */
247 return 0;
248 return 1;
249 case AC97_ID_AD1885: /* AD1885 */
250 case AC97_ID_AD1886: /* AD1886 */
251 case AC97_ID_AD1886A: /* AD1886A - !!verify!! --jk */
252 case AC97_ID_AD1887: /* AD1887 - !!verify!! --jk */
253 if (reg == 0x5a)
254 return 1;
255 if (reg >= 0x3c && reg <= 0x6e) /* 0x59 */
256 return 0;
257 return 1;
258 case AC97_ID_STAC9700:
259 case AC97_ID_STAC9704:
260 case AC97_ID_STAC9705:
261 case AC97_ID_STAC9708:
262 case AC97_ID_STAC9721:
263 case AC97_ID_STAC9744:
264 case AC97_ID_STAC9756:
265 if (reg <= 0x3a || reg >= 0x5a)
266 return 1;
267 return 0;
268 }
269 return 1;
270}
271
272/**
273 * snd_ac97_write - write a value on the given register
274 * @ac97: the ac97 instance
275 * @reg: the register to change
276 * @value: the value to set
277 *
278 * Writes a value on the given register. This will invoke the write
279 * callback directly after the register check.
280 * This function doesn't change the register cache unlike
281 * #snd_ca97_write_cache(), so use this only when you don't want to
282 * reflect the change to the suspend/resume state.
283 */
284void snd_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short value)
285{
286 if (!snd_ac97_valid_reg(ac97, reg))
287 return;
288 if ((ac97->id & 0xffffff00) == AC97_ID_ALC100) {
289 /* Fix H/W bug of ALC100/100P */
290 if (reg == AC97_MASTER || reg == AC97_HEADPHONE)
291 ac97->bus->ops->write(ac97, AC97_RESET, 0); /* reset audio codec */
292 }
293 ac97->bus->ops->write(ac97, reg, value);
294}
295
296/**
297 * snd_ac97_read - read a value from the given register
298 *
299 * @ac97: the ac97 instance
300 * @reg: the register to read
301 *
302 * Reads a value from the given register. This will invoke the read
303 * callback directly after the register check.
304 *
305 * Returns the read value.
306 */
307unsigned short snd_ac97_read(ac97_t *ac97, unsigned short reg)
308{
309 if (!snd_ac97_valid_reg(ac97, reg))
310 return 0;
311 return ac97->bus->ops->read(ac97, reg);
312}
313
314/* read a register - return the cached value if already read */
315static inline unsigned short snd_ac97_read_cache(ac97_t *ac97, unsigned short reg)
316{
317 if (! test_bit(reg, ac97->reg_accessed)) {
318 ac97->regs[reg] = ac97->bus->ops->read(ac97, reg);
319 // set_bit(reg, ac97->reg_accessed);
320 }
321 return ac97->regs[reg];
322}
323
324/**
325 * snd_ac97_write_cache - write a value on the given register and update the cache
326 * @ac97: the ac97 instance
327 * @reg: the register to change
328 * @value: the value to set
329 *
330 * Writes a value on the given register and updates the register
331 * cache. The cached values are used for the cached-read and the
332 * suspend/resume.
333 */
334void snd_ac97_write_cache(ac97_t *ac97, unsigned short reg, unsigned short value)
335{
336 if (!snd_ac97_valid_reg(ac97, reg))
337 return;
338 down(&ac97->reg_mutex);
339 ac97->regs[reg] = value;
340 ac97->bus->ops->write(ac97, reg, value);
341 set_bit(reg, ac97->reg_accessed);
342 up(&ac97->reg_mutex);
343}
344
345/**
346 * snd_ac97_update - update the value on the given register
347 * @ac97: the ac97 instance
348 * @reg: the register to change
349 * @value: the value to set
350 *
351 * Compares the value with the register cache and updates the value
352 * only when the value is changed.
353 *
354 * Returns 1 if the value is changed, 0 if no change, or a negative
355 * code on failure.
356 */
357int snd_ac97_update(ac97_t *ac97, unsigned short reg, unsigned short value)
358{
359 int change;
360
361 if (!snd_ac97_valid_reg(ac97, reg))
362 return -EINVAL;
363 down(&ac97->reg_mutex);
364 change = ac97->regs[reg] != value;
365 if (change) {
366 ac97->regs[reg] = value;
367 ac97->bus->ops->write(ac97, reg, value);
368 }
369 up(&ac97->reg_mutex);
370 return change;
371}
372
373/**
374 * snd_ac97_update_bits - update the bits on the given register
375 * @ac97: the ac97 instance
376 * @reg: the register to change
377 * @mask: the bit-mask to change
378 * @value: the value to set
379 *
380 * Updates the masked-bits on the given register only when the value
381 * is changed.
382 *
383 * Returns 1 if the bits are changed, 0 if no change, or a negative
384 * code on failure.
385 */
386int snd_ac97_update_bits(ac97_t *ac97, unsigned short reg, unsigned short mask, unsigned short value)
387{
388 int change;
389
390 if (!snd_ac97_valid_reg(ac97, reg))
391 return -EINVAL;
392 down(&ac97->reg_mutex);
393 change = snd_ac97_update_bits_nolock(ac97, reg, mask, value);
394 up(&ac97->reg_mutex);
395 return change;
396}
397
398/* no lock version - see snd_ac97_updat_bits() */
399int snd_ac97_update_bits_nolock(ac97_t *ac97, unsigned short reg,
400 unsigned short mask, unsigned short value)
401{
402 int change;
403 unsigned short old, new;
404
405 old = snd_ac97_read_cache(ac97, reg);
406 new = (old & ~mask) | value;
407 change = old != new;
408 if (change) {
409 ac97->regs[reg] = new;
410 ac97->bus->ops->write(ac97, reg, new);
411 }
412 return change;
413}
414
415static int snd_ac97_ad18xx_update_pcm_bits(ac97_t *ac97, int codec, unsigned short mask, unsigned short value)
416{
417 int change;
418 unsigned short old, new, cfg;
419
420 down(&ac97->page_mutex);
421 old = ac97->spec.ad18xx.pcmreg[codec];
422 new = (old & ~mask) | value;
423 change = old != new;
424 if (change) {
425 down(&ac97->reg_mutex);
426 cfg = snd_ac97_read_cache(ac97, AC97_AD_SERIAL_CFG);
427 ac97->spec.ad18xx.pcmreg[codec] = new;
428 /* select single codec */
429 ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
430 (cfg & ~0x7000) |
431 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
432 /* update PCM bits */
433 ac97->bus->ops->write(ac97, AC97_PCM, new);
434 /* select all codecs */
435 ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
436 cfg | 0x7000);
437 up(&ac97->reg_mutex);
438 }
439 up(&ac97->page_mutex);
440 return change;
441}
442
443/*
444 * Controls
445 */
446
447int snd_ac97_info_enum_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
448{
449 struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
450
451 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
452 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
453 uinfo->value.enumerated.items = e->mask;
454
455 if (uinfo->value.enumerated.item > e->mask - 1)
456 uinfo->value.enumerated.item = e->mask - 1;
457 strcpy(uinfo->value.enumerated.name, e->texts[uinfo->value.enumerated.item]);
458 return 0;
459}
460
461int snd_ac97_get_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
462{
463 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
464 struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
465 unsigned short val;
466
467 val = snd_ac97_read_cache(ac97, e->reg);
468 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (e->mask - 1);
469 if (e->shift_l != e->shift_r)
470 ucontrol->value.enumerated.item[1] = (val >> e->shift_r) & (e->mask - 1);
471
472 return 0;
473}
474
475int snd_ac97_put_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
476{
477 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
478 struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
479 unsigned short val;
480 unsigned short mask;
481
482 if (ucontrol->value.enumerated.item[0] > e->mask - 1)
483 return -EINVAL;
484 val = ucontrol->value.enumerated.item[0] << e->shift_l;
485 mask = (e->mask - 1) << e->shift_l;
486 if (e->shift_l != e->shift_r) {
487 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
488 return -EINVAL;
489 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
490 mask |= (e->mask - 1) << e->shift_r;
491 }
492 return snd_ac97_update_bits(ac97, e->reg, mask, val);
493}
494
495/* save/restore ac97 v2.3 paging */
496static int snd_ac97_page_save(ac97_t *ac97, int reg, snd_kcontrol_t *kcontrol)
497{
498 int page_save = -1;
499 if ((kcontrol->private_value & (1<<25)) &&
500 (ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23 &&
501 (reg >= 0x60 && reg < 0x70)) {
502 unsigned short page = (kcontrol->private_value >> 26) & 0x0f;
503 down(&ac97->page_mutex); /* lock paging */
504 page_save = snd_ac97_read(ac97, AC97_INT_PAGING) & AC97_PAGE_MASK;
505 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page);
506 }
507 return page_save;
508}
509
510static void snd_ac97_page_restore(ac97_t *ac97, int page_save)
511{
512 if (page_save >= 0) {
513 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save);
514 up(&ac97->page_mutex); /* unlock paging */
515 }
516}
517
518/* volume and switch controls */
519int snd_ac97_info_volsw(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
520{
521 int mask = (kcontrol->private_value >> 16) & 0xff;
522 int shift = (kcontrol->private_value >> 8) & 0x0f;
523 int rshift = (kcontrol->private_value >> 12) & 0x0f;
524
525 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
526 uinfo->count = shift == rshift ? 1 : 2;
527 uinfo->value.integer.min = 0;
528 uinfo->value.integer.max = mask;
529 return 0;
530}
531
532int snd_ac97_get_volsw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
533{
534 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
535 int reg = kcontrol->private_value & 0xff;
536 int shift = (kcontrol->private_value >> 8) & 0x0f;
537 int rshift = (kcontrol->private_value >> 12) & 0x0f;
538 int mask = (kcontrol->private_value >> 16) & 0xff;
539 int invert = (kcontrol->private_value >> 24) & 0x01;
540 int page_save;
541
542 page_save = snd_ac97_page_save(ac97, reg, kcontrol);
543 ucontrol->value.integer.value[0] = (snd_ac97_read_cache(ac97, reg) >> shift) & mask;
544 if (shift != rshift)
545 ucontrol->value.integer.value[1] = (snd_ac97_read_cache(ac97, reg) >> rshift) & mask;
546 if (invert) {
547 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
548 if (shift != rshift)
549 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
550 }
551 snd_ac97_page_restore(ac97, page_save);
552 return 0;
553}
554
555int snd_ac97_put_volsw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
556{
557 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
558 int reg = kcontrol->private_value & 0xff;
559 int shift = (kcontrol->private_value >> 8) & 0x0f;
560 int rshift = (kcontrol->private_value >> 12) & 0x0f;
561 int mask = (kcontrol->private_value >> 16) & 0xff;
562 int invert = (kcontrol->private_value >> 24) & 0x01;
563 int err, page_save;
564 unsigned short val, val2, val_mask;
565
566 page_save = snd_ac97_page_save(ac97, reg, kcontrol);
567 val = (ucontrol->value.integer.value[0] & mask);
568 if (invert)
569 val = mask - val;
570 val_mask = mask << shift;
571 val = val << shift;
572 if (shift != rshift) {
573 val2 = (ucontrol->value.integer.value[1] & mask);
574 if (invert)
575 val2 = mask - val2;
576 val_mask |= mask << rshift;
577 val |= val2 << rshift;
578 }
579 err = snd_ac97_update_bits(ac97, reg, val_mask, val);
580 snd_ac97_page_restore(ac97, page_save);
581 return err;
582}
583
584static const snd_kcontrol_new_t snd_ac97_controls_master_mono[2] = {
585AC97_SINGLE("Master Mono Playback Switch", AC97_MASTER_MONO, 15, 1, 1),
586AC97_SINGLE("Master Mono Playback Volume", AC97_MASTER_MONO, 0, 31, 1)
587};
588
589static const snd_kcontrol_new_t snd_ac97_controls_tone[2] = {
590AC97_SINGLE("Tone Control - Bass", AC97_MASTER_TONE, 8, 15, 1),
591AC97_SINGLE("Tone Control - Treble", AC97_MASTER_TONE, 0, 15, 1)
592};
593
594static const snd_kcontrol_new_t snd_ac97_controls_pc_beep[2] = {
595AC97_SINGLE("PC Speaker Playback Switch", AC97_PC_BEEP, 15, 1, 1),
596AC97_SINGLE("PC Speaker Playback Volume", AC97_PC_BEEP, 1, 15, 1)
597};
598
599static const snd_kcontrol_new_t snd_ac97_controls_mic_boost =
600 AC97_SINGLE("Mic Boost (+20dB)", AC97_MIC, 6, 1, 0);
601
602
603static const char* std_rec_sel[] = {"Mic", "CD", "Video", "Aux", "Line", "Mix", "Mix Mono", "Phone"};
604static const char* std_3d_path[] = {"pre 3D", "post 3D"};
605static const char* std_mix[] = {"Mix", "Mic"};
606static const char* std_mic[] = {"Mic1", "Mic2"};
607
608static const struct ac97_enum std_enum[] = {
609AC97_ENUM_DOUBLE(AC97_REC_SEL, 8, 0, 8, std_rec_sel),
610AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 15, 2, std_3d_path),
611AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 9, 2, std_mix),
612AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 8, 2, std_mic),
613};
614
615static const snd_kcontrol_new_t snd_ac97_control_capture_src =
616AC97_ENUM("Capture Source", std_enum[0]);
617
618static const snd_kcontrol_new_t snd_ac97_control_capture_vol =
619AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 15, 0);
620
621static const snd_kcontrol_new_t snd_ac97_controls_mic_capture[2] = {
622AC97_SINGLE("Mic Capture Switch", AC97_REC_GAIN_MIC, 15, 1, 1),
623AC97_SINGLE("Mic Capture Volume", AC97_REC_GAIN_MIC, 0, 15, 0)
624};
625
626typedef enum {
627 AC97_GENERAL_PCM_OUT = 0,
628 AC97_GENERAL_STEREO_ENHANCEMENT,
629 AC97_GENERAL_3D,
630 AC97_GENERAL_LOUDNESS,
631 AC97_GENERAL_MONO,
632 AC97_GENERAL_MIC,
633 AC97_GENERAL_LOOPBACK
634} ac97_general_index_t;
635
636static const snd_kcontrol_new_t snd_ac97_controls_general[7] = {
637AC97_ENUM("PCM Out Path & Mute", std_enum[1]),
638AC97_SINGLE("Simulated Stereo Enhancement", AC97_GENERAL_PURPOSE, 14, 1, 0),
639AC97_SINGLE("3D Control - Switch", AC97_GENERAL_PURPOSE, 13, 1, 0),
640AC97_SINGLE("Loudness (bass boost)", AC97_GENERAL_PURPOSE, 12, 1, 0),
641AC97_ENUM("Mono Output Select", std_enum[2]),
642AC97_ENUM("Mic Select", std_enum[3]),
643AC97_SINGLE("ADC/DAC Loopback", AC97_GENERAL_PURPOSE, 7, 1, 0)
644};
645
646const snd_kcontrol_new_t snd_ac97_controls_3d[2] = {
647AC97_SINGLE("3D Control - Center", AC97_3D_CONTROL, 8, 15, 0),
648AC97_SINGLE("3D Control - Depth", AC97_3D_CONTROL, 0, 15, 0)
649};
650
651static const snd_kcontrol_new_t snd_ac97_controls_center[2] = {
652AC97_SINGLE("Center Playback Switch", AC97_CENTER_LFE_MASTER, 7, 1, 1),
653AC97_SINGLE("Center Playback Volume", AC97_CENTER_LFE_MASTER, 0, 31, 1)
654};
655
656static const snd_kcontrol_new_t snd_ac97_controls_lfe[2] = {
657AC97_SINGLE("LFE Playback Switch", AC97_CENTER_LFE_MASTER, 15, 1, 1),
658AC97_SINGLE("LFE Playback Volume", AC97_CENTER_LFE_MASTER, 8, 31, 1)
659};
660
661static const snd_kcontrol_new_t snd_ac97_controls_surround[2] = {
662AC97_DOUBLE("Surround Playback Switch", AC97_SURROUND_MASTER, 15, 7, 1, 1),
663AC97_DOUBLE("Surround Playback Volume", AC97_SURROUND_MASTER, 8, 0, 31, 1),
664};
665
666static const snd_kcontrol_new_t snd_ac97_control_eapd =
667AC97_SINGLE("External Amplifier", AC97_POWERDOWN, 15, 1, 1);
668
669/* change the existing EAPD control as inverted */
670static void set_inv_eapd(ac97_t *ac97, snd_kcontrol_t *kctl)
671{
672 kctl->private_value = AC97_SINGLE_VALUE(AC97_POWERDOWN, 15, 1, 0);
673 snd_ac97_update_bits(ac97, AC97_POWERDOWN, (1<<15), (1<<15)); /* EAPD up */
674 ac97->scaps |= AC97_SCAP_INV_EAPD;
675}
676
677static int snd_ac97_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
678{
679 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
680 uinfo->count = 1;
681 return 0;
682}
683
684static int snd_ac97_spdif_cmask_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
685{
686 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
687 IEC958_AES0_NONAUDIO |
688 IEC958_AES0_CON_EMPHASIS_5015 |
689 IEC958_AES0_CON_NOT_COPYRIGHT;
690 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
691 IEC958_AES1_CON_ORIGINAL;
692 ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
693 return 0;
694}
695
696static int snd_ac97_spdif_pmask_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
697{
698 /* FIXME: AC'97 spec doesn't say which bits are used for what */
699 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
700 IEC958_AES0_NONAUDIO |
701 IEC958_AES0_PRO_FS |
702 IEC958_AES0_PRO_EMPHASIS_5015;
703 return 0;
704}
705
706static int snd_ac97_spdif_default_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
707{
708 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
709
710 down(&ac97->reg_mutex);
711 ucontrol->value.iec958.status[0] = ac97->spdif_status & 0xff;
712 ucontrol->value.iec958.status[1] = (ac97->spdif_status >> 8) & 0xff;
713 ucontrol->value.iec958.status[2] = (ac97->spdif_status >> 16) & 0xff;
714 ucontrol->value.iec958.status[3] = (ac97->spdif_status >> 24) & 0xff;
715 up(&ac97->reg_mutex);
716 return 0;
717}
718
719static int snd_ac97_spdif_default_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
720{
721 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
722 unsigned int new = 0;
723 unsigned short val = 0;
724 int change;
725
726 new = val = ucontrol->value.iec958.status[0] & (IEC958_AES0_PROFESSIONAL|IEC958_AES0_NONAUDIO);
727 if (ucontrol->value.iec958.status[0] & IEC958_AES0_PROFESSIONAL) {
728 new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_PRO_FS|IEC958_AES0_PRO_EMPHASIS_5015);
729 switch (new & IEC958_AES0_PRO_FS) {
730 case IEC958_AES0_PRO_FS_44100: val |= 0<<12; break;
731 case IEC958_AES0_PRO_FS_48000: val |= 2<<12; break;
732 case IEC958_AES0_PRO_FS_32000: val |= 3<<12; break;
733 default: val |= 1<<12; break;
734 }
735 if ((new & IEC958_AES0_PRO_EMPHASIS) == IEC958_AES0_PRO_EMPHASIS_5015)
736 val |= 1<<3;
737 } else {
738 new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT);
739 new |= ((ucontrol->value.iec958.status[1] & (IEC958_AES1_CON_CATEGORY|IEC958_AES1_CON_ORIGINAL)) << 8);
740 new |= ((ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) << 24);
741 if ((new & IEC958_AES0_CON_EMPHASIS) == IEC958_AES0_CON_EMPHASIS_5015)
742 val |= 1<<3;
743 if (!(new & IEC958_AES0_CON_NOT_COPYRIGHT))
744 val |= 1<<2;
745 val |= ((new >> 8) & 0xff) << 4; // category + original
746 switch ((new >> 24) & 0xff) {
747 case IEC958_AES3_CON_FS_44100: val |= 0<<12; break;
748 case IEC958_AES3_CON_FS_48000: val |= 2<<12; break;
749 case IEC958_AES3_CON_FS_32000: val |= 3<<12; break;
750 default: val |= 1<<12; break;
751 }
752 }
753
754 down(&ac97->reg_mutex);
755 change = ac97->spdif_status != new;
756 ac97->spdif_status = new;
757
758 if (ac97->flags & AC97_CS_SPDIF) {
759 int x = (val >> 12) & 0x03;
760 switch (x) {
761 case 0: x = 1; break; // 44.1
762 case 2: x = 0; break; // 48.0
763 default: x = 0; break; // illegal.
764 }
765 change |= snd_ac97_update_bits_nolock(ac97, AC97_CSR_SPDIF, 0x3fff, ((val & 0xcfff) | (x << 12)));
766 } else if (ac97->flags & AC97_CX_SPDIF) {
767 int v;
768 v = new & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT) ? 0 : AC97_CXR_COPYRGT;
769 v |= new & IEC958_AES0_NONAUDIO ? AC97_CXR_SPDIF_AC3 : AC97_CXR_SPDIF_PCM;
770 change |= snd_ac97_update_bits_nolock(ac97, AC97_CXR_AUDIO_MISC,
771 AC97_CXR_SPDIF_MASK | AC97_CXR_COPYRGT,
772 v);
773 } else {
774 unsigned short extst = snd_ac97_read_cache(ac97, AC97_EXTENDED_STATUS);
775 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); /* turn off */
776
777 change |= snd_ac97_update_bits_nolock(ac97, AC97_SPDIF, 0x3fff, val);
778 if (extst & AC97_EA_SPDIF) {
779 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
780 }
781 }
782 up(&ac97->reg_mutex);
783
784 return change;
785}
786
787static int snd_ac97_put_spsa(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
788{
789 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
790 int reg = kcontrol->private_value & 0xff;
791 int shift = (kcontrol->private_value >> 8) & 0xff;
792 int mask = (kcontrol->private_value >> 16) & 0xff;
793 // int invert = (kcontrol->private_value >> 24) & 0xff;
794 unsigned short value, old, new;
795 int change;
796
797 value = (ucontrol->value.integer.value[0] & mask);
798
799 down(&ac97->reg_mutex);
800 mask <<= shift;
801 value <<= shift;
802 old = snd_ac97_read_cache(ac97, reg);
803 new = (old & ~mask) | value;
804 change = old != new;
805
806 if (change) {
807 unsigned short extst = snd_ac97_read_cache(ac97, AC97_EXTENDED_STATUS);
808 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); /* turn off */
809 change = snd_ac97_update_bits_nolock(ac97, reg, mask, value);
810 if (extst & AC97_EA_SPDIF)
811 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
812 }
813 up(&ac97->reg_mutex);
814 return change;
815}
816
817const snd_kcontrol_new_t snd_ac97_controls_spdif[5] = {
818 {
819 .access = SNDRV_CTL_ELEM_ACCESS_READ,
820 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
821 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
822 .info = snd_ac97_spdif_mask_info,
823 .get = snd_ac97_spdif_cmask_get,
824 },
825 {
826 .access = SNDRV_CTL_ELEM_ACCESS_READ,
827 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
828 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
829 .info = snd_ac97_spdif_mask_info,
830 .get = snd_ac97_spdif_pmask_get,
831 },
832 {
833 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
834 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
835 .info = snd_ac97_spdif_mask_info,
836 .get = snd_ac97_spdif_default_get,
837 .put = snd_ac97_spdif_default_put,
838 },
839
840 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),AC97_EXTENDED_STATUS, 2, 1, 0),
841 {
842 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
843 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA",
844 .info = snd_ac97_info_volsw,
845 .get = snd_ac97_get_volsw,
846 .put = snd_ac97_put_spsa,
847 .private_value = AC97_SINGLE_VALUE(AC97_EXTENDED_STATUS, 4, 3, 0)
848 },
849};
850
851#define AD18XX_PCM_BITS(xname, codec, lshift, rshift, mask) \
852{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_ad18xx_pcm_info_bits, \
853 .get = snd_ac97_ad18xx_pcm_get_bits, .put = snd_ac97_ad18xx_pcm_put_bits, \
854 .private_value = (codec) | ((lshift) << 8) | ((rshift) << 12) | ((mask) << 16) }
855
856static int snd_ac97_ad18xx_pcm_info_bits(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
857{
858 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
859 int mask = (kcontrol->private_value >> 16) & 0x0f;
860 int lshift = (kcontrol->private_value >> 8) & 0x0f;
861 int rshift = (kcontrol->private_value >> 12) & 0x0f;
862
863 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
864 if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
865 uinfo->count = 2;
866 else
867 uinfo->count = 1;
868 uinfo->value.integer.min = 0;
869 uinfo->value.integer.max = mask;
870 return 0;
871}
872
873static int snd_ac97_ad18xx_pcm_get_bits(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
874{
875 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
876 int codec = kcontrol->private_value & 3;
877 int lshift = (kcontrol->private_value >> 8) & 0x0f;
878 int rshift = (kcontrol->private_value >> 12) & 0x0f;
879 int mask = (kcontrol->private_value >> 16) & 0xff;
880
881 ucontrol->value.integer.value[0] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> lshift) & mask);
882 if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
883 ucontrol->value.integer.value[1] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> rshift) & mask);
884 return 0;
885}
886
887static int snd_ac97_ad18xx_pcm_put_bits(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
888{
889 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
890 int codec = kcontrol->private_value & 3;
891 int lshift = (kcontrol->private_value >> 8) & 0x0f;
892 int rshift = (kcontrol->private_value >> 12) & 0x0f;
893 int mask = (kcontrol->private_value >> 16) & 0xff;
894 unsigned short val, valmask;
895
896 val = (mask - (ucontrol->value.integer.value[0] & mask)) << lshift;
897 valmask = mask << lshift;
898 if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES)) {
899 val |= (mask - (ucontrol->value.integer.value[1] & mask)) << rshift;
900 valmask |= mask << rshift;
901 }
902 return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, valmask, val);
903}
904
905#define AD18XX_PCM_VOLUME(xname, codec) \
906{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_ad18xx_pcm_info_volume, \
907 .get = snd_ac97_ad18xx_pcm_get_volume, .put = snd_ac97_ad18xx_pcm_put_volume, \
908 .private_value = codec }
909
910static int snd_ac97_ad18xx_pcm_info_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
911{
912 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
913 uinfo->count = 2;
914 uinfo->value.integer.min = 0;
915 uinfo->value.integer.max = 31;
916 return 0;
917}
918
919static int snd_ac97_ad18xx_pcm_get_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
920{
921 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
922 int codec = kcontrol->private_value & 3;
923
924 down(&ac97->page_mutex);
925 ucontrol->value.integer.value[0] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 0) & 31);
926 ucontrol->value.integer.value[1] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 8) & 31);
927 up(&ac97->page_mutex);
928 return 0;
929}
930
931static int snd_ac97_ad18xx_pcm_put_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
932{
933 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
934 int codec = kcontrol->private_value & 3;
935 unsigned short val1, val2;
936
937 val1 = 31 - (ucontrol->value.integer.value[0] & 31);
938 val2 = 31 - (ucontrol->value.integer.value[1] & 31);
939 return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, 0x1f1f, (val1 << 8) | val2);
940}
941
942static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_pcm[2] = {
943AD18XX_PCM_BITS("PCM Playback Switch", 0, 15, 7, 1),
944AD18XX_PCM_VOLUME("PCM Playback Volume", 0)
945};
946
947static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_surround[2] = {
948AD18XX_PCM_BITS("Surround Playback Switch", 1, 15, 7, 1),
949AD18XX_PCM_VOLUME("Surround Playback Volume", 1)
950};
951
952static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_center[2] = {
953AD18XX_PCM_BITS("Center Playback Switch", 2, 15, 15, 1),
954AD18XX_PCM_BITS("Center Playback Volume", 2, 8, 8, 31)
955};
956
957static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_lfe[2] = {
958AD18XX_PCM_BITS("LFE Playback Switch", 2, 7, 7, 1),
959AD18XX_PCM_BITS("LFE Playback Volume", 2, 0, 0, 31)
960};
961
962/*
963 *
964 */
965
966static void snd_ac97_powerdown(ac97_t *ac97);
967
968static int snd_ac97_bus_free(ac97_bus_t *bus)
969{
970 if (bus) {
971 snd_ac97_bus_proc_done(bus);
972 kfree(bus->pcms);
973 if (bus->private_free)
974 bus->private_free(bus);
975 kfree(bus);
976 }
977 return 0;
978}
979
980static int snd_ac97_bus_dev_free(snd_device_t *device)
981{
982 ac97_bus_t *bus = device->device_data;
983 return snd_ac97_bus_free(bus);
984}
985
986static int snd_ac97_free(ac97_t *ac97)
987{
988 if (ac97) {
989 snd_ac97_proc_done(ac97);
990 if (ac97->bus) {
991 ac97->bus->codec[ac97->num] = NULL;
992 if (ac97->bus->shared_type) {
993 down(&shared_codec_mutex);
994 shared_codec[ac97->bus->shared_type-1][ac97->num] = NULL;
995 up(&shared_codec_mutex);
996 }
997 }
998 if (ac97->private_free)
999 ac97->private_free(ac97);
1000 kfree(ac97);
1001 }
1002 return 0;
1003}
1004
1005static int snd_ac97_dev_free(snd_device_t *device)
1006{
1007 ac97_t *ac97 = device->device_data;
1008 snd_ac97_powerdown(ac97); /* for avoiding click noises during shut down */
1009 return snd_ac97_free(ac97);
1010}
1011
1012static int snd_ac97_try_volume_mix(ac97_t * ac97, int reg)
1013{
1014 unsigned short val, mask = 0x8000;
1015
1016 if (! snd_ac97_valid_reg(ac97, reg))
1017 return 0;
1018
1019 switch (reg) {
1020 case AC97_MASTER_TONE:
1021 return ac97->caps & 0x04 ? 1 : 0;
1022 case AC97_HEADPHONE:
1023 return ac97->caps & 0x10 ? 1 : 0;
1024 case AC97_REC_GAIN_MIC:
1025 return ac97->caps & 0x01 ? 1 : 0;
1026 case AC97_3D_CONTROL:
1027 if (ac97->caps & 0x7c00) {
1028 val = snd_ac97_read(ac97, reg);
1029 /* if nonzero - fixed and we can't set it */
1030 return val == 0;
1031 }
1032 return 0;
1033 case AC97_CENTER_LFE_MASTER: /* center */
1034 if ((ac97->ext_id & AC97_EI_CDAC) == 0)
1035 return 0;
1036 break;
1037 case AC97_CENTER_LFE_MASTER+1: /* lfe */
1038 if ((ac97->ext_id & AC97_EI_LDAC) == 0)
1039 return 0;
1040 reg = AC97_CENTER_LFE_MASTER;
1041 mask = 0x0080;
1042 break;
1043 case AC97_SURROUND_MASTER:
1044 if ((ac97->ext_id & AC97_EI_SDAC) == 0)
1045 return 0;
1046 break;
1047 }
1048
1049 if (ac97->limited_regs && test_bit(reg, ac97->reg_accessed))
1050 return 1; /* allow without check */
1051
1052 val = snd_ac97_read(ac97, reg);
1053 if (!(val & mask)) {
1054 /* nothing seems to be here - mute flag is not set */
1055 /* try another test */
1056 snd_ac97_write_cache(ac97, reg, val | mask);
1057 val = snd_ac97_read(ac97, reg);
1058 if (!(val & mask))
1059 return 0; /* nothing here */
1060 }
1061 return 1; /* success, useable */
1062}
1063
1064static void check_volume_resolution(ac97_t *ac97, int reg, unsigned char *lo_max, unsigned char *hi_max)
1065{
1066 unsigned short cbit[3] = { 0x20, 0x10, 0x01 };
1067 unsigned char max[3] = { 63, 31, 15 };
1068 int i;
1069
1070 *lo_max = *hi_max = 0;
1071 for (i = 0 ; i < ARRAY_SIZE(cbit); i++) {
1072 unsigned short val;
1073 snd_ac97_write(ac97, reg, 0x8080 | cbit[i] | (cbit[i] << 8));
1074 val = snd_ac97_read(ac97, reg);
1075 if (! *lo_max && (val & cbit[i]))
1076 *lo_max = max[i];
1077 if (! *hi_max && (val & (cbit[i] << 8)))
1078 *hi_max = max[i];
1079 if (*lo_max && *hi_max)
1080 break;
1081 }
1082}
1083
1084int snd_ac97_try_bit(ac97_t * ac97, int reg, int bit)
1085{
1086 unsigned short mask, val, orig, res;
1087
1088 mask = 1 << bit;
1089 orig = snd_ac97_read(ac97, reg);
1090 val = orig ^ mask;
1091 snd_ac97_write(ac97, reg, val);
1092 res = snd_ac97_read(ac97, reg);
1093 snd_ac97_write_cache(ac97, reg, orig);
1094 return res == val;
1095}
1096
1097/* check the volume resolution of center/lfe */
1098static void snd_ac97_change_volume_params2(ac97_t * ac97, int reg, int shift, unsigned char *max)
1099{
1100 unsigned short val, val1;
1101
1102 *max = 63;
1103 val = 0x8080 | (0x20 << shift);
1104 snd_ac97_write(ac97, reg, val);
1105 val1 = snd_ac97_read(ac97, reg);
1106 if (val != val1) {
1107 *max = 31;
1108 }
1109 /* reset volume to zero */
1110 snd_ac97_write_cache(ac97, reg, 0x8080);
1111}
1112
1113static inline int printable(unsigned int x)
1114{
1115 x &= 0xff;
1116 if (x < ' ' || x >= 0x71) {
1117 if (x <= 0x89)
1118 return x - 0x71 + 'A';
1119 return '?';
1120 }
1121 return x;
1122}
1123
1124snd_kcontrol_t *snd_ac97_cnew(const snd_kcontrol_new_t *_template, ac97_t * ac97)
1125{
1126 snd_kcontrol_new_t template;
1127 memcpy(&template, _template, sizeof(template));
1128 snd_runtime_check(!template.index, return NULL);
1129 template.index = ac97->num;
1130 return snd_ctl_new1(&template, ac97);
1131}
1132
1133/*
1134 * create mute switch(es) for normal stereo controls
1135 */
1136static int snd_ac97_cmute_new_stereo(snd_card_t *card, char *name, int reg, int check_stereo, ac97_t *ac97)
1137{
1138 snd_kcontrol_t *kctl;
1139 int err;
1140 unsigned short val, val1, mute_mask;
1141
1142 if (! snd_ac97_valid_reg(ac97, reg))
1143 return 0;
1144
1145 mute_mask = 0x8000;
1146 val = snd_ac97_read(ac97, reg);
1147 if (check_stereo || (ac97->flags & AC97_STEREO_MUTES)) {
1148 /* check whether both mute bits work */
1149 val1 = val | 0x8080;
1150 snd_ac97_write(ac97, reg, val1);
1151 if (val1 == snd_ac97_read(ac97, reg))
1152 mute_mask = 0x8080;
1153 }
1154 if (mute_mask == 0x8080) {
1155 snd_kcontrol_new_t tmp = AC97_DOUBLE(name, reg, 15, 7, 1, 1);
1156 tmp.index = ac97->num;
1157 kctl = snd_ctl_new1(&tmp, ac97);
1158 } else {
1159 snd_kcontrol_new_t tmp = AC97_SINGLE(name, reg, 15, 1, 1);
1160 tmp.index = ac97->num;
1161 kctl = snd_ctl_new1(&tmp, ac97);
1162 }
1163 err = snd_ctl_add(card, kctl);
1164 if (err < 0)
1165 return err;
1166 /* mute as default */
1167 snd_ac97_write_cache(ac97, reg, val | mute_mask);
1168 return 0;
1169}
1170
1171/*
1172 * create a volume for normal stereo/mono controls
1173 */
1174static int snd_ac97_cvol_new(snd_card_t *card, char *name, int reg, unsigned int lo_max,
1175 unsigned int hi_max, ac97_t *ac97)
1176{
1177 int err;
1178 snd_kcontrol_t *kctl;
1179
1180 if (! snd_ac97_valid_reg(ac97, reg))
1181 return 0;
1182 if (hi_max) {
1183 /* invert */
1184 snd_kcontrol_new_t tmp = AC97_DOUBLE(name, reg, 8, 0, lo_max, 1);
1185 tmp.index = ac97->num;
1186 kctl = snd_ctl_new1(&tmp, ac97);
1187 } else {
1188 /* invert */
1189 snd_kcontrol_new_t tmp = AC97_SINGLE(name, reg, 0, lo_max, 1);
1190 tmp.index = ac97->num;
1191 kctl = snd_ctl_new1(&tmp, ac97);
1192 }
1193 err = snd_ctl_add(card, kctl);
1194 if (err < 0)
1195 return err;
1196 snd_ac97_write_cache(ac97, reg,
1197 (snd_ac97_read(ac97, reg) & 0x8080) |
1198 lo_max | (hi_max << 8));
1199 return 0;
1200}
1201
1202/*
1203 * create a mute-switch and a volume for normal stereo/mono controls
1204 */
1205static int snd_ac97_cmix_new_stereo(snd_card_t *card, const char *pfx, int reg, int check_stereo, ac97_t *ac97)
1206{
1207 int err;
1208 char name[44];
1209 unsigned char lo_max, hi_max;
1210
1211 if (! snd_ac97_valid_reg(ac97, reg))
1212 return 0;
1213
1214 if (snd_ac97_try_bit(ac97, reg, 15)) {
1215 sprintf(name, "%s Switch", pfx);
1216 if ((err = snd_ac97_cmute_new_stereo(card, name, reg, check_stereo, ac97)) < 0)
1217 return err;
1218 }
1219 check_volume_resolution(ac97, reg, &lo_max, &hi_max);
1220 if (lo_max) {
1221 sprintf(name, "%s Volume", pfx);
1222 if ((err = snd_ac97_cvol_new(card, name, reg, lo_max, hi_max, ac97)) < 0)
1223 return err;
1224 }
1225 return 0;
1226}
1227
1228#define snd_ac97_cmix_new(card, pfx, reg, ac97) snd_ac97_cmix_new_stereo(card, pfx, reg, 0, ac97)
1229#define snd_ac97_cmute_new(card, name, reg, ac97) snd_ac97_cmute_new_stereo(card, name, reg, 0, ac97)
1230
1231static unsigned int snd_ac97_determine_spdif_rates(ac97_t *ac97);
1232
1233static int snd_ac97_mixer_build(ac97_t * ac97)
1234{
1235 snd_card_t *card = ac97->bus->card;
1236 snd_kcontrol_t *kctl;
1237 int err;
1238 unsigned int idx;
1239 unsigned char max;
1240
1241 /* build master controls */
1242 /* AD claims to remove this control from AD1887, although spec v2.2 does not allow this */
1243 if (snd_ac97_try_volume_mix(ac97, AC97_MASTER)) {
1244 if (ac97->flags & AC97_HAS_NO_MASTER_VOL)
1245 err = snd_ac97_cmute_new(card, "Master Playback Switch", AC97_MASTER, ac97);
1246 else
1247 err = snd_ac97_cmix_new(card, "Master Playback", AC97_MASTER, ac97);
1248 if (err < 0)
1249 return err;
1250 }
1251
1252 ac97->regs[AC97_CENTER_LFE_MASTER] = 0x8080;
1253
1254 /* build center controls */
1255 if (snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER)) {
1256 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_center[0], ac97))) < 0)
1257 return err;
1258 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_center[1], ac97))) < 0)
1259 return err;
1260 snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 0, &max);
1261 kctl->private_value &= ~(0xff << 16);
1262 kctl->private_value |= (int)max << 16;
1263 snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max);
1264 }
1265
1266 /* build LFE controls */
1267 if (snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1)) {
1268 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_lfe[0], ac97))) < 0)
1269 return err;
1270 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_lfe[1], ac97))) < 0)
1271 return err;
1272 snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 8, &max);
1273 kctl->private_value &= ~(0xff << 16);
1274 kctl->private_value |= (int)max << 16;
1275 snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max << 8);
1276 }
1277
1278 /* build surround controls */
1279 if (snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER)) {
1280 /* Surround Master (0x38) is with stereo mutes */
1281 if ((err = snd_ac97_cmix_new_stereo(card, "Surround Playback", AC97_SURROUND_MASTER, 1, ac97)) < 0)
1282 return err;
1283 }
1284
1285 /* build headphone controls */
1286 if (snd_ac97_try_volume_mix(ac97, AC97_HEADPHONE)) {
1287 if ((err = snd_ac97_cmix_new(card, "Headphone Playback", AC97_HEADPHONE, ac97)) < 0)
1288 return err;
1289 }
1290
1291 /* build master mono controls */
1292 if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_MONO)) {
1293 if ((err = snd_ac97_cmix_new(card, "Master Mono Playback", AC97_MASTER_MONO, ac97)) < 0)
1294 return err;
1295 }
1296
1297 /* build master tone controls */
1298 if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_TONE)) {
1299 for (idx = 0; idx < 2; idx++) {
1300 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_tone[idx], ac97))) < 0)
1301 return err;
1302 if (ac97->id == AC97_ID_YMF753) {
1303 kctl->private_value &= ~(0xff << 16);
1304 kctl->private_value |= 7 << 16;
1305 }
1306 }
1307 snd_ac97_write_cache(ac97, AC97_MASTER_TONE, 0x0f0f);
1308 }
1309
1310 /* build PC Speaker controls */
1311 if (!(ac97->flags & AC97_HAS_NO_PC_BEEP) &&
1312 ((ac97->flags & AC97_HAS_PC_BEEP) ||
1313 snd_ac97_try_volume_mix(ac97, AC97_PC_BEEP))) {
1314 for (idx = 0; idx < 2; idx++)
1315 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_pc_beep[idx], ac97))) < 0)
1316 return err;
1317 snd_ac97_write_cache(ac97, AC97_PC_BEEP,
1318 snd_ac97_read(ac97, AC97_PC_BEEP) | 0x801e);
1319 }
1320
1321 /* build Phone controls */
1322 if (!(ac97->flags & AC97_HAS_NO_PHONE)) {
1323 if (snd_ac97_try_volume_mix(ac97, AC97_PHONE)) {
1324 if ((err = snd_ac97_cmix_new(card, "Phone Playback", AC97_PHONE, ac97)) < 0)
1325 return err;
1326 }
1327 }
1328
1329 /* build MIC controls */
1330 if (snd_ac97_try_volume_mix(ac97, AC97_MIC)) {
1331 if ((err = snd_ac97_cmix_new(card, "Mic Playback", AC97_MIC, ac97)) < 0)
1332 return err;
1333 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_boost, ac97))) < 0)
1334 return err;
1335 }
1336
1337 /* build Line controls */
1338 if (snd_ac97_try_volume_mix(ac97, AC97_LINE)) {
1339 if ((err = snd_ac97_cmix_new(card, "Line Playback", AC97_LINE, ac97)) < 0)
1340 return err;
1341 }
1342
1343 /* build CD controls */
1344 if (!(ac97->flags & AC97_HAS_NO_CD)) {
1345 if (snd_ac97_try_volume_mix(ac97, AC97_CD)) {
1346 if ((err = snd_ac97_cmix_new(card, "CD Playback", AC97_CD, ac97)) < 0)
1347 return err;
1348 }
1349 }
1350
1351 /* build Video controls */
1352 if (!(ac97->flags & AC97_HAS_NO_VIDEO)) {
1353 if (snd_ac97_try_volume_mix(ac97, AC97_VIDEO)) {
1354 if ((err = snd_ac97_cmix_new(card, "Video Playback", AC97_VIDEO, ac97)) < 0)
1355 return err;
1356 }
1357 }
1358
1359 /* build Aux controls */
1360 if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
1361 if ((err = snd_ac97_cmix_new(card, "Aux Playback", AC97_AUX, ac97)) < 0)
1362 return err;
1363 }
1364
1365 /* build PCM controls */
1366 if (ac97->flags & AC97_AD_MULTI) {
1367 unsigned short init_val;
1368 if (ac97->flags & AC97_STEREO_MUTES)
1369 init_val = 0x9f9f;
1370 else
1371 init_val = 0x9f1f;
1372 for (idx = 0; idx < 2; idx++)
1373 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_pcm[idx], ac97))) < 0)
1374 return err;
1375 ac97->spec.ad18xx.pcmreg[0] = init_val;
1376 if (ac97->scaps & AC97_SCAP_SURROUND_DAC) {
1377 for (idx = 0; idx < 2; idx++)
1378 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_surround[idx], ac97))) < 0)
1379 return err;
1380 ac97->spec.ad18xx.pcmreg[1] = init_val;
1381 }
1382 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) {
1383 for (idx = 0; idx < 2; idx++)
1384 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_center[idx], ac97))) < 0)
1385 return err;
1386 for (idx = 0; idx < 2; idx++)
1387 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_lfe[idx], ac97))) < 0)
1388 return err;
1389 ac97->spec.ad18xx.pcmreg[2] = init_val;
1390 }
1391 snd_ac97_write_cache(ac97, AC97_PCM, init_val);
1392 } else {
1393 if (ac97->flags & AC97_HAS_NO_PCM_VOL)
1394 err = snd_ac97_cmute_new(card, "PCM Playback Switch", AC97_PCM, ac97);
1395 else
1396 err = snd_ac97_cmix_new(card, "PCM Playback", AC97_PCM, ac97);
1397 if (err < 0)
1398 return err;
1399 }
1400
1401 /* build Capture controls */
1402 if (!(ac97->flags & AC97_HAS_NO_REC_GAIN)) {
1403 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_src, ac97))) < 0)
1404 return err;
1405 if (snd_ac97_try_bit(ac97, AC97_REC_GAIN, 15)) {
1406 if ((err = snd_ac97_cmute_new(card, "Capture Switch", AC97_REC_GAIN, ac97)) < 0)
1407 return err;
1408 }
1409 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_vol, ac97))) < 0)
1410 return err;
1411 snd_ac97_write_cache(ac97, AC97_REC_SEL, 0x0000);
1412 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x0000);
1413 }
1414 /* build MIC Capture controls */
1415 if (snd_ac97_try_volume_mix(ac97, AC97_REC_GAIN_MIC)) {
1416 for (idx = 0; idx < 2; idx++)
1417 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_capture[idx], ac97))) < 0)
1418 return err;
1419 snd_ac97_write_cache(ac97, AC97_REC_GAIN_MIC, 0x0000);
1420 }
1421
1422 /* build PCM out path & mute control */
1423 if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 15)) {
1424 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_PCM_OUT], ac97))) < 0)
1425 return err;
1426 }
1427
1428 /* build Simulated Stereo Enhancement control */
1429 if (ac97->caps & 0x0008) {
1430 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_STEREO_ENHANCEMENT], ac97))) < 0)
1431 return err;
1432 }
1433
1434 /* build 3D Stereo Enhancement control */
1435 if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 13)) {
1436 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_3D], ac97))) < 0)
1437 return err;
1438 }
1439
1440 /* build Loudness control */
1441 if (ac97->caps & 0x0020) {
1442 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOUDNESS], ac97))) < 0)
1443 return err;
1444 }
1445
1446 /* build Mono output select control */
1447 if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 9)) {
1448 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MONO], ac97))) < 0)
1449 return err;
1450 }
1451
1452 /* build Mic select control */
1453 if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 8)) {
1454 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MIC], ac97))) < 0)
1455 return err;
1456 }
1457
1458 /* build ADC/DAC loopback control */
1459 if (enable_loopback && snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 7)) {
1460 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOOPBACK], ac97))) < 0)
1461 return err;
1462 }
1463
1464 snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, ~AC97_GP_DRSS_MASK, 0x0000);
1465
1466 /* build 3D controls */
1467 if (ac97->build_ops->build_3d) {
1468 ac97->build_ops->build_3d(ac97);
1469 } else {
1470 if (snd_ac97_try_volume_mix(ac97, AC97_3D_CONTROL)) {
1471 unsigned short val;
1472 val = 0x0707;
1473 snd_ac97_write(ac97, AC97_3D_CONTROL, val);
1474 val = snd_ac97_read(ac97, AC97_3D_CONTROL);
1475 val = val == 0x0606;
1476 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
1477 return err;
1478 if (val)
1479 kctl->private_value = AC97_3D_CONTROL | (9 << 8) | (7 << 16);
1480 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[1], ac97))) < 0)
1481 return err;
1482 if (val)
1483 kctl->private_value = AC97_3D_CONTROL | (1 << 8) | (7 << 16);
1484 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
1485 }
1486 }
1487
1488 /* build S/PDIF controls */
1489 if ((ac97->ext_id & AC97_EI_SPDIF) && !(ac97->scaps & AC97_SCAP_NO_SPDIF)) {
1490 if (ac97->build_ops->build_spdif) {
1491 if ((err = ac97->build_ops->build_spdif(ac97)) < 0)
1492 return err;
1493 } else {
1494 for (idx = 0; idx < 5; idx++)
1495 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_spdif[idx], ac97))) < 0)
1496 return err;
1497 if (ac97->build_ops->build_post_spdif) {
1498 if ((err = ac97->build_ops->build_post_spdif(ac97)) < 0)
1499 return err;
1500 }
1501 /* set default PCM S/PDIF params */
1502 /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
1503 snd_ac97_write_cache(ac97, AC97_SPDIF, 0x2a20);
1504 ac97->rates[AC97_RATES_SPDIF] = snd_ac97_determine_spdif_rates(ac97);
1505 }
1506 ac97->spdif_status = SNDRV_PCM_DEFAULT_CON_SPDIF;
1507 }
1508
1509 /* build chip specific controls */
1510 if (ac97->build_ops->build_specific)
1511 if ((err = ac97->build_ops->build_specific(ac97)) < 0)
1512 return err;
1513
1514 if (snd_ac97_try_bit(ac97, AC97_POWERDOWN, 15)) {
1515 kctl = snd_ac97_cnew(&snd_ac97_control_eapd, ac97);
1516 if (! kctl)
1517 return -ENOMEM;
1518 if (ac97->scaps & AC97_SCAP_INV_EAPD)
1519 set_inv_eapd(ac97, kctl);
1520 if ((err = snd_ctl_add(card, kctl)) < 0)
1521 return err;
1522 }
1523
1524 return 0;
1525}
1526
1527static int snd_ac97_modem_build(snd_card_t * card, ac97_t * ac97)
1528{
1529 /* TODO */
1530 //printk("AC97_GPIO_CFG = %x\n",snd_ac97_read(ac97,AC97_GPIO_CFG));
1531 snd_ac97_write(ac97, AC97_GPIO_CFG, 0xffff & ~(AC97_GPIO_LINE1_OH));
1532 snd_ac97_write(ac97, AC97_GPIO_POLARITY, 0xffff & ~(AC97_GPIO_LINE1_OH));
1533 snd_ac97_write(ac97, AC97_GPIO_STICKY, 0xffff);
1534 snd_ac97_write(ac97, AC97_GPIO_WAKEUP, 0x0);
1535 snd_ac97_write(ac97, AC97_MISC_AFE, 0x0);
1536 return 0;
1537}
1538
1539static int snd_ac97_test_rate(ac97_t *ac97, int reg, int shadow_reg, int rate)
1540{
1541 unsigned short val;
1542 unsigned int tmp;
1543
1544 tmp = ((unsigned int)rate * ac97->bus->clock) / 48000;
1545 snd_ac97_write_cache(ac97, reg, tmp & 0xffff);
1546 if (shadow_reg)
1547 snd_ac97_write_cache(ac97, shadow_reg, tmp & 0xffff);
1548 val = snd_ac97_read(ac97, reg);
1549 return val == (tmp & 0xffff);
1550}
1551
1552static void snd_ac97_determine_rates(ac97_t *ac97, int reg, int shadow_reg, unsigned int *r_result)
1553{
1554 unsigned int result = 0;
1555 unsigned short saved;
1556
1557 if (ac97->bus->no_vra) {
1558 *r_result = SNDRV_PCM_RATE_48000;
1559 if ((ac97->flags & AC97_DOUBLE_RATE) &&
1560 reg == AC97_PCM_FRONT_DAC_RATE)
1561 *r_result |= SNDRV_PCM_RATE_96000;
1562 return;
1563 }
1564
1565 saved = snd_ac97_read(ac97, reg);
1566 if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE)
1567 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1568 AC97_EA_DRA, 0);
1569 /* test a non-standard rate */
1570 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11000))
1571 result |= SNDRV_PCM_RATE_CONTINUOUS;
1572 /* let's try to obtain standard rates */
1573 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 8000))
1574 result |= SNDRV_PCM_RATE_8000;
1575 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11025))
1576 result |= SNDRV_PCM_RATE_11025;
1577 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 16000))
1578 result |= SNDRV_PCM_RATE_16000;
1579 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 22050))
1580 result |= SNDRV_PCM_RATE_22050;
1581 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 32000))
1582 result |= SNDRV_PCM_RATE_32000;
1583 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 44100))
1584 result |= SNDRV_PCM_RATE_44100;
1585 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 48000))
1586 result |= SNDRV_PCM_RATE_48000;
1587 if ((ac97->flags & AC97_DOUBLE_RATE) &&
1588 reg == AC97_PCM_FRONT_DAC_RATE) {
1589 /* test standard double rates */
1590 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1591 AC97_EA_DRA, AC97_EA_DRA);
1592 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 64000 / 2))
1593 result |= SNDRV_PCM_RATE_64000;
1594 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 88200 / 2))
1595 result |= SNDRV_PCM_RATE_88200;
1596 if (snd_ac97_test_rate(ac97, reg, shadow_reg, 96000 / 2))
1597 result |= SNDRV_PCM_RATE_96000;
1598 /* some codecs don't support variable double rates */
1599 if (!snd_ac97_test_rate(ac97, reg, shadow_reg, 76100 / 2))
1600 result &= ~SNDRV_PCM_RATE_CONTINUOUS;
1601 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1602 AC97_EA_DRA, 0);
1603 }
1604 /* restore the default value */
1605 snd_ac97_write_cache(ac97, reg, saved);
1606 if (shadow_reg)
1607 snd_ac97_write_cache(ac97, shadow_reg, saved);
1608 *r_result = result;
1609}
1610
1611/* check AC97_SPDIF register to accept which sample rates */
1612static unsigned int snd_ac97_determine_spdif_rates(ac97_t *ac97)
1613{
1614 unsigned int result = 0;
1615 int i;
1616 static unsigned short ctl_bits[] = {
1617 AC97_SC_SPSR_44K, AC97_SC_SPSR_32K, AC97_SC_SPSR_48K
1618 };
1619 static unsigned int rate_bits[] = {
1620 SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_32000, SNDRV_PCM_RATE_48000
1621 };
1622
1623 for (i = 0; i < (int)ARRAY_SIZE(ctl_bits); i++) {
1624 snd_ac97_update_bits(ac97, AC97_SPDIF, AC97_SC_SPSR_MASK, ctl_bits[i]);
1625 if ((snd_ac97_read(ac97, AC97_SPDIF) & AC97_SC_SPSR_MASK) == ctl_bits[i])
1626 result |= rate_bits[i];
1627 }
1628 return result;
1629}
1630
1631/* look for the codec id table matching with the given id */
1632static const ac97_codec_id_t *look_for_codec_id(const ac97_codec_id_t *table,
1633 unsigned int id)
1634{
1635 const ac97_codec_id_t *pid;
1636
1637 for (pid = table; pid->id; pid++)
1638 if (pid->id == (id & pid->mask))
1639 return pid;
1640 return NULL;
1641}
1642
1643void snd_ac97_get_name(ac97_t *ac97, unsigned int id, char *name, int modem)
1644{
1645 const ac97_codec_id_t *pid;
1646
1647 sprintf(name, "0x%x %c%c%c", id,
1648 printable(id >> 24),
1649 printable(id >> 16),
1650 printable(id >> 8));
1651 pid = look_for_codec_id(snd_ac97_codec_id_vendors, id);
1652 if (! pid)
1653 return;
1654
1655 strcpy(name, pid->name);
1656 if (ac97 && pid->patch) {
1657 if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
1658 (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
1659 pid->patch(ac97);
1660 }
1661
1662 pid = look_for_codec_id(snd_ac97_codec_ids, id);
1663 if (pid) {
1664 strcat(name, " ");
1665 strcat(name, pid->name);
1666 if (pid->mask != 0xffffffff)
1667 sprintf(name + strlen(name), " rev %d", id & ~pid->mask);
1668 if (ac97 && pid->patch) {
1669 if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
1670 (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
1671 pid->patch(ac97);
1672 }
1673 } else
1674 sprintf(name + strlen(name), " id %x", id & 0xff);
1675}
1676
1677/**
1678 * snd_ac97_get_short_name - retrieve codec name
1679 * @ac97: the codec instance
1680 *
1681 * Returns the short identifying name of the codec.
1682 */
1683const char *snd_ac97_get_short_name(ac97_t *ac97)
1684{
1685 const ac97_codec_id_t *pid;
1686
1687 for (pid = snd_ac97_codec_ids; pid->id; pid++)
1688 if (pid->id == (ac97->id & pid->mask))
1689 return pid->name;
1690 return "unknown codec";
1691}
1692
1693
1694/* wait for a while until registers are accessible after RESET
1695 * return 0 if ok, negative not ready
1696 */
1697static int ac97_reset_wait(ac97_t *ac97, int timeout, int with_modem)
1698{
1699 unsigned long end_time;
1700 unsigned short val;
1701
1702 end_time = jiffies + timeout;
1703 do {
1704
1705 /* use preliminary reads to settle the communication */
1706 snd_ac97_read(ac97, AC97_RESET);
1707 snd_ac97_read(ac97, AC97_VENDOR_ID1);
1708 snd_ac97_read(ac97, AC97_VENDOR_ID2);
1709 /* modem? */
1710 if (with_modem) {
1711 val = snd_ac97_read(ac97, AC97_EXTENDED_MID);
1712 if (val != 0xffff && (val & 1) != 0)
1713 return 0;
1714 }
1715 if (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) {
1716 /* probably only Xbox issue - all registers are read as zero */
1717 val = snd_ac97_read(ac97, AC97_VENDOR_ID1);
1718 if (val != 0 && val != 0xffff)
1719 return 0;
1720 } else {
1721 /* because the PCM or MASTER volume registers can be modified,
1722 * the REC_GAIN register is used for tests
1723 */
1724 /* test if we can write to the record gain volume register */
1725 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a05);
1726 if ((snd_ac97_read(ac97, AC97_REC_GAIN) & 0x7fff) == 0x0a05)
1727 return 0;
1728 }
1729 set_current_state(TASK_UNINTERRUPTIBLE);
1730 schedule_timeout(1);
1731 } while (time_after_eq(end_time, jiffies));
1732 return -ENODEV;
1733}
1734
1735/**
1736 * snd_ac97_bus - create an AC97 bus component
1737 * @card: the card instance
1738 * @num: the bus number
1739 * @ops: the bus callbacks table
1740 * @private_data: private data pointer for the new instance
1741 * @rbus: the pointer to store the new AC97 bus instance.
1742 *
1743 * Creates an AC97 bus component. An ac97_bus_t instance is newly
1744 * allocated and initialized.
1745 *
1746 * The ops table must include valid callbacks (at least read and
1747 * write). The other callbacks, wait and reset, are not mandatory.
1748 *
1749 * The clock is set to 48000. If another clock is needed, set
1750 * (*rbus)->clock manually.
1751 *
1752 * The AC97 bus instance is registered as a low-level device, so you don't
1753 * have to release it manually.
1754 *
1755 * Returns zero if successful, or a negative error code on failure.
1756 */
1757int snd_ac97_bus(snd_card_t *card, int num, ac97_bus_ops_t *ops,
1758 void *private_data, ac97_bus_t **rbus)
1759{
1760 int err;
1761 ac97_bus_t *bus;
1762 static snd_device_ops_t dev_ops = {
1763 .dev_free = snd_ac97_bus_dev_free,
1764 };
1765
1766 snd_assert(card != NULL, return -EINVAL);
1767 snd_assert(rbus != NULL, return -EINVAL);
1768 bus = kcalloc(1, sizeof(*bus), GFP_KERNEL);
1769 if (bus == NULL)
1770 return -ENOMEM;
1771 bus->card = card;
1772 bus->num = num;
1773 bus->ops = ops;
1774 bus->private_data = private_data;
1775 bus->clock = 48000;
1776 spin_lock_init(&bus->bus_lock);
1777 snd_ac97_bus_proc_init(bus);
1778 if ((err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops)) < 0) {
1779 snd_ac97_bus_free(bus);
1780 return err;
1781 }
1782 *rbus = bus;
1783 return 0;
1784}
1785
1786/* build_ops to do nothing */
1787static struct snd_ac97_build_ops null_build_ops;
1788
1789/**
1790 * snd_ac97_mixer - create an Codec97 component
1791 * @bus: the AC97 bus which codec is attached to
1792 * @template: the template of ac97, including index, callbacks and
1793 * the private data.
1794 * @rac97: the pointer to store the new ac97 instance.
1795 *
1796 * Creates an Codec97 component. An ac97_t instance is newly
1797 * allocated and initialized from the template. The codec
1798 * is then initialized by the standard procedure.
1799 *
1800 * The template must include the codec number (num) and address (addr),
1801 * and the private data (private_data).
1802 *
1803 * The ac97 instance is registered as a low-level device, so you don't
1804 * have to release it manually.
1805 *
1806 * Returns zero if successful, or a negative error code on failure.
1807 */
1808int snd_ac97_mixer(ac97_bus_t *bus, ac97_template_t *template, ac97_t **rac97)
1809{
1810 int err;
1811 ac97_t *ac97;
1812 snd_card_t *card;
1813 char name[64];
1814 unsigned long end_time;
1815 unsigned int reg;
1816 const ac97_codec_id_t *pid;
1817 static snd_device_ops_t ops = {
1818 .dev_free = snd_ac97_dev_free,
1819 };
1820
1821 snd_assert(rac97 != NULL, return -EINVAL);
1822 *rac97 = NULL;
1823 snd_assert(bus != NULL && template != NULL, return -EINVAL);
1824 snd_assert(template->num < 4 && bus->codec[template->num] == NULL, return -EINVAL);
1825
1826 snd_assert(bus->shared_type <= AC97_SHARED_TYPES, return -EINVAL);
1827 if (bus->shared_type) {
1828 /* already shared? */
1829 down(&shared_codec_mutex);
1830 ac97 = shared_codec[bus->shared_type-1][template->num];
1831 if (ac97) {
1832 if ((ac97_is_audio(ac97) && (template->scaps & AC97_SCAP_SKIP_AUDIO)) ||
1833 (ac97_is_modem(ac97) && (template->scaps & AC97_SCAP_SKIP_MODEM))) {
1834 up(&shared_codec_mutex);
1835 return -EACCES; /* skip this */
1836 }
1837 }
1838 up(&shared_codec_mutex);
1839 }
1840
1841 card = bus->card;
1842 ac97 = kcalloc(1, sizeof(*ac97), GFP_KERNEL);
1843 if (ac97 == NULL)
1844 return -ENOMEM;
1845 ac97->private_data = template->private_data;
1846 ac97->private_free = template->private_free;
1847 ac97->bus = bus;
1848 ac97->pci = template->pci;
1849 ac97->num = template->num;
1850 ac97->addr = template->addr;
1851 ac97->scaps = template->scaps;
1852 ac97->limited_regs = template->limited_regs;
1853 memcpy(ac97->reg_accessed, template->reg_accessed, sizeof(ac97->reg_accessed));
1854 bus->codec[ac97->num] = ac97;
1855 init_MUTEX(&ac97->reg_mutex);
1856 init_MUTEX(&ac97->page_mutex);
1857
1858 if (ac97->pci) {
1859 pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_VENDOR_ID, &ac97->subsystem_vendor);
1860 pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_ID, &ac97->subsystem_device);
1861 }
1862 if (bus->ops->reset) {
1863 bus->ops->reset(ac97);
1864 goto __access_ok;
1865 }
1866
1867 ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
1868 ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
1869 if (ac97->id && ac97->id != (unsigned int)-1) {
1870 pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
1871 if (pid && (pid->flags & AC97_DEFAULT_POWER_OFF))
1872 goto __access_ok;
1873 }
1874
1875 snd_ac97_write(ac97, AC97_RESET, 0); /* reset to defaults */
1876 if (bus->ops->wait)
1877 bus->ops->wait(ac97);
1878 else {
1879 udelay(50);
1880 if (ac97->scaps & AC97_SCAP_SKIP_AUDIO)
1881 err = ac97_reset_wait(ac97, HZ/2, 1);
1882 else {
1883 err = ac97_reset_wait(ac97, HZ/2, 0);
1884 if (err < 0)
1885 err = ac97_reset_wait(ac97, HZ/2, 1);
1886 }
1887 if (err < 0) {
1888 snd_printk(KERN_WARNING "AC'97 %d does not respond - RESET\n", ac97->num);
1889 /* proceed anyway - it's often non-critical */
1890 }
1891 }
1892 __access_ok:
1893 ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
1894 ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
1895 if (! (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) &&
1896 (ac97->id == 0x00000000 || ac97->id == 0xffffffff)) {
1897 snd_printk(KERN_ERR "AC'97 %d access is not valid [0x%x], removing mixer.\n", ac97->num, ac97->id);
1898 snd_ac97_free(ac97);
1899 return -EIO;
1900 }
1901 pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
1902 if (pid)
1903 ac97->flags |= pid->flags;
1904
1905 /* test for AC'97 */
1906 if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO) && !(ac97->scaps & AC97_SCAP_AUDIO)) {
1907 /* test if we can write to the record gain volume register */
1908 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a06);
1909 if (((err = snd_ac97_read(ac97, AC97_REC_GAIN)) & 0x7fff) == 0x0a06)
1910 ac97->scaps |= AC97_SCAP_AUDIO;
1911 }
1912 if (ac97->scaps & AC97_SCAP_AUDIO) {
1913 ac97->caps = snd_ac97_read(ac97, AC97_RESET);
1914 ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID);
1915 if (ac97->ext_id == 0xffff) /* invalid combination */
1916 ac97->ext_id = 0;
1917 }
1918
1919 /* test for MC'97 */
1920 if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM) && !(ac97->scaps & AC97_SCAP_MODEM)) {
1921 ac97->ext_mid = snd_ac97_read(ac97, AC97_EXTENDED_MID);
1922 if (ac97->ext_mid == 0xffff) /* invalid combination */
1923 ac97->ext_mid = 0;
1924 if (ac97->ext_mid & 1)
1925 ac97->scaps |= AC97_SCAP_MODEM;
1926 }
1927
1928 if (!ac97_is_audio(ac97) && !ac97_is_modem(ac97)) {
1929 if (!(ac97->scaps & (AC97_SCAP_SKIP_AUDIO|AC97_SCAP_SKIP_MODEM)))
1930 snd_printk(KERN_ERR "AC'97 %d access error (not audio or modem codec)\n", ac97->num);
1931 snd_ac97_free(ac97);
1932 return -EACCES;
1933 }
1934
1935 if (bus->ops->reset) // FIXME: always skipping?
1936 goto __ready_ok;
1937
1938 /* FIXME: add powerdown control */
1939 if (ac97_is_audio(ac97)) {
1940 /* nothing should be in powerdown mode */
1941 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
1942 if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
1943 snd_ac97_write_cache(ac97, AC97_RESET, 0); /* reset to defaults */
1944 udelay(100);
1945 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
1946 }
1947 /* nothing should be in powerdown mode */
1948 snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0);
1949 end_time = jiffies + (HZ / 10);
1950 do {
1951 if ((snd_ac97_read(ac97, AC97_POWERDOWN) & 0x0f) == 0x0f)
1952 goto __ready_ok;
1953 set_current_state(TASK_UNINTERRUPTIBLE);
1954 schedule_timeout(1);
1955 } while (time_after_eq(end_time, jiffies));
1956 snd_printk(KERN_WARNING "AC'97 %d analog subsections not ready\n", ac97->num);
1957 }
1958
1959 /* FIXME: add powerdown control */
1960 if (ac97_is_modem(ac97)) {
1961 unsigned char tmp;
1962
1963 /* nothing should be in powerdown mode */
1964 /* note: it's important to set the rate at first */
1965 tmp = AC97_MEA_GPIO;
1966 if (ac97->ext_mid & AC97_MEI_LINE1) {
1967 snd_ac97_write_cache(ac97, AC97_LINE1_RATE, 12000);
1968 tmp |= AC97_MEA_ADC1 | AC97_MEA_DAC1;
1969 }
1970 if (ac97->ext_mid & AC97_MEI_LINE2) {
1971 snd_ac97_write_cache(ac97, AC97_LINE2_RATE, 12000);
1972 tmp |= AC97_MEA_ADC2 | AC97_MEA_DAC2;
1973 }
1974 if (ac97->ext_mid & AC97_MEI_HANDSET) {
1975 snd_ac97_write_cache(ac97, AC97_HANDSET_RATE, 12000);
1976 tmp |= AC97_MEA_HADC | AC97_MEA_HDAC;
1977 }
1978 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0xff00 & ~(tmp << 8));
1979 udelay(100);
1980 /* nothing should be in powerdown mode */
1981 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0xff00 & ~(tmp << 8));
1982 end_time = jiffies + (HZ / 10);
1983 do {
1984 if ((snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS) & tmp) == tmp)
1985 goto __ready_ok;
1986 set_current_state(TASK_UNINTERRUPTIBLE);
1987 schedule_timeout(1);
1988 } while (time_after_eq(end_time, jiffies));
1989 snd_printk(KERN_WARNING "MC'97 %d converters and GPIO not ready (0x%x)\n", ac97->num, snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS));
1990 }
1991
1992 __ready_ok:
1993 if (ac97_is_audio(ac97))
1994 ac97->addr = (ac97->ext_id & AC97_EI_ADDR_MASK) >> AC97_EI_ADDR_SHIFT;
1995 else
1996 ac97->addr = (ac97->ext_mid & AC97_MEI_ADDR_MASK) >> AC97_MEI_ADDR_SHIFT;
1997 if (ac97->ext_id & 0x01c9) { /* L/R, MIC, SDAC, LDAC VRA support */
1998 reg = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
1999 reg |= ac97->ext_id & 0x01c0; /* LDAC/SDAC/CDAC */
2000 if (! bus->no_vra)
2001 reg |= ac97->ext_id & 0x0009; /* VRA/VRM */
2002 snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, reg);
2003 }
2004 if ((ac97->ext_id & AC97_EI_DRA) && bus->dra) {
2005 /* Intel controllers require double rate data to be put in
2006 * slots 7+8, so let's hope the codec supports it. */
2007 snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, AC97_GP_DRSS_MASK, AC97_GP_DRSS_78);
2008 if ((snd_ac97_read(ac97, AC97_GENERAL_PURPOSE) & AC97_GP_DRSS_MASK) == AC97_GP_DRSS_78)
2009 ac97->flags |= AC97_DOUBLE_RATE;
2010 }
2011 if (ac97->ext_id & AC97_EI_VRA) { /* VRA support */
2012 snd_ac97_determine_rates(ac97, AC97_PCM_FRONT_DAC_RATE, 0, &ac97->rates[AC97_RATES_FRONT_DAC]);
2013 snd_ac97_determine_rates(ac97, AC97_PCM_LR_ADC_RATE, 0, &ac97->rates[AC97_RATES_ADC]);
2014 } else {
2015 ac97->rates[AC97_RATES_FRONT_DAC] = SNDRV_PCM_RATE_48000;
2016 if (ac97->flags & AC97_DOUBLE_RATE)
2017 ac97->rates[AC97_RATES_FRONT_DAC] |= SNDRV_PCM_RATE_96000;
2018 ac97->rates[AC97_RATES_ADC] = SNDRV_PCM_RATE_48000;
2019 }
2020 if (ac97->ext_id & AC97_EI_SPDIF) {
2021 /* codec specific code (patch) should override these values */
2022 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_32000;
2023 }
2024 if (ac97->ext_id & AC97_EI_VRM) { /* MIC VRA support */
2025 snd_ac97_determine_rates(ac97, AC97_PCM_MIC_ADC_RATE, 0, &ac97->rates[AC97_RATES_MIC_ADC]);
2026 } else {
2027 ac97->rates[AC97_RATES_MIC_ADC] = SNDRV_PCM_RATE_48000;
2028 }
2029 if (ac97->ext_id & AC97_EI_SDAC) { /* SDAC support */
2030 snd_ac97_determine_rates(ac97, AC97_PCM_SURR_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_SURR_DAC]);
2031 ac97->scaps |= AC97_SCAP_SURROUND_DAC;
2032 }
2033 if (ac97->ext_id & AC97_EI_LDAC) { /* LDAC support */
2034 snd_ac97_determine_rates(ac97, AC97_PCM_LFE_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_LFE_DAC]);
2035 ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC;
2036 }
2037 /* additional initializations */
2038 if (bus->ops->init)
2039 bus->ops->init(ac97);
2040 snd_ac97_get_name(ac97, ac97->id, name, !ac97_is_audio(ac97));
2041 snd_ac97_get_name(NULL, ac97->id, name, !ac97_is_audio(ac97)); // ac97->id might be changed in the special setup code
2042 if (! ac97->build_ops)
2043 ac97->build_ops = &null_build_ops;
2044
2045 if (ac97_is_audio(ac97)) {
2046 char comp[16];
2047 if (card->mixername[0] == '\0') {
2048 strcpy(card->mixername, name);
2049 } else {
2050 if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
2051 strcat(card->mixername, ",");
2052 strcat(card->mixername, name);
2053 }
2054 }
2055 sprintf(comp, "AC97a:%08x", ac97->id);
2056 if ((err = snd_component_add(card, comp)) < 0) {
2057 snd_ac97_free(ac97);
2058 return err;
2059 }
2060 if (snd_ac97_mixer_build(ac97) < 0) {
2061 snd_ac97_free(ac97);
2062 return -ENOMEM;
2063 }
2064 }
2065 if (ac97_is_modem(ac97)) {
2066 char comp[16];
2067 if (card->mixername[0] == '\0') {
2068 strcpy(card->mixername, name);
2069 } else {
2070 if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
2071 strcat(card->mixername, ",");
2072 strcat(card->mixername, name);
2073 }
2074 }
2075 sprintf(comp, "AC97m:%08x", ac97->id);
2076 if ((err = snd_component_add(card, comp)) < 0) {
2077 snd_ac97_free(ac97);
2078 return err;
2079 }
2080 if (snd_ac97_modem_build(card, ac97) < 0) {
2081 snd_ac97_free(ac97);
2082 return -ENOMEM;
2083 }
2084 }
2085 /* make sure the proper powerdown bits are cleared */
2086 if (ac97->scaps) {
2087 reg = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
2088 if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
2089 reg &= ~AC97_EA_PRJ;
2090 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
2091 reg &= ~(AC97_EA_PRI | AC97_EA_PRK);
2092 snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, reg);
2093 }
2094 snd_ac97_proc_init(ac97);
2095 if ((err = snd_device_new(card, SNDRV_DEV_CODEC, ac97, &ops)) < 0) {
2096 snd_ac97_free(ac97);
2097 return err;
2098 }
2099 *rac97 = ac97;
2100
2101 if (bus->shared_type) {
2102 down(&shared_codec_mutex);
2103 shared_codec[bus->shared_type-1][ac97->num] = ac97;
2104 up(&shared_codec_mutex);
2105 }
2106
2107 return 0;
2108}
2109
2110
2111/*
2112 * Power down the chip.
2113 *
2114 * MASTER and HEADPHONE registers are muted but the register cache values
2115 * are not changed, so that the values can be restored in snd_ac97_resume().
2116 */
2117static void snd_ac97_powerdown(ac97_t *ac97)
2118{
2119 unsigned short power;
2120
2121 if (ac97_is_audio(ac97)) {
2122 /* some codecs have stereo mute bits */
2123 snd_ac97_write(ac97, AC97_MASTER, 0x9f9f);
2124 snd_ac97_write(ac97, AC97_HEADPHONE, 0x9f9f);
2125 }
2126
2127 power = ac97->regs[AC97_POWERDOWN] | 0x8000; /* EAPD */
2128 power |= 0x4000; /* Headphone amplifier powerdown */
2129 power |= 0x0300; /* ADC & DAC powerdown */
2130 snd_ac97_write(ac97, AC97_POWERDOWN, power);
2131 udelay(100);
2132 power |= 0x0400; /* Analog Mixer powerdown (Vref on) */
2133 snd_ac97_write(ac97, AC97_POWERDOWN, power);
2134 udelay(100);
2135#if 0
2136 /* FIXME: this causes click noises on some boards at resume */
2137 power |= 0x3800; /* AC-link powerdown, internal Clk disable */
2138 snd_ac97_write(ac97, AC97_POWERDOWN, power);
2139#endif
2140}
2141
2142
2143#ifdef CONFIG_PM
2144/**
2145 * snd_ac97_suspend - General suspend function for AC97 codec
2146 * @ac97: the ac97 instance
2147 *
2148 * Suspends the codec, power down the chip.
2149 */
2150void snd_ac97_suspend(ac97_t *ac97)
2151{
2152 if (ac97->build_ops->suspend)
2153 ac97->build_ops->suspend(ac97);
2154 snd_ac97_powerdown(ac97);
2155}
2156
2157/*
2158 * restore ac97 status
2159 */
2160void snd_ac97_restore_status(ac97_t *ac97)
2161{
2162 int i;
2163
2164 for (i = 2; i < 0x7c ; i += 2) {
2165 if (i == AC97_POWERDOWN || i == AC97_EXTENDED_ID)
2166 continue;
2167 /* restore only accessible registers
2168 * some chip (e.g. nm256) may hang up when unsupported registers
2169 * are accessed..!
2170 */
2171 if (test_bit(i, ac97->reg_accessed)) {
2172 snd_ac97_write(ac97, i, ac97->regs[i]);
2173 snd_ac97_read(ac97, i);
2174 }
2175 }
2176}
2177
2178/*
2179 * restore IEC958 status
2180 */
2181void snd_ac97_restore_iec958(ac97_t *ac97)
2182{
2183 if (ac97->ext_id & AC97_EI_SPDIF) {
2184 if (ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_SPDIF) {
2185 /* reset spdif status */
2186 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
2187 snd_ac97_write(ac97, AC97_EXTENDED_STATUS, ac97->regs[AC97_EXTENDED_STATUS]);
2188 if (ac97->flags & AC97_CS_SPDIF)
2189 snd_ac97_write(ac97, AC97_CSR_SPDIF, ac97->regs[AC97_CSR_SPDIF]);
2190 else
2191 snd_ac97_write(ac97, AC97_SPDIF, ac97->regs[AC97_SPDIF]);
2192 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
2193 }
2194 }
2195}
2196
2197/**
2198 * snd_ac97_resume - General resume function for AC97 codec
2199 * @ac97: the ac97 instance
2200 *
2201 * Do the standard resume procedure, power up and restoring the
2202 * old register values.
2203 */
2204void snd_ac97_resume(ac97_t *ac97)
2205{
2206 int i;
2207
2208 if (ac97->bus->ops->reset) {
2209 ac97->bus->ops->reset(ac97);
2210 goto __reset_ready;
2211 }
2212
2213 snd_ac97_write(ac97, AC97_POWERDOWN, 0);
2214 if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
2215 snd_ac97_write(ac97, AC97_RESET, 0);
2216 udelay(100);
2217 snd_ac97_write(ac97, AC97_POWERDOWN, 0);
2218 }
2219 snd_ac97_write(ac97, AC97_GENERAL_PURPOSE, 0);
2220
2221 snd_ac97_write(ac97, AC97_POWERDOWN, ac97->regs[AC97_POWERDOWN]);
2222 if (ac97_is_audio(ac97)) {
2223 ac97->bus->ops->write(ac97, AC97_MASTER, 0x8101);
2224 for (i = HZ/10; i >= 0; i--) {
2225 if (snd_ac97_read(ac97, AC97_MASTER) == 0x8101)
2226 break;
2227 set_current_state(TASK_UNINTERRUPTIBLE);
2228 schedule_timeout(1);
2229 }
2230 /* FIXME: extra delay */
2231 ac97->bus->ops->write(ac97, AC97_MASTER, 0x8000);
2232 if (snd_ac97_read(ac97, AC97_MASTER) != 0x8000) {
2233 set_current_state(TASK_UNINTERRUPTIBLE);
2234 schedule_timeout(HZ/4);
2235 }
2236 } else {
2237 for (i = HZ/10; i >= 0; i--) {
2238 unsigned short val = snd_ac97_read(ac97, AC97_EXTENDED_MID);
2239 if (val != 0xffff && (val & 1) != 0)
2240 break;
2241 set_current_state(TASK_UNINTERRUPTIBLE);
2242 schedule_timeout(1);
2243 }
2244 }
2245__reset_ready:
2246
2247 if (ac97->bus->ops->init)
2248 ac97->bus->ops->init(ac97);
2249
2250 if (ac97->build_ops->resume)
2251 ac97->build_ops->resume(ac97);
2252 else {
2253 snd_ac97_restore_status(ac97);
2254 snd_ac97_restore_iec958(ac97);
2255 }
2256}
2257#endif
2258
2259
2260/*
2261 * Hardware tuning
2262 */
2263static void set_ctl_name(char *dst, const char *src, const char *suffix)
2264{
2265 if (suffix)
2266 sprintf(dst, "%s %s", src, suffix);
2267 else
2268 strcpy(dst, src);
2269}
2270
2271/* remove the control with the given name and optional suffix */
2272int snd_ac97_remove_ctl(ac97_t *ac97, const char *name, const char *suffix)
2273{
2274 snd_ctl_elem_id_t id;
2275 memset(&id, 0, sizeof(id));
2276 set_ctl_name(id.name, name, suffix);
2277 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2278 return snd_ctl_remove_id(ac97->bus->card, &id);
2279}
2280
2281static snd_kcontrol_t *ctl_find(ac97_t *ac97, const char *name, const char *suffix)
2282{
2283 snd_ctl_elem_id_t sid;
2284 memset(&sid, 0, sizeof(sid));
2285 set_ctl_name(sid.name, name, suffix);
2286 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2287 return snd_ctl_find_id(ac97->bus->card, &sid);
2288}
2289
2290/* rename the control with the given name and optional suffix */
2291int snd_ac97_rename_ctl(ac97_t *ac97, const char *src, const char *dst, const char *suffix)
2292{
2293 snd_kcontrol_t *kctl = ctl_find(ac97, src, suffix);
2294 if (kctl) {
2295 set_ctl_name(kctl->id.name, dst, suffix);
2296 return 0;
2297 }
2298 return -ENOENT;
2299}
2300
2301/* rename both Volume and Switch controls - don't check the return value */
2302void snd_ac97_rename_vol_ctl(ac97_t *ac97, const char *src, const char *dst)
2303{
2304 snd_ac97_rename_ctl(ac97, src, dst, "Switch");
2305 snd_ac97_rename_ctl(ac97, src, dst, "Volume");
2306}
2307
2308/* swap controls */
2309int snd_ac97_swap_ctl(ac97_t *ac97, const char *s1, const char *s2, const char *suffix)
2310{
2311 snd_kcontrol_t *kctl1, *kctl2;
2312 kctl1 = ctl_find(ac97, s1, suffix);
2313 kctl2 = ctl_find(ac97, s2, suffix);
2314 if (kctl1 && kctl2) {
2315 set_ctl_name(kctl1->id.name, s2, suffix);
2316 set_ctl_name(kctl2->id.name, s1, suffix);
2317 return 0;
2318 }
2319 return -ENOENT;
2320}
2321
2322#if 1
2323/* bind hp and master controls instead of using only hp control */
2324static int bind_hp_volsw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
2325{
2326 int err = snd_ac97_put_volsw(kcontrol, ucontrol);
2327 if (err > 0) {
2328 unsigned long priv_saved = kcontrol->private_value;
2329 kcontrol->private_value = (kcontrol->private_value & ~0xff) | AC97_HEADPHONE;
2330 snd_ac97_put_volsw(kcontrol, ucontrol);
2331 kcontrol->private_value = priv_saved;
2332 }
2333 return err;
2334}
2335
2336/* ac97 tune: bind Master and Headphone controls */
2337static int tune_hp_only(ac97_t *ac97)
2338{
2339 snd_kcontrol_t *msw = ctl_find(ac97, "Master Playback Switch", NULL);
2340 snd_kcontrol_t *mvol = ctl_find(ac97, "Master Playback Volume", NULL);
2341 if (! msw || ! mvol)
2342 return -ENOENT;
2343 msw->put = bind_hp_volsw_put;
2344 mvol->put = bind_hp_volsw_put;
2345 snd_ac97_remove_ctl(ac97, "Headphone Playback", "Switch");
2346 snd_ac97_remove_ctl(ac97, "Headphone Playback", "Volume");
2347 return 0;
2348}
2349
2350#else
2351/* ac97 tune: use Headphone control as master */
2352static int tune_hp_only(ac97_t *ac97)
2353{
2354 if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL)
2355 return -ENOENT;
2356 snd_ac97_remove_ctl(ac97, "Master Playback", "Switch");
2357 snd_ac97_remove_ctl(ac97, "Master Playback", "Volume");
2358 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
2359 return 0;
2360}
2361#endif
2362
2363/* ac97 tune: swap Headphone and Master controls */
2364static int tune_swap_hp(ac97_t *ac97)
2365{
2366 if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL)
2367 return -ENOENT;
2368 snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Line-Out Playback");
2369 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
2370 return 0;
2371}
2372
2373/* ac97 tune: swap Surround and Master controls */
2374static int tune_swap_surround(ac97_t *ac97)
2375{
2376 if (snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Switch") ||
2377 snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Volume"))
2378 return -ENOENT;
2379 return 0;
2380}
2381
2382/* ac97 tune: set up mic sharing for AD codecs */
2383static int tune_ad_sharing(ac97_t *ac97)
2384{
2385 unsigned short scfg;
2386 if ((ac97->id & 0xffffff00) != 0x41445300) {
2387 snd_printk(KERN_ERR "ac97_quirk AD_SHARING is only for AD codecs\n");
2388 return -EINVAL;
2389 }
2390 /* Turn on OMS bit to route microphone to back panel */
2391 scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
2392 snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x0200);
2393 return 0;
2394}
2395
2396static const snd_kcontrol_new_t snd_ac97_alc_jack_detect =
2397AC97_SINGLE("Jack Detect", AC97_ALC650_CLOCK, 5, 1, 0);
2398
2399/* ac97 tune: set up ALC jack-select */
2400static int tune_alc_jack(ac97_t *ac97)
2401{
2402 if ((ac97->id & 0xffffff00) != 0x414c4700) {
2403 snd_printk(KERN_ERR "ac97_quirk ALC_JACK is only for Realtek codecs\n");
2404 return -EINVAL;
2405 }
2406 snd_ac97_update_bits(ac97, 0x7a, 0x20, 0x20); /* select jack detect function */
2407 snd_ac97_update_bits(ac97, 0x7a, 0x01, 0x01); /* Line-out auto mute */
2408 return snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&snd_ac97_alc_jack_detect, ac97));
2409}
2410
2411/* ac97 tune: inversed EAPD bit */
2412static int tune_inv_eapd(ac97_t *ac97)
2413{
2414 snd_kcontrol_t *kctl = ctl_find(ac97, "External Amplifier", NULL);
2415 if (! kctl)
2416 return -ENOENT;
2417 set_inv_eapd(ac97, kctl);
2418 return 0;
2419}
2420
2421static int master_mute_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
2422{
2423 int err = snd_ac97_put_volsw(kcontrol, ucontrol);
2424 if (err > 0) {
2425 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
2426 int shift = (kcontrol->private_value >> 8) & 0x0f;
2427 int rshift = (kcontrol->private_value >> 12) & 0x0f;
2428 unsigned short mask;
2429 if (shift != rshift)
2430 mask = 0x8080;
2431 else
2432 mask = 0x8000;
2433 snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000,
2434 (ac97->regs[AC97_MASTER] & mask) == mask ?
2435 0x8000 : 0);
2436 }
2437 return err;
2438}
2439
2440/* ac97 tune: EAPD controls mute LED bound with the master mute */
2441static int tune_mute_led(ac97_t *ac97)
2442{
2443 snd_kcontrol_t *msw = ctl_find(ac97, "Master Playback Switch", NULL);
2444 if (! msw)
2445 return -ENOENT;
2446 msw->put = master_mute_sw_put;
2447 snd_ac97_remove_ctl(ac97, "External Amplifier", NULL);
2448 snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000, 0x8000); /* mute LED on */
2449 return 0;
2450}
2451
2452struct quirk_table {
2453 const char *name;
2454 int (*func)(ac97_t *);
2455};
2456
2457static struct quirk_table applicable_quirks[] = {
2458 { "none", NULL },
2459 { "hp_only", tune_hp_only },
2460 { "swap_hp", tune_swap_hp },
2461 { "swap_surround", tune_swap_surround },
2462 { "ad_sharing", tune_ad_sharing },
2463 { "alc_jack", tune_alc_jack },
2464 { "inv_eapd", tune_inv_eapd },
2465 { "mute_led", tune_mute_led },
2466};
2467
2468/* apply the quirk with the given type */
2469static int apply_quirk(ac97_t *ac97, int type)
2470{
2471 if (type <= 0)
2472 return 0;
2473 else if (type >= ARRAY_SIZE(applicable_quirks))
2474 return -EINVAL;
2475 if (applicable_quirks[type].func)
2476 return applicable_quirks[type].func(ac97);
2477 return 0;
2478}
2479
2480/* apply the quirk with the given name */
2481static int apply_quirk_str(ac97_t *ac97, const char *typestr)
2482{
2483 int i;
2484 struct quirk_table *q;
2485
2486 for (i = 0; i < ARRAY_SIZE(applicable_quirks); i++) {
2487 q = &applicable_quirks[i];
2488 if (q->name && ! strcmp(typestr, q->name))
2489 return apply_quirk(ac97, i);
2490 }
2491 /* for compatibility, accept the numbers, too */
2492 if (*typestr >= '0' && *typestr <= '9')
2493 return apply_quirk(ac97, (int)simple_strtoul(typestr, NULL, 10));
2494 return -EINVAL;
2495}
2496
2497/**
2498 * snd_ac97_tune_hardware - tune up the hardware
2499 * @ac97: the ac97 instance
2500 * @quirk: quirk list
2501 * @override: explicit quirk value (overrides the list if non-NULL)
2502 *
2503 * Do some workaround for each pci device, such as renaming of the
2504 * headphone (true line-out) control as "Master".
2505 * The quirk-list must be terminated with a zero-filled entry.
2506 *
2507 * Returns zero if successful, or a negative error code on failure.
2508 */
2509
2510int snd_ac97_tune_hardware(ac97_t *ac97, struct ac97_quirk *quirk, const char *override)
2511{
2512 int result;
2513
2514 snd_assert(quirk, return -EINVAL);
2515
2516 /* quirk overriden? */
2517 if (override && strcmp(override, "-1") && strcmp(override, "default")) {
2518 result = apply_quirk_str(ac97, override);
2519 if (result < 0)
2520 snd_printk(KERN_ERR "applying quirk type %s failed (%d)\n", override, result);
2521 return result;
2522 }
2523
2524 for (; quirk->vendor; quirk++) {
2525 if (quirk->vendor != ac97->subsystem_vendor)
2526 continue;
2527 if ((! quirk->mask && quirk->device == ac97->subsystem_device) ||
2528 quirk->device == (quirk->mask & ac97->subsystem_device)) {
2529 if (quirk->codec_id && quirk->codec_id != ac97->id)
2530 continue;
2531 snd_printdd("ac97 quirk for %s (%04x:%04x)\n", quirk->name, ac97->subsystem_vendor, ac97->subsystem_device);
2532 result = apply_quirk(ac97, quirk->type);
2533 if (result < 0)
2534 snd_printk(KERN_ERR "applying quirk type %d for %s failed (%d)\n", quirk->type, quirk->name, result);
2535 return result;
2536 }
2537 }
2538 return 0;
2539}
2540
2541
2542/*
2543 * Exported symbols
2544 */
2545
2546EXPORT_SYMBOL(snd_ac97_write);
2547EXPORT_SYMBOL(snd_ac97_read);
2548EXPORT_SYMBOL(snd_ac97_write_cache);
2549EXPORT_SYMBOL(snd_ac97_update);
2550EXPORT_SYMBOL(snd_ac97_update_bits);
2551EXPORT_SYMBOL(snd_ac97_get_short_name);
2552EXPORT_SYMBOL(snd_ac97_bus);
2553EXPORT_SYMBOL(snd_ac97_mixer);
2554EXPORT_SYMBOL(snd_ac97_pcm_assign);
2555EXPORT_SYMBOL(snd_ac97_pcm_open);
2556EXPORT_SYMBOL(snd_ac97_pcm_close);
2557EXPORT_SYMBOL(snd_ac97_pcm_double_rate_rules);
2558EXPORT_SYMBOL(snd_ac97_tune_hardware);
2559EXPORT_SYMBOL(snd_ac97_set_rate);
2560#ifdef CONFIG_PM
2561EXPORT_SYMBOL(snd_ac97_resume);
2562EXPORT_SYMBOL(snd_ac97_suspend);
2563#endif
2564
2565/*
2566 * INIT part
2567 */
2568
2569static int __init alsa_ac97_init(void)
2570{
2571 return 0;
2572}
2573
2574static void __exit alsa_ac97_exit(void)
2575{
2576}
2577
2578module_init(alsa_ac97_init)
2579module_exit(alsa_ac97_exit)
diff --git a/sound/pci/ac97/ac97_id.h b/sound/pci/ac97/ac97_id.h
new file mode 100644
index 000000000000..dadf387ad0b8
--- /dev/null
+++ b/sound/pci/ac97/ac97_id.h
@@ -0,0 +1,62 @@
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Universal interface for Audio Codec '97
4 *
5 * For more details look to AC '97 component specification revision 2.2
6 * by Intel Corporation (http://developer.intel.com).
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 */
24
25#define AC97_ID_AK4540 0x414b4d00
26#define AC97_ID_AK4542 0x414b4d01
27#define AC97_ID_AD1819 0x41445303
28#define AC97_ID_AD1881 0x41445340
29#define AC97_ID_AD1881A 0x41445348
30#define AC97_ID_AD1885 0x41445360
31#define AC97_ID_AD1886 0x41445361
32#define AC97_ID_AD1887 0x41445362
33#define AC97_ID_AD1886A 0x41445363
34#define AC97_ID_AD1980 0x41445370
35#define AC97_ID_TR28028 0x54524108
36#define AC97_ID_STAC9700 0x83847600
37#define AC97_ID_STAC9704 0x83847604
38#define AC97_ID_STAC9705 0x83847605
39#define AC97_ID_STAC9708 0x83847608
40#define AC97_ID_STAC9721 0x83847609
41#define AC97_ID_STAC9744 0x83847644
42#define AC97_ID_STAC9756 0x83847656
43#define AC97_ID_CS4297A 0x43525910
44#define AC97_ID_CS4299 0x43525930
45#define AC97_ID_CS4201 0x43525948
46#define AC97_ID_CS4205 0x43525958
47#define AC97_ID_CS_MASK 0xfffffff8 /* bit 0-2: rev */
48#define AC97_ID_ALC100 0x414c4300
49#define AC97_ID_ALC650 0x414c4720
50#define AC97_ID_ALC650D 0x414c4721
51#define AC97_ID_ALC650E 0x414c4722
52#define AC97_ID_ALC650F 0x414c4723
53#define AC97_ID_ALC655 0x414c4760
54#define AC97_ID_ALC658 0x414c4780
55#define AC97_ID_ALC850 0x414c4790
56#define AC97_ID_YMF753 0x594d4803
57#define AC97_ID_VT1616 0x49434551
58#define AC97_ID_CM9738 0x434d4941
59#define AC97_ID_CM9739 0x434d4961
60#define AC97_ID_CM9761_78 0x434d4978
61#define AC97_ID_CM9761_82 0x434d4982
62#define AC97_ID_CM9761_83 0x434d4983
diff --git a/sound/pci/ac97/ac97_local.h b/sound/pci/ac97/ac97_local.h
new file mode 100644
index 000000000000..536a4d4793af
--- /dev/null
+++ b/sound/pci/ac97/ac97_local.h
@@ -0,0 +1,83 @@
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Universal interface for Audio Codec '97
4 *
5 * For more details look to AC '97 component specification revision 2.2
6 * by Intel Corporation (http://developer.intel.com).
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 */
24
25#define AC97_SINGLE_VALUE(reg,shift,mask,invert) ((reg) | ((shift) << 8) | ((shift) << 12) | ((mask) << 16) | ((invert) << 24))
26#define AC97_PAGE_SINGLE_VALUE(reg,shift,mask,invert,page) (AC97_SINGLE_VALUE(reg,shift,mask,invert) | (1<<25) | ((page) << 26))
27#define AC97_SINGLE(xname, reg, shift, mask, invert) \
28{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_info_volsw, \
29 .get = snd_ac97_get_volsw, .put = snd_ac97_put_volsw, \
30 .private_value = AC97_SINGLE_VALUE(reg, shift, mask, invert) }
31#define AC97_PAGE_SINGLE(xname, reg, shift, mask, invert, page) \
32{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_info_volsw, \
33 .get = snd_ac97_get_volsw, .put = snd_ac97_put_volsw, \
34 .private_value = AC97_PAGE_SINGLE_VALUE(reg, shift, mask, invert, page) }
35#define AC97_DOUBLE(xname, reg, shift_left, shift_right, mask, invert) \
36{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), .info = snd_ac97_info_volsw, \
37 .get = snd_ac97_get_volsw, .put = snd_ac97_put_volsw, \
38 .private_value = (reg) | ((shift_left) << 8) | ((shift_right) << 12) | ((mask) << 16) | ((invert) << 24) }
39#define AC97_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xtexts) \
40{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
41 .mask = xmask, .texts = xtexts }
42#define AC97_ENUM_SINGLE(xreg, xshift, xmask, xtexts) \
43 AC97_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xtexts)
44#define AC97_ENUM(xname, xenum) \
45{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_info_enum_double, \
46 .get = snd_ac97_get_enum_double, .put = snd_ac97_put_enum_double, \
47 .private_value = (unsigned long)&xenum }
48
49/* ac97_codec.c */
50extern const char *snd_ac97_stereo_enhancements[];
51extern const snd_kcontrol_new_t snd_ac97_controls_3d[];
52extern const snd_kcontrol_new_t snd_ac97_controls_spdif[];
53snd_kcontrol_t *snd_ac97_cnew(const snd_kcontrol_new_t *_template, ac97_t * ac97);
54void snd_ac97_get_name(ac97_t *ac97, unsigned int id, char *name, int modem);
55int snd_ac97_info_volsw(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo);
56int snd_ac97_get_volsw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
57int snd_ac97_put_volsw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
58int snd_ac97_try_bit(ac97_t * ac97, int reg, int bit);
59int snd_ac97_remove_ctl(ac97_t *ac97, const char *name, const char *suffix);
60int snd_ac97_rename_ctl(ac97_t *ac97, const char *src, const char *dst, const char *suffix);
61int snd_ac97_swap_ctl(ac97_t *ac97, const char *s1, const char *s2, const char *suffix);
62void snd_ac97_rename_vol_ctl(ac97_t *ac97, const char *src, const char *dst);
63void snd_ac97_restore_status(ac97_t *ac97);
64void snd_ac97_restore_iec958(ac97_t *ac97);
65int snd_ac97_info_enum_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo);
66int snd_ac97_get_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
67int snd_ac97_put_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
68
69int snd_ac97_update_bits_nolock(ac97_t *ac97, unsigned short reg,
70 unsigned short mask, unsigned short value);
71
72/* ac97_proc.c */
73#ifdef CONFIG_PROC_FS
74void snd_ac97_bus_proc_init(ac97_bus_t * ac97);
75void snd_ac97_bus_proc_done(ac97_bus_t * ac97);
76void snd_ac97_proc_init(ac97_t * ac97);
77void snd_ac97_proc_done(ac97_t * ac97);
78#else
79#define snd_ac97_bus_proc_init(ac97_bus_t) do { } while (0)
80#define snd_ac97_bus_proc_done(ac97_bus_t) do { } while (0)
81#define snd_ac97_proc_init(ac97_t) do { } while (0)
82#define snd_ac97_proc_done(ac97_t) do { } while (0)
83#endif
diff --git a/sound/pci/ac97/ac97_patch.c b/sound/pci/ac97/ac97_patch.c
new file mode 100644
index 000000000000..13c34a5d8206
--- /dev/null
+++ b/sound/pci/ac97/ac97_patch.c
@@ -0,0 +1,2309 @@
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Universal interface for Audio Codec '97
4 *
5 * For more details look to AC '97 component specification revision 2.2
6 * by Intel Corporation (http://developer.intel.com) and to datasheets
7 * for specific codecs.
8 *
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
25
26#include <sound/driver.h>
27#include <linux/delay.h>
28#include <linux/init.h>
29#include <linux/slab.h>
30#include <sound/core.h>
31#include <sound/pcm.h>
32#include <sound/control.h>
33#include <sound/ac97_codec.h>
34#include "ac97_patch.h"
35#include "ac97_id.h"
36#include "ac97_local.h"
37
38/*
39 * Chip specific initialization
40 */
41
42static int patch_build_controls(ac97_t * ac97, const snd_kcontrol_new_t *controls, int count)
43{
44 int idx, err;
45
46 for (idx = 0; idx < count; idx++)
47 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&controls[idx], ac97))) < 0)
48 return err;
49 return 0;
50}
51
52/* set to the page, update bits and restore the page */
53static int ac97_update_bits_page(ac97_t *ac97, unsigned short reg, unsigned short mask, unsigned short value, unsigned short page)
54{
55 unsigned short page_save;
56 int ret;
57
58 down(&ac97->page_mutex);
59 page_save = snd_ac97_read(ac97, AC97_INT_PAGING) & AC97_PAGE_MASK;
60 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page);
61 ret = snd_ac97_update_bits(ac97, reg, mask, value);
62 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save);
63 up(&ac97->page_mutex); /* unlock paging */
64 return ret;
65}
66
67/* The following snd_ac97_ymf753_... items added by David Shust (dshust@shustring.com) */
68
69/* It is possible to indicate to the Yamaha YMF753 the type of speakers being used. */
70static int snd_ac97_ymf753_info_speaker(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
71{
72 static char *texts[3] = {
73 "Standard", "Small", "Smaller"
74 };
75
76 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
77 uinfo->count = 1;
78 uinfo->value.enumerated.items = 3;
79 if (uinfo->value.enumerated.item > 2)
80 uinfo->value.enumerated.item = 2;
81 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
82 return 0;
83}
84
85static int snd_ac97_ymf753_get_speaker(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
86{
87 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
88 unsigned short val;
89
90 val = ac97->regs[AC97_YMF753_3D_MODE_SEL];
91 val = (val >> 10) & 3;
92 if (val > 0) /* 0 = invalid */
93 val--;
94 ucontrol->value.enumerated.item[0] = val;
95 return 0;
96}
97
98static int snd_ac97_ymf753_put_speaker(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
99{
100 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
101 unsigned short val;
102
103 if (ucontrol->value.enumerated.item[0] > 2)
104 return -EINVAL;
105 val = (ucontrol->value.enumerated.item[0] + 1) << 10;
106 return snd_ac97_update(ac97, AC97_YMF753_3D_MODE_SEL, val);
107}
108
109static const snd_kcontrol_new_t snd_ac97_ymf753_controls_speaker =
110{
111 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
112 .name = "3D Control - Speaker",
113 .info = snd_ac97_ymf753_info_speaker,
114 .get = snd_ac97_ymf753_get_speaker,
115 .put = snd_ac97_ymf753_put_speaker,
116};
117
118/* It is possible to indicate to the Yamaha YMF753 the source to direct to the S/PDIF output. */
119static int snd_ac97_ymf753_spdif_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
120{
121 static char *texts[2] = { "AC-Link", "A/D Converter" };
122
123 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
124 uinfo->count = 1;
125 uinfo->value.enumerated.items = 2;
126 if (uinfo->value.enumerated.item > 1)
127 uinfo->value.enumerated.item = 1;
128 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
129 return 0;
130}
131
132static int snd_ac97_ymf753_spdif_source_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
133{
134 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
135 unsigned short val;
136
137 val = ac97->regs[AC97_YMF753_DIT_CTRL2];
138 ucontrol->value.enumerated.item[0] = (val >> 1) & 1;
139 return 0;
140}
141
142static int snd_ac97_ymf753_spdif_source_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
143{
144 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
145 unsigned short val;
146
147 if (ucontrol->value.enumerated.item[0] > 1)
148 return -EINVAL;
149 val = ucontrol->value.enumerated.item[0] << 1;
150 return snd_ac97_update_bits(ac97, AC97_YMF753_DIT_CTRL2, 0x0002, val);
151}
152
153/* The AC'97 spec states that the S/PDIF signal is to be output at pin 48.
154 The YMF753 will output the S/PDIF signal to pin 43, 47 (EAPD), or 48.
155 By default, no output pin is selected, and the S/PDIF signal is not output.
156 There is also a bit to mute S/PDIF output in a vendor-specific register. */
157static int snd_ac97_ymf753_spdif_output_pin_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
158{
159 static char *texts[3] = { "Disabled", "Pin 43", "Pin 48" };
160
161 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
162 uinfo->count = 1;
163 uinfo->value.enumerated.items = 3;
164 if (uinfo->value.enumerated.item > 2)
165 uinfo->value.enumerated.item = 2;
166 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
167 return 0;
168}
169
170static int snd_ac97_ymf753_spdif_output_pin_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
171{
172 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
173 unsigned short val;
174
175 val = ac97->regs[AC97_YMF753_DIT_CTRL2];
176 ucontrol->value.enumerated.item[0] = (val & 0x0008) ? 2 : (val & 0x0020) ? 1 : 0;
177 return 0;
178}
179
180static int snd_ac97_ymf753_spdif_output_pin_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
181{
182 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
183 unsigned short val;
184
185 if (ucontrol->value.enumerated.item[0] > 2)
186 return -EINVAL;
187 val = (ucontrol->value.enumerated.item[0] == 2) ? 0x0008 :
188 (ucontrol->value.enumerated.item[0] == 1) ? 0x0020 : 0;
189 return snd_ac97_update_bits(ac97, AC97_YMF753_DIT_CTRL2, 0x0028, val);
190 /* The following can be used to direct S/PDIF output to pin 47 (EAPD).
191 snd_ac97_write_cache(ac97, 0x62, snd_ac97_read(ac97, 0x62) | 0x0008); */
192}
193
194static const snd_kcontrol_new_t snd_ac97_ymf753_controls_spdif[3] = {
195 {
196 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
197 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
198 .info = snd_ac97_ymf753_spdif_source_info,
199 .get = snd_ac97_ymf753_spdif_source_get,
200 .put = snd_ac97_ymf753_spdif_source_put,
201 },
202 {
203 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
204 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Output Pin",
205 .info = snd_ac97_ymf753_spdif_output_pin_info,
206 .get = snd_ac97_ymf753_spdif_output_pin_get,
207 .put = snd_ac97_ymf753_spdif_output_pin_put,
208 },
209 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",NONE,NONE) "Mute", AC97_YMF753_DIT_CTRL2, 2, 1, 1)
210};
211
212static int patch_yamaha_ymf753_3d(ac97_t * ac97)
213{
214 snd_kcontrol_t *kctl;
215 int err;
216
217 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
218 return err;
219 strcpy(kctl->id.name, "3D Control - Wide");
220 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 9, 7, 0);
221 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
222 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&snd_ac97_ymf753_controls_speaker, ac97))) < 0)
223 return err;
224 snd_ac97_write_cache(ac97, AC97_YMF753_3D_MODE_SEL, 0x0c00);
225 return 0;
226}
227
228static int patch_yamaha_ymf753_post_spdif(ac97_t * ac97)
229{
230 int err;
231
232 if ((err = patch_build_controls(ac97, snd_ac97_ymf753_controls_spdif, ARRAY_SIZE(snd_ac97_ymf753_controls_spdif))) < 0)
233 return err;
234 return 0;
235}
236
237static struct snd_ac97_build_ops patch_yamaha_ymf753_ops = {
238 .build_3d = patch_yamaha_ymf753_3d,
239 .build_post_spdif = patch_yamaha_ymf753_post_spdif
240};
241
242int patch_yamaha_ymf753(ac97_t * ac97)
243{
244 /* Patch for Yamaha YMF753, Copyright (c) by David Shust, dshust@shustring.com.
245 This chip has nonstandard and extended behaviour with regard to its S/PDIF output.
246 The AC'97 spec states that the S/PDIF signal is to be output at pin 48.
247 The YMF753 will ouput the S/PDIF signal to pin 43, 47 (EAPD), or 48.
248 By default, no output pin is selected, and the S/PDIF signal is not output.
249 There is also a bit to mute S/PDIF output in a vendor-specific register.
250 */
251 ac97->build_ops = &patch_yamaha_ymf753_ops;
252 ac97->caps |= AC97_BC_BASS_TREBLE;
253 ac97->caps |= 0x04 << 10; /* Yamaha 3D enhancement */
254 return 0;
255}
256
257/*
258 * May 2, 2003 Liam Girdwood <liam.girdwood@wolfsonmicro.com>
259 * removed broken wolfson00 patch.
260 * added support for WM9705,WM9708,WM9709,WM9710,WM9711,WM9712 and WM9717.
261 */
262
263int patch_wolfson03(ac97_t * ac97)
264{
265 /* This is known to work for the ViewSonic ViewPad 1000
266 Randolph Bentson <bentson@holmsjoen.com> */
267
268 // WM9703/9707/9708/9717
269 snd_ac97_write_cache(ac97, AC97_WM97XX_FMIXER_VOL, 0x0808);
270 snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0x8000);
271 return 0;
272}
273
274int patch_wolfson04(ac97_t * ac97)
275{
276 // WM9704M/9704Q
277 // set front and rear mixer volume
278 snd_ac97_write_cache(ac97, AC97_WM97XX_FMIXER_VOL, 0x0808);
279 snd_ac97_write_cache(ac97, AC97_WM9704_RMIXER_VOL, 0x0808);
280
281 // patch for DVD noise
282 snd_ac97_write_cache(ac97, AC97_WM9704_TEST, 0x0200);
283
284 // init vol
285 snd_ac97_write_cache(ac97, AC97_WM9704_RPCM_VOL, 0x0808);
286
287 // set rear surround volume
288 snd_ac97_write_cache(ac97, AC97_SURROUND_MASTER, 0x0000);
289 return 0;
290}
291
292int patch_wolfson05(ac97_t * ac97)
293{
294 // WM9705, WM9710
295 // set front mixer volume
296 snd_ac97_write_cache(ac97, AC97_WM97XX_FMIXER_VOL, 0x0808);
297 return 0;
298}
299
300int patch_wolfson11(ac97_t * ac97)
301{
302 // WM9711, WM9712
303 // set out3 volume
304 snd_ac97_write_cache(ac97, AC97_WM9711_OUT3VOL, 0x0808);
305 return 0;
306}
307
308static const char* wm9713_mic_mixer[] = {"Stereo", "Mic1", "Mic2", "Mute"};
309static const char* wm9713_rec_mux[] = {"Stereo", "Left", "Right", "Mute"};
310static const char* wm9713_rec_src_l[] = {"Mic1", "Mic2", "Line L", "Mono In", "HP Mix L", "Spk Mix", "Mono Mix", "Zh"};
311static const char* wm9713_rec_src_r[] = {"Mic1", "Mic2", "Line R", "Mono In", "HP Mix R", "Spk Mix", "Mono Mix", "Zh"};
312
313static const struct ac97_enum wm9713_enum[] = {
314AC97_ENUM_SINGLE(AC97_LINE, 3, 4, wm9713_mic_mixer),
315AC97_ENUM_SINGLE(AC97_VIDEO, 14, 4, wm9713_rec_mux),
316AC97_ENUM_SINGLE(AC97_VIDEO, 9, 4, wm9713_rec_mux),
317AC97_ENUM_SINGLE(AC97_VIDEO, 3, 8, wm9713_rec_src_l),
318AC97_ENUM_SINGLE(AC97_VIDEO, 0, 8, wm9713_rec_src_r),
319};
320
321static const snd_kcontrol_new_t wm13_snd_ac97_controls_line_in[] = {
322AC97_DOUBLE("Line In Volume", AC97_PC_BEEP, 8, 0, 31, 1),
323AC97_SINGLE("Line In to Headphone Mute", AC97_PC_BEEP, 15, 1, 1),
324AC97_SINGLE("Line In to Speaker Mute", AC97_PC_BEEP, 14, 1, 1),
325AC97_SINGLE("Line In to Mono Mute", AC97_PC_BEEP, 13, 1, 1),
326};
327
328static const snd_kcontrol_new_t wm13_snd_ac97_controls_dac[] = {
329AC97_DOUBLE("DAC Volume", AC97_PHONE, 8, 0, 31, 1),
330AC97_SINGLE("DAC to Headphone Mute", AC97_PHONE, 15, 1, 1),
331AC97_SINGLE("DAC to Speaker Mute", AC97_PHONE, 14, 1, 1),
332AC97_SINGLE("DAC to Mono Mute", AC97_PHONE, 13, 1, 1),
333};
334
335static const snd_kcontrol_new_t wm13_snd_ac97_controls_mic[] = {
336AC97_SINGLE("MICA Volume", AC97_MIC, 8, 31, 1),
337AC97_SINGLE("MICB Volume", AC97_MIC, 0, 31, 1),
338AC97_SINGLE("MICA to Mono Mute", AC97_LINE, 7, 1, 1),
339AC97_SINGLE("MICB to Mono Mute", AC97_LINE, 6, 1, 1),
340AC97_SINGLE("MIC Boost (+20dB)", AC97_LINE, 5, 1, 1),
341AC97_ENUM("MIC Headphone Routing", wm9713_enum[0]),
342AC97_SINGLE("MIC Headphone Mixer Volume", AC97_LINE, 0, 7, 1)
343};
344
345static const snd_kcontrol_new_t wm13_snd_ac97_controls_adc[] = {
346AC97_SINGLE("ADC Mute", AC97_CD, 15, 1, 1),
347AC97_DOUBLE("Gain Step Size (1.5dB/0.75dB)", AC97_CD, 14, 6, 1, 1),
348AC97_DOUBLE("ADC Volume",AC97_CD, 8, 0, 15, 0),
349AC97_SINGLE("ADC Zero Cross", AC97_CD, 7, 1, 1),
350};
351
352static const snd_kcontrol_new_t wm13_snd_ac97_controls_recsel[] = {
353AC97_ENUM("Record to Headphone Path", wm9713_enum[1]),
354AC97_SINGLE("Record to Headphone Volume", AC97_VIDEO, 11, 7, 0),
355AC97_ENUM("Record to Mono Path", wm9713_enum[2]),
356AC97_SINGLE("Record to Mono Boost (+20dB)", AC97_VIDEO, 8, 1, 0),
357AC97_SINGLE("Record ADC Boost (+20dB)", AC97_VIDEO, 6, 1, 0),
358AC97_ENUM("Record Select Left", wm9713_enum[3]),
359AC97_ENUM("Record Select Right", wm9713_enum[4]),
360};
361
362static int patch_wolfson_wm9713_specific(ac97_t * ac97)
363{
364 int err, i;
365
366 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls_line_in); i++) {
367 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls_line_in[i], ac97))) < 0)
368 return err;
369 }
370 snd_ac97_write_cache(ac97, AC97_PC_BEEP, 0x0808);
371
372 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls_dac); i++) {
373 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls_dac[i], ac97))) < 0)
374 return err;
375 }
376 snd_ac97_write_cache(ac97, AC97_PHONE, 0x0808);
377
378 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls_mic); i++) {
379 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls_mic[i], ac97))) < 0)
380 return err;
381 }
382 snd_ac97_write_cache(ac97, AC97_MIC, 0x0808);
383 snd_ac97_write_cache(ac97, AC97_LINE, 0x00da);
384
385 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls_adc); i++) {
386 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls_adc[i], ac97))) < 0)
387 return err;
388 }
389 snd_ac97_write_cache(ac97, AC97_CD, 0x0808);
390
391 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls_recsel); i++) {
392 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls_recsel[i], ac97))) < 0)
393 return err;
394 }
395 snd_ac97_write_cache(ac97, AC97_VIDEO, 0xd612);
396 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x1ba0);
397
398 return 0;
399}
400
401#ifdef CONFIG_PM
402static void patch_wolfson_wm9713_suspend (ac97_t * ac97)
403{
404 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xfeff);
405 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0xffff);
406}
407
408static void patch_wolfson_wm9713_resume (ac97_t * ac97)
409{
410 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xda00);
411 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0x3810);
412 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0x0);
413}
414#endif
415
416static struct snd_ac97_build_ops patch_wolfson_wm9713_ops = {
417 .build_specific = patch_wolfson_wm9713_specific,
418#ifdef CONFIG_PM
419 .suspend = patch_wolfson_wm9713_suspend,
420 .resume = patch_wolfson_wm9713_resume
421#endif
422};
423
424int patch_wolfson13(ac97_t * ac97)
425{
426 ac97->build_ops = &patch_wolfson_wm9713_ops;
427
428 ac97->flags |= AC97_HAS_NO_REC_GAIN | AC97_STEREO_MUTES | AC97_HAS_NO_PHONE |
429 AC97_HAS_NO_PC_BEEP | AC97_HAS_NO_VIDEO | AC97_HAS_NO_CD;
430
431 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xda00);
432 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0x3810);
433 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0x0);
434
435 return 0;
436}
437
438/*
439 * Tritech codec
440 */
441int patch_tritech_tr28028(ac97_t * ac97)
442{
443 snd_ac97_write_cache(ac97, 0x26, 0x0300);
444 snd_ac97_write_cache(ac97, 0x26, 0x0000);
445 snd_ac97_write_cache(ac97, AC97_SURROUND_MASTER, 0x0000);
446 snd_ac97_write_cache(ac97, AC97_SPDIF, 0x0000);
447 return 0;
448}
449
450/*
451 * Sigmatel STAC97xx codecs
452 */
453static int patch_sigmatel_stac9700_3d(ac97_t * ac97)
454{
455 snd_kcontrol_t *kctl;
456 int err;
457
458 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
459 return err;
460 strcpy(kctl->id.name, "3D Control Sigmatel - Depth");
461 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 2, 3, 0);
462 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
463 return 0;
464}
465
466static int patch_sigmatel_stac9708_3d(ac97_t * ac97)
467{
468 snd_kcontrol_t *kctl;
469 int err;
470
471 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
472 return err;
473 strcpy(kctl->id.name, "3D Control Sigmatel - Depth");
474 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 0, 3, 0);
475 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
476 return err;
477 strcpy(kctl->id.name, "3D Control Sigmatel - Rear Depth");
478 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 2, 3, 0);
479 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
480 return 0;
481}
482
483static const snd_kcontrol_new_t snd_ac97_sigmatel_4speaker =
484AC97_SINGLE("Sigmatel 4-Speaker Stereo Playback Switch", AC97_SIGMATEL_DAC2INVERT, 2, 1, 0);
485
486static const snd_kcontrol_new_t snd_ac97_sigmatel_phaseinvert =
487AC97_SINGLE("Sigmatel Surround Phase Inversion Playback Switch", AC97_SIGMATEL_DAC2INVERT, 3, 1, 0);
488
489static const snd_kcontrol_new_t snd_ac97_sigmatel_controls[] = {
490AC97_SINGLE("Sigmatel DAC 6dB Attenuate", AC97_SIGMATEL_ANALOG, 1, 1, 0),
491AC97_SINGLE("Sigmatel ADC 6dB Attenuate", AC97_SIGMATEL_ANALOG, 0, 1, 0)
492};
493
494static int patch_sigmatel_stac97xx_specific(ac97_t * ac97)
495{
496 int err;
497
498 snd_ac97_write_cache(ac97, AC97_SIGMATEL_ANALOG, snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG) & ~0x0003);
499 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_ANALOG, 1))
500 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_controls[0], 1)) < 0)
501 return err;
502 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_ANALOG, 0))
503 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_controls[1], 1)) < 0)
504 return err;
505 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_DAC2INVERT, 2))
506 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_4speaker, 1)) < 0)
507 return err;
508 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_DAC2INVERT, 3))
509 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_phaseinvert, 1)) < 0)
510 return err;
511 return 0;
512}
513
514static struct snd_ac97_build_ops patch_sigmatel_stac9700_ops = {
515 .build_3d = patch_sigmatel_stac9700_3d,
516 .build_specific = patch_sigmatel_stac97xx_specific
517};
518
519int patch_sigmatel_stac9700(ac97_t * ac97)
520{
521 ac97->build_ops = &patch_sigmatel_stac9700_ops;
522 return 0;
523}
524
525static int snd_ac97_stac9708_put_bias(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
526{
527 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
528 int err;
529
530 down(&ac97->page_mutex);
531 snd_ac97_write(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
532 err = snd_ac97_update_bits(ac97, AC97_SIGMATEL_BIAS2, 0x0010,
533 (ucontrol->value.integer.value[0] & 1) << 4);
534 snd_ac97_write(ac97, AC97_SIGMATEL_BIAS1, 0);
535 up(&ac97->page_mutex);
536 return err;
537}
538
539static const snd_kcontrol_new_t snd_ac97_stac9708_bias_control = {
540 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
541 .name = "Sigmatel Output Bias Switch",
542 .info = snd_ac97_info_volsw,
543 .get = snd_ac97_get_volsw,
544 .put = snd_ac97_stac9708_put_bias,
545 .private_value = AC97_SINGLE_VALUE(AC97_SIGMATEL_BIAS2, 4, 1, 0),
546};
547
548static int patch_sigmatel_stac9708_specific(ac97_t *ac97)
549{
550 int err;
551
552 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Sigmatel Surround Playback");
553 if ((err = patch_build_controls(ac97, &snd_ac97_stac9708_bias_control, 1)) < 0)
554 return err;
555 return patch_sigmatel_stac97xx_specific(ac97);
556}
557
558static struct snd_ac97_build_ops patch_sigmatel_stac9708_ops = {
559 .build_3d = patch_sigmatel_stac9708_3d,
560 .build_specific = patch_sigmatel_stac9708_specific
561};
562
563int patch_sigmatel_stac9708(ac97_t * ac97)
564{
565 unsigned int codec72, codec6c;
566
567 ac97->build_ops = &patch_sigmatel_stac9708_ops;
568 ac97->caps |= 0x10; /* HP (sigmatel surround) support */
569
570 codec72 = snd_ac97_read(ac97, AC97_SIGMATEL_BIAS2) & 0x8000;
571 codec6c = snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG);
572
573 if ((codec72==0) && (codec6c==0)) {
574 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
575 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x1000);
576 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
577 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0007);
578 } else if ((codec72==0x8000) && (codec6c==0)) {
579 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
580 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x1001);
581 snd_ac97_write_cache(ac97, AC97_SIGMATEL_DAC2INVERT, 0x0008);
582 } else if ((codec72==0x8000) && (codec6c==0x0080)) {
583 /* nothing */
584 }
585 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000);
586 return 0;
587}
588
589int patch_sigmatel_stac9721(ac97_t * ac97)
590{
591 ac97->build_ops = &patch_sigmatel_stac9700_ops;
592 if (snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG) == 0) {
593 // patch for SigmaTel
594 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
595 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x4000);
596 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
597 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002);
598 }
599 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000);
600 return 0;
601}
602
603int patch_sigmatel_stac9744(ac97_t * ac97)
604{
605 // patch for SigmaTel
606 ac97->build_ops = &patch_sigmatel_stac9700_ops;
607 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
608 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x0000); /* is this correct? --jk */
609 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
610 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002);
611 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000);
612 return 0;
613}
614
615int patch_sigmatel_stac9756(ac97_t * ac97)
616{
617 // patch for SigmaTel
618 ac97->build_ops = &patch_sigmatel_stac9700_ops;
619 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
620 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x0000); /* is this correct? --jk */
621 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
622 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002);
623 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000);
624 return 0;
625}
626
627static int snd_ac97_stac9758_output_jack_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
628{
629 static char *texts[5] = { "Input/Disabled", "Front Output",
630 "Rear Output", "Center/LFE Output", "Mixer Output" };
631
632 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
633 uinfo->count = 1;
634 uinfo->value.enumerated.items = 5;
635 if (uinfo->value.enumerated.item > 4)
636 uinfo->value.enumerated.item = 4;
637 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
638 return 0;
639}
640
641static int snd_ac97_stac9758_output_jack_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol)
642{
643 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
644 int shift = kcontrol->private_value;
645 unsigned short val;
646
647 val = ac97->regs[AC97_SIGMATEL_OUTSEL] >> shift;
648 if (!(val & 4))
649 ucontrol->value.enumerated.item[0] = 0;
650 else
651 ucontrol->value.enumerated.item[0] = 1 + (val & 3);
652 return 0;
653}
654
655static int snd_ac97_stac9758_output_jack_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
656{
657 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
658 int shift = kcontrol->private_value;
659 unsigned short val;
660
661 if (ucontrol->value.enumerated.item[0] > 4)
662 return -EINVAL;
663 if (ucontrol->value.enumerated.item[0] == 0)
664 val = 0;
665 else
666 val = 4 | (ucontrol->value.enumerated.item[0] - 1);
667 return ac97_update_bits_page(ac97, AC97_SIGMATEL_OUTSEL,
668 7 << shift, val << shift, 0);
669}
670
671static int snd_ac97_stac9758_input_jack_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
672{
673 static char *texts[7] = { "Mic2 Jack", "Mic1 Jack", "Line In Jack",
674 "Front Jack", "Rear Jack", "Center/LFE Jack", "Mute" };
675
676 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
677 uinfo->count = 1;
678 uinfo->value.enumerated.items = 7;
679 if (uinfo->value.enumerated.item > 6)
680 uinfo->value.enumerated.item = 6;
681 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
682 return 0;
683}
684
685static int snd_ac97_stac9758_input_jack_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol)
686{
687 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
688 int shift = kcontrol->private_value;
689 unsigned short val;
690
691 val = ac97->regs[AC97_SIGMATEL_INSEL];
692 ucontrol->value.enumerated.item[0] = (val >> shift) & 7;
693 return 0;
694}
695
696static int snd_ac97_stac9758_input_jack_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
697{
698 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
699 int shift = kcontrol->private_value;
700
701 return ac97_update_bits_page(ac97, AC97_SIGMATEL_INSEL, 7 << shift,
702 ucontrol->value.enumerated.item[0] << shift, 0);
703}
704
705static int snd_ac97_stac9758_phonesel_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
706{
707 static char *texts[3] = { "None", "Front Jack", "Rear Jack" };
708
709 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
710 uinfo->count = 1;
711 uinfo->value.enumerated.items = 3;
712 if (uinfo->value.enumerated.item > 2)
713 uinfo->value.enumerated.item = 2;
714 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
715 return 0;
716}
717
718static int snd_ac97_stac9758_phonesel_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol)
719{
720 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
721
722 ucontrol->value.enumerated.item[0] = ac97->regs[AC97_SIGMATEL_IOMISC] & 3;
723 return 0;
724}
725
726static int snd_ac97_stac9758_phonesel_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
727{
728 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
729
730 return ac97_update_bits_page(ac97, AC97_SIGMATEL_IOMISC, 3,
731 ucontrol->value.enumerated.item[0], 0);
732}
733
734#define STAC9758_OUTPUT_JACK(xname, shift) \
735{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
736 .info = snd_ac97_stac9758_output_jack_info, \
737 .get = snd_ac97_stac9758_output_jack_get, \
738 .put = snd_ac97_stac9758_output_jack_put, \
739 .private_value = shift }
740#define STAC9758_INPUT_JACK(xname, shift) \
741{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
742 .info = snd_ac97_stac9758_input_jack_info, \
743 .get = snd_ac97_stac9758_input_jack_get, \
744 .put = snd_ac97_stac9758_input_jack_put, \
745 .private_value = shift }
746static const snd_kcontrol_new_t snd_ac97_sigmatel_stac9758_controls[] = {
747 STAC9758_OUTPUT_JACK("Mic1 Jack", 1),
748 STAC9758_OUTPUT_JACK("LineIn Jack", 4),
749 STAC9758_OUTPUT_JACK("Front Jack", 7),
750 STAC9758_OUTPUT_JACK("Rear Jack", 10),
751 STAC9758_OUTPUT_JACK("Center/LFE Jack", 13),
752 STAC9758_INPUT_JACK("Mic Input Source", 0),
753 STAC9758_INPUT_JACK("Line Input Source", 8),
754 {
755 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
756 .name = "Headphone Amp",
757 .info = snd_ac97_stac9758_phonesel_info,
758 .get = snd_ac97_stac9758_phonesel_get,
759 .put = snd_ac97_stac9758_phonesel_put
760 },
761 AC97_SINGLE("Exchange Center/LFE", AC97_SIGMATEL_IOMISC, 4, 1, 0),
762 AC97_SINGLE("Headphone +3dB Boost", AC97_SIGMATEL_IOMISC, 8, 1, 0)
763};
764
765static int patch_sigmatel_stac9758_specific(ac97_t *ac97)
766{
767 int err;
768
769 err = patch_sigmatel_stac97xx_specific(ac97);
770 if (err < 0)
771 return err;
772 err = patch_build_controls(ac97, snd_ac97_sigmatel_stac9758_controls,
773 ARRAY_SIZE(snd_ac97_sigmatel_stac9758_controls));
774 if (err < 0)
775 return err;
776 /* DAC-A direct */
777 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Front Playback");
778 /* DAC-A to Mix = PCM */
779 /* DAC-B direct = Surround */
780 /* DAC-B to Mix */
781 snd_ac97_rename_vol_ctl(ac97, "Video Playback", "Surround Mix Playback");
782 /* DAC-C direct = Center/LFE */
783
784 return 0;
785}
786
787static struct snd_ac97_build_ops patch_sigmatel_stac9758_ops = {
788 .build_3d = patch_sigmatel_stac9700_3d,
789 .build_specific = patch_sigmatel_stac9758_specific
790};
791
792int patch_sigmatel_stac9758(ac97_t * ac97)
793{
794 static unsigned short regs[4] = {
795 AC97_SIGMATEL_OUTSEL,
796 AC97_SIGMATEL_IOMISC,
797 AC97_SIGMATEL_INSEL,
798 AC97_SIGMATEL_VARIOUS
799 };
800 static unsigned short def_regs[4] = {
801 /* OUTSEL */ 0xd794, /* CL:CL, SR:SR, LO:MX, LI:DS, MI:DS */
802 /* IOMISC */ 0x2001,
803 /* INSEL */ 0x0201, /* LI:LI, MI:M1 */
804 /* VARIOUS */ 0x0040
805 };
806 static unsigned short m675_regs[4] = {
807 /* OUTSEL */ 0xfc70, /* CL:MX, SR:MX, LO:DS, LI:MX, MI:DS */
808 /* IOMISC */ 0x2102, /* HP amp on */
809 /* INSEL */ 0x0203, /* LI:LI, MI:FR */
810 /* VARIOUS */ 0x0041 /* stereo mic */
811 };
812 unsigned short *pregs = def_regs;
813 int i;
814
815 /* Gateway M675 notebook */
816 if (ac97->pci &&
817 ac97->subsystem_vendor == 0x107b &&
818 ac97->subsystem_device == 0x0601)
819 pregs = m675_regs;
820
821 // patch for SigmaTel
822 ac97->build_ops = &patch_sigmatel_stac9758_ops;
823 /* FIXME: assume only page 0 for writing cache */
824 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR);
825 for (i = 0; i < 4; i++)
826 snd_ac97_write_cache(ac97, regs[i], pregs[i]);
827
828 ac97->flags |= AC97_STEREO_MUTES;
829 return 0;
830}
831
832/*
833 * Cirrus Logic CS42xx codecs
834 */
835static const snd_kcontrol_new_t snd_ac97_cirrus_controls_spdif[2] = {
836 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), AC97_CSR_SPDIF, 15, 1, 0),
837 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA", AC97_CSR_ACMODE, 0, 3, 0)
838};
839
840static int patch_cirrus_build_spdif(ac97_t * ac97)
841{
842 int err;
843
844 /* con mask, pro mask, default */
845 if ((err = patch_build_controls(ac97, &snd_ac97_controls_spdif[0], 3)) < 0)
846 return err;
847 /* switch, spsa */
848 if ((err = patch_build_controls(ac97, &snd_ac97_cirrus_controls_spdif[0], 1)) < 0)
849 return err;
850 switch (ac97->id & AC97_ID_CS_MASK) {
851 case AC97_ID_CS4205:
852 if ((err = patch_build_controls(ac97, &snd_ac97_cirrus_controls_spdif[1], 1)) < 0)
853 return err;
854 break;
855 }
856 /* set default PCM S/PDIF params */
857 /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
858 snd_ac97_write_cache(ac97, AC97_CSR_SPDIF, 0x0a20);
859 return 0;
860}
861
862static struct snd_ac97_build_ops patch_cirrus_ops = {
863 .build_spdif = patch_cirrus_build_spdif
864};
865
866int patch_cirrus_spdif(ac97_t * ac97)
867{
868 /* Basically, the cs4201/cs4205/cs4297a has non-standard sp/dif registers.
869 WHY CAN'T ANYONE FOLLOW THE BLOODY SPEC? *sigh*
870 - sp/dif EA ID is not set, but sp/dif is always present.
871 - enable/disable is spdif register bit 15.
872 - sp/dif control register is 0x68. differs from AC97:
873 - valid is bit 14 (vs 15)
874 - no DRS
875 - only 44.1/48k [00 = 48, 01=44,1] (AC97 is 00=44.1, 10=48)
876 - sp/dif ssource select is in 0x5e bits 0,1.
877 */
878
879 ac97->build_ops = &patch_cirrus_ops;
880 ac97->flags |= AC97_CS_SPDIF;
881 ac97->rates[AC97_RATES_SPDIF] &= ~SNDRV_PCM_RATE_32000;
882 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */
883 snd_ac97_write_cache(ac97, AC97_CSR_ACMODE, 0x0080);
884 return 0;
885}
886
887int patch_cirrus_cs4299(ac97_t * ac97)
888{
889 /* force the detection of PC Beep */
890 ac97->flags |= AC97_HAS_PC_BEEP;
891
892 return patch_cirrus_spdif(ac97);
893}
894
895/*
896 * Conexant codecs
897 */
898static const snd_kcontrol_new_t snd_ac97_conexant_controls_spdif[1] = {
899 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), AC97_CXR_AUDIO_MISC, 3, 1, 0),
900};
901
902static int patch_conexant_build_spdif(ac97_t * ac97)
903{
904 int err;
905
906 /* con mask, pro mask, default */
907 if ((err = patch_build_controls(ac97, &snd_ac97_controls_spdif[0], 3)) < 0)
908 return err;
909 /* switch */
910 if ((err = patch_build_controls(ac97, &snd_ac97_conexant_controls_spdif[0], 1)) < 0)
911 return err;
912 /* set default PCM S/PDIF params */
913 /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
914 snd_ac97_write_cache(ac97, AC97_CXR_AUDIO_MISC,
915 snd_ac97_read(ac97, AC97_CXR_AUDIO_MISC) & ~(AC97_CXR_SPDIFEN|AC97_CXR_COPYRGT|AC97_CXR_SPDIF_MASK));
916 return 0;
917}
918
919static struct snd_ac97_build_ops patch_conexant_ops = {
920 .build_spdif = patch_conexant_build_spdif
921};
922
923int patch_conexant(ac97_t * ac97)
924{
925 ac97->build_ops = &patch_conexant_ops;
926 ac97->flags |= AC97_CX_SPDIF;
927 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */
928 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */
929 return 0;
930}
931
932/*
933 * Analog Device AD18xx, AD19xx codecs
934 */
935#ifdef CONFIG_PM
936static void ad18xx_resume(ac97_t *ac97)
937{
938 static unsigned short setup_regs[] = {
939 AC97_AD_MISC, AC97_AD_SERIAL_CFG, AC97_AD_JACK_SPDIF,
940 };
941 int i, codec;
942
943 for (i = 0; i < (int)ARRAY_SIZE(setup_regs); i++) {
944 unsigned short reg = setup_regs[i];
945 if (test_bit(reg, ac97->reg_accessed)) {
946 snd_ac97_write(ac97, reg, ac97->regs[reg]);
947 snd_ac97_read(ac97, reg);
948 }
949 }
950
951 if (! (ac97->flags & AC97_AD_MULTI))
952 /* normal restore */
953 snd_ac97_restore_status(ac97);
954 else {
955 /* restore the AD18xx codec configurations */
956 for (codec = 0; codec < 3; codec++) {
957 if (! ac97->spec.ad18xx.id[codec])
958 continue;
959 /* select single codec */
960 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
961 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
962 ac97->bus->ops->write(ac97, AC97_AD_CODEC_CFG, ac97->spec.ad18xx.codec_cfg[codec]);
963 }
964 /* select all codecs */
965 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
966
967 /* restore status */
968 for (i = 2; i < 0x7c ; i += 2) {
969 if (i == AC97_POWERDOWN || i == AC97_EXTENDED_ID)
970 continue;
971 if (test_bit(i, ac97->reg_accessed)) {
972 /* handle multi codecs for AD18xx */
973 if (i == AC97_PCM) {
974 for (codec = 0; codec < 3; codec++) {
975 if (! ac97->spec.ad18xx.id[codec])
976 continue;
977 /* select single codec */
978 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
979 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
980 /* update PCM bits */
981 ac97->bus->ops->write(ac97, AC97_PCM, ac97->spec.ad18xx.pcmreg[codec]);
982 }
983 /* select all codecs */
984 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
985 continue;
986 } else if (i == AC97_AD_TEST ||
987 i == AC97_AD_CODEC_CFG ||
988 i == AC97_AD_SERIAL_CFG)
989 continue; /* ignore */
990 }
991 snd_ac97_write(ac97, i, ac97->regs[i]);
992 snd_ac97_read(ac97, i);
993 }
994 }
995
996 snd_ac97_restore_iec958(ac97);
997}
998#endif
999
1000int patch_ad1819(ac97_t * ac97)
1001{
1002 unsigned short scfg;
1003
1004 // patch for Analog Devices
1005 scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
1006 snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x7000); /* select all codecs */
1007 return 0;
1008}
1009
1010static unsigned short patch_ad1881_unchained(ac97_t * ac97, int idx, unsigned short mask)
1011{
1012 unsigned short val;
1013
1014 // test for unchained codec
1015 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, mask);
1016 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0000); /* ID0C, ID1C, SDIE = off */
1017 val = snd_ac97_read(ac97, AC97_VENDOR_ID2);
1018 if ((val & 0xff40) != 0x5340)
1019 return 0;
1020 ac97->spec.ad18xx.unchained[idx] = mask;
1021 ac97->spec.ad18xx.id[idx] = val;
1022 ac97->spec.ad18xx.codec_cfg[idx] = 0x0000;
1023 return mask;
1024}
1025
1026static int patch_ad1881_chained1(ac97_t * ac97, int idx, unsigned short codec_bits)
1027{
1028 static int cfg_bits[3] = { 1<<12, 1<<14, 1<<13 };
1029 unsigned short val;
1030
1031 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, cfg_bits[idx]);
1032 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0004); // SDIE
1033 val = snd_ac97_read(ac97, AC97_VENDOR_ID2);
1034 if ((val & 0xff40) != 0x5340)
1035 return 0;
1036 if (codec_bits)
1037 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, codec_bits);
1038 ac97->spec.ad18xx.chained[idx] = cfg_bits[idx];
1039 ac97->spec.ad18xx.id[idx] = val;
1040 ac97->spec.ad18xx.codec_cfg[idx] = codec_bits ? codec_bits : 0x0004;
1041 return 1;
1042}
1043
1044static void patch_ad1881_chained(ac97_t * ac97, int unchained_idx, int cidx1, int cidx2)
1045{
1046 // already detected?
1047 if (ac97->spec.ad18xx.unchained[cidx1] || ac97->spec.ad18xx.chained[cidx1])
1048 cidx1 = -1;
1049 if (ac97->spec.ad18xx.unchained[cidx2] || ac97->spec.ad18xx.chained[cidx2])
1050 cidx2 = -1;
1051 if (cidx1 < 0 && cidx2 < 0)
1052 return;
1053 // test for chained codecs
1054 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
1055 ac97->spec.ad18xx.unchained[unchained_idx]);
1056 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0002); // ID1C
1057 ac97->spec.ad18xx.codec_cfg[unchained_idx] = 0x0002;
1058 if (cidx1 >= 0) {
1059 if (patch_ad1881_chained1(ac97, cidx1, 0x0006)) // SDIE | ID1C
1060 patch_ad1881_chained1(ac97, cidx2, 0);
1061 else if (patch_ad1881_chained1(ac97, cidx2, 0x0006)) // SDIE | ID1C
1062 patch_ad1881_chained1(ac97, cidx1, 0);
1063 } else if (cidx2 >= 0) {
1064 patch_ad1881_chained1(ac97, cidx2, 0);
1065 }
1066}
1067
1068static struct snd_ac97_build_ops patch_ad1881_build_ops = {
1069#ifdef CONFIG_PM
1070 .resume = ad18xx_resume
1071#endif
1072};
1073
1074int patch_ad1881(ac97_t * ac97)
1075{
1076 static const char cfg_idxs[3][2] = {
1077 {2, 1},
1078 {0, 2},
1079 {0, 1}
1080 };
1081
1082 // patch for Analog Devices
1083 unsigned short codecs[3];
1084 unsigned short val;
1085 int idx, num;
1086
1087 val = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
1088 snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, val);
1089 codecs[0] = patch_ad1881_unchained(ac97, 0, (1<<12));
1090 codecs[1] = patch_ad1881_unchained(ac97, 1, (1<<14));
1091 codecs[2] = patch_ad1881_unchained(ac97, 2, (1<<13));
1092
1093 snd_runtime_check(codecs[0] | codecs[1] | codecs[2], goto __end);
1094
1095 for (idx = 0; idx < 3; idx++)
1096 if (ac97->spec.ad18xx.unchained[idx])
1097 patch_ad1881_chained(ac97, idx, cfg_idxs[idx][0], cfg_idxs[idx][1]);
1098
1099 if (ac97->spec.ad18xx.id[1]) {
1100 ac97->flags |= AC97_AD_MULTI;
1101 ac97->scaps |= AC97_SCAP_SURROUND_DAC;
1102 }
1103 if (ac97->spec.ad18xx.id[2]) {
1104 ac97->flags |= AC97_AD_MULTI;
1105 ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC;
1106 }
1107
1108 __end:
1109 /* select all codecs */
1110 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
1111 /* check if only one codec is present */
1112 for (idx = num = 0; idx < 3; idx++)
1113 if (ac97->spec.ad18xx.id[idx])
1114 num++;
1115 if (num == 1) {
1116 /* ok, deselect all ID bits */
1117 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0000);
1118 ac97->spec.ad18xx.codec_cfg[0] =
1119 ac97->spec.ad18xx.codec_cfg[1] =
1120 ac97->spec.ad18xx.codec_cfg[2] = 0x0000;
1121 }
1122 /* required for AD1886/AD1885 combination */
1123 ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID);
1124 if (ac97->spec.ad18xx.id[0]) {
1125 ac97->id &= 0xffff0000;
1126 ac97->id |= ac97->spec.ad18xx.id[0];
1127 }
1128 ac97->build_ops = &patch_ad1881_build_ops;
1129 return 0;
1130}
1131
1132static const snd_kcontrol_new_t snd_ac97_controls_ad1885[] = {
1133 AC97_SINGLE("Digital Mono Direct", AC97_AD_MISC, 11, 1, 0),
1134 /* AC97_SINGLE("Digital Audio Mode", AC97_AD_MISC, 12, 1, 0), */ /* seems problematic */
1135 AC97_SINGLE("Low Power Mixer", AC97_AD_MISC, 14, 1, 0),
1136 AC97_SINGLE("Zero Fill DAC", AC97_AD_MISC, 15, 1, 0),
1137 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 9, 1, 1), /* inverted */
1138 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 8, 1, 1), /* inverted */
1139};
1140
1141static int patch_ad1885_specific(ac97_t * ac97)
1142{
1143 int err;
1144
1145 if ((err = patch_build_controls(ac97, snd_ac97_controls_ad1885, ARRAY_SIZE(snd_ac97_controls_ad1885))) < 0)
1146 return err;
1147 return 0;
1148}
1149
1150static struct snd_ac97_build_ops patch_ad1885_build_ops = {
1151 .build_specific = &patch_ad1885_specific,
1152#ifdef CONFIG_PM
1153 .resume = ad18xx_resume
1154#endif
1155};
1156
1157int patch_ad1885(ac97_t * ac97)
1158{
1159 patch_ad1881(ac97);
1160 /* This is required to deal with the Intel D815EEAL2 */
1161 /* i.e. Line out is actually headphone out from codec */
1162
1163 /* set default */
1164 snd_ac97_write_cache(ac97, AC97_AD_MISC, 0x0404);
1165
1166 ac97->build_ops = &patch_ad1885_build_ops;
1167 return 0;
1168}
1169
1170int patch_ad1886(ac97_t * ac97)
1171{
1172 patch_ad1881(ac97);
1173 /* Presario700 workaround */
1174 /* for Jack Sense/SPDIF Register misetting causing */
1175 snd_ac97_write_cache(ac97, AC97_AD_JACK_SPDIF, 0x0010);
1176 return 0;
1177}
1178
1179/* MISC bits */
1180#define AC97_AD198X_MBC 0x0003 /* mic boost */
1181#define AC97_AD198X_MBC_20 0x0000 /* +20dB */
1182#define AC97_AD198X_MBC_10 0x0001 /* +10dB */
1183#define AC97_AD198X_MBC_30 0x0002 /* +30dB */
1184#define AC97_AD198X_VREFD 0x0004 /* VREF high-Z */
1185#define AC97_AD198X_VREFH 0x0008 /* 2.25V, 3.7V */
1186#define AC97_AD198X_VREF_0 0x000c /* 0V */
1187#define AC97_AD198X_SRU 0x0010 /* sample rate unlock */
1188#define AC97_AD198X_LOSEL 0x0020 /* LINE_OUT amplifiers input select */
1189#define AC97_AD198X_2MIC 0x0040 /* 2-channel mic select */
1190#define AC97_AD198X_SPRD 0x0080 /* SPREAD enable */
1191#define AC97_AD198X_DMIX0 0x0100 /* downmix mode: 0 = 6-to-4, 1 = 6-to-2 downmix */
1192#define AC97_AD198X_DMIX1 0x0200 /* downmix mode: 1 = enabled */
1193#define AC97_AD198X_HPSEL 0x0400 /* headphone amplifier input select */
1194#define AC97_AD198X_CLDIS 0x0800 /* center/lfe disable */
1195#define AC97_AD198X_LODIS 0x1000 /* LINE_OUT disable */
1196#define AC97_AD198X_MSPLT 0x2000 /* mute split */
1197#define AC97_AD198X_AC97NC 0x4000 /* AC97 no compatible mode */
1198#define AC97_AD198X_DACZ 0x8000 /* DAC zero-fill mode */
1199
1200
1201static int snd_ac97_ad198x_spdif_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1202{
1203 static char *texts[2] = { "AC-Link", "A/D Converter" };
1204
1205 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1206 uinfo->count = 1;
1207 uinfo->value.enumerated.items = 2;
1208 if (uinfo->value.enumerated.item > 1)
1209 uinfo->value.enumerated.item = 1;
1210 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1211 return 0;
1212}
1213
1214static int snd_ac97_ad198x_spdif_source_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1215{
1216 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1217 unsigned short val;
1218
1219 val = ac97->regs[AC97_AD_SERIAL_CFG];
1220 ucontrol->value.enumerated.item[0] = (val >> 2) & 1;
1221 return 0;
1222}
1223
1224static int snd_ac97_ad198x_spdif_source_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1225{
1226 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1227 unsigned short val;
1228
1229 if (ucontrol->value.enumerated.item[0] > 1)
1230 return -EINVAL;
1231 val = ucontrol->value.enumerated.item[0] << 2;
1232 return snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x0004, val);
1233}
1234
1235static const snd_kcontrol_new_t snd_ac97_ad198x_spdif_source = {
1236 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1237 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1238 .info = snd_ac97_ad198x_spdif_source_info,
1239 .get = snd_ac97_ad198x_spdif_source_get,
1240 .put = snd_ac97_ad198x_spdif_source_put,
1241};
1242
1243static int patch_ad198x_post_spdif(ac97_t * ac97)
1244{
1245 return patch_build_controls(ac97, &snd_ac97_ad198x_spdif_source, 1);
1246}
1247
1248static const snd_kcontrol_new_t snd_ac97_ad1981x_jack_sense[] = {
1249 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 11, 1, 0),
1250 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0),
1251};
1252
1253static int patch_ad1981a_specific(ac97_t * ac97)
1254{
1255 return patch_build_controls(ac97, snd_ac97_ad1981x_jack_sense,
1256 ARRAY_SIZE(snd_ac97_ad1981x_jack_sense));
1257}
1258
1259static struct snd_ac97_build_ops patch_ad1981a_build_ops = {
1260 .build_post_spdif = patch_ad198x_post_spdif,
1261 .build_specific = patch_ad1981a_specific,
1262#ifdef CONFIG_PM
1263 .resume = ad18xx_resume
1264#endif
1265};
1266
1267static void check_ad1981_hp_jack_sense(ac97_t *ac97)
1268{
1269 u32 subid = ((u32)ac97->subsystem_vendor << 16) | ac97->subsystem_device;
1270 switch (subid) {
1271 case 0x103c0890: /* HP nc6000 */
1272 case 0x103c006d: /* HP nx9105 */
1273 case 0x17340088: /* FSC Scenic-W */
1274 /* enable headphone jack sense */
1275 snd_ac97_update_bits(ac97, AC97_AD_JACK_SPDIF, 1<<11, 1<<11);
1276 break;
1277 }
1278}
1279
1280int patch_ad1981a(ac97_t *ac97)
1281{
1282 patch_ad1881(ac97);
1283 ac97->build_ops = &patch_ad1981a_build_ops;
1284 snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD198X_MSPLT, AC97_AD198X_MSPLT);
1285 ac97->flags |= AC97_STEREO_MUTES;
1286 check_ad1981_hp_jack_sense(ac97);
1287 return 0;
1288}
1289
1290static const snd_kcontrol_new_t snd_ac97_ad198x_2cmic =
1291AC97_SINGLE("Stereo Mic", AC97_AD_MISC, 6, 1, 0);
1292
1293static int patch_ad1981b_specific(ac97_t *ac97)
1294{
1295 int err;
1296
1297 if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0)
1298 return err;
1299 return patch_build_controls(ac97, snd_ac97_ad1981x_jack_sense,
1300 ARRAY_SIZE(snd_ac97_ad1981x_jack_sense));
1301}
1302
1303static struct snd_ac97_build_ops patch_ad1981b_build_ops = {
1304 .build_post_spdif = patch_ad198x_post_spdif,
1305 .build_specific = patch_ad1981b_specific,
1306#ifdef CONFIG_PM
1307 .resume = ad18xx_resume
1308#endif
1309};
1310
1311int patch_ad1981b(ac97_t *ac97)
1312{
1313 patch_ad1881(ac97);
1314 ac97->build_ops = &patch_ad1981b_build_ops;
1315 snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD198X_MSPLT, AC97_AD198X_MSPLT);
1316 ac97->flags |= AC97_STEREO_MUTES;
1317 check_ad1981_hp_jack_sense(ac97);
1318 return 0;
1319}
1320
1321static int snd_ac97_ad1888_lohpsel_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
1322{
1323 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1324 uinfo->count = 1;
1325 uinfo->value.integer.min = 0;
1326 uinfo->value.integer.max = 1;
1327 return 0;
1328}
1329
1330static int snd_ac97_ad1888_lohpsel_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol)
1331{
1332 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1333 unsigned short val;
1334
1335 val = ac97->regs[AC97_AD_MISC];
1336 ucontrol->value.integer.value[0] = !(val & AC97_AD198X_LOSEL);
1337 return 0;
1338}
1339
1340static int snd_ac97_ad1888_lohpsel_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
1341{
1342 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1343 unsigned short val;
1344
1345 val = !ucontrol->value.integer.value[0]
1346 ? (AC97_AD198X_LOSEL | AC97_AD198X_HPSEL) : 0;
1347 return snd_ac97_update_bits(ac97, AC97_AD_MISC,
1348 AC97_AD198X_LOSEL | AC97_AD198X_HPSEL, val);
1349}
1350
1351static int snd_ac97_ad1888_downmix_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
1352{
1353 static char *texts[3] = {"Off", "6 -> 4", "6 -> 2"};
1354
1355 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1356 uinfo->count = 1;
1357 uinfo->value.enumerated.items = 3;
1358 if (uinfo->value.enumerated.item > 2)
1359 uinfo->value.enumerated.item = 2;
1360 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1361 return 0;
1362}
1363
1364static int snd_ac97_ad1888_downmix_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol)
1365{
1366 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1367 unsigned short val;
1368
1369 val = ac97->regs[AC97_AD_MISC];
1370 if (!(val & AC97_AD198X_DMIX1))
1371 ucontrol->value.enumerated.item[0] = 0;
1372 else
1373 ucontrol->value.enumerated.item[0] = 1 + ((val >> 8) & 1);
1374 return 0;
1375}
1376
1377static int snd_ac97_ad1888_downmix_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
1378{
1379 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1380 unsigned short val;
1381
1382 if (ucontrol->value.enumerated.item[0] > 2)
1383 return -EINVAL;
1384 if (ucontrol->value.enumerated.item[0] == 0)
1385 val = 0;
1386 else
1387 val = AC97_AD198X_DMIX1 |
1388 ((ucontrol->value.enumerated.item[0] - 1) << 8);
1389 return snd_ac97_update_bits(ac97, AC97_AD_MISC,
1390 AC97_AD198X_DMIX0 | AC97_AD198X_DMIX1, val);
1391}
1392
1393static const snd_kcontrol_new_t snd_ac97_ad1888_controls[] = {
1394 {
1395 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1396 .name = "Exchange Front/Surround",
1397 .info = snd_ac97_ad1888_lohpsel_info,
1398 .get = snd_ac97_ad1888_lohpsel_get,
1399 .put = snd_ac97_ad1888_lohpsel_put
1400 },
1401 AC97_SINGLE("Spread Front to Surround and Center/LFE", AC97_AD_MISC, 7, 1, 0),
1402 {
1403 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1404 .name = "Downmix",
1405 .info = snd_ac97_ad1888_downmix_info,
1406 .get = snd_ac97_ad1888_downmix_get,
1407 .put = snd_ac97_ad1888_downmix_put
1408 },
1409 AC97_SINGLE("Surround Jack as Input", AC97_AD_MISC, 12, 1, 0),
1410 AC97_SINGLE("Center/LFE Jack as Input", AC97_AD_MISC, 11, 1, 0),
1411};
1412
1413static int patch_ad1888_specific(ac97_t *ac97)
1414{
1415 /* rename 0x04 as "Master" and 0x02 as "Master Surround" */
1416 snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Master Surround Playback");
1417 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
1418 return patch_build_controls(ac97, snd_ac97_ad1888_controls, ARRAY_SIZE(snd_ac97_ad1888_controls));
1419}
1420
1421static struct snd_ac97_build_ops patch_ad1888_build_ops = {
1422 .build_post_spdif = patch_ad198x_post_spdif,
1423 .build_specific = patch_ad1888_specific,
1424#ifdef CONFIG_PM
1425 .resume = ad18xx_resume
1426#endif
1427};
1428
1429int patch_ad1888(ac97_t * ac97)
1430{
1431 unsigned short misc;
1432
1433 patch_ad1881(ac97);
1434 ac97->build_ops = &patch_ad1888_build_ops;
1435 /* Switch FRONT/SURROUND LINE-OUT/HP-OUT default connection */
1436 /* it seems that most vendors connect line-out connector to headphone out of AC'97 */
1437 /* AD-compatible mode */
1438 /* Stereo mutes enabled */
1439 misc = snd_ac97_read(ac97, AC97_AD_MISC);
1440 snd_ac97_write_cache(ac97, AC97_AD_MISC, misc |
1441 AC97_AD198X_LOSEL |
1442 AC97_AD198X_HPSEL |
1443 AC97_AD198X_MSPLT |
1444 AC97_AD198X_AC97NC);
1445 ac97->flags |= AC97_STEREO_MUTES;
1446 return 0;
1447}
1448
1449static int patch_ad1980_specific(ac97_t *ac97)
1450{
1451 int err;
1452
1453 if ((err = patch_ad1888_specific(ac97)) < 0)
1454 return err;
1455 return patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1);
1456}
1457
1458static struct snd_ac97_build_ops patch_ad1980_build_ops = {
1459 .build_post_spdif = patch_ad198x_post_spdif,
1460 .build_specific = patch_ad1980_specific,
1461#ifdef CONFIG_PM
1462 .resume = ad18xx_resume
1463#endif
1464};
1465
1466int patch_ad1980(ac97_t * ac97)
1467{
1468 patch_ad1888(ac97);
1469 ac97->build_ops = &patch_ad1980_build_ops;
1470 return 0;
1471}
1472
1473static const snd_kcontrol_new_t snd_ac97_ad1985_controls[] = {
1474 AC97_SINGLE("Center/LFE Jack as Mic", AC97_AD_SERIAL_CFG, 9, 1, 0),
1475 AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0)
1476};
1477
1478static int patch_ad1985_specific(ac97_t *ac97)
1479{
1480 int err;
1481
1482 if ((err = patch_ad1980_specific(ac97)) < 0)
1483 return err;
1484 return patch_build_controls(ac97, snd_ac97_ad1985_controls, ARRAY_SIZE(snd_ac97_ad1985_controls));
1485}
1486
1487static struct snd_ac97_build_ops patch_ad1985_build_ops = {
1488 .build_post_spdif = patch_ad198x_post_spdif,
1489 .build_specific = patch_ad1985_specific,
1490#ifdef CONFIG_PM
1491 .resume = ad18xx_resume
1492#endif
1493};
1494
1495int patch_ad1985(ac97_t * ac97)
1496{
1497 unsigned short misc;
1498
1499 patch_ad1881(ac97);
1500 ac97->build_ops = &patch_ad1985_build_ops;
1501 misc = snd_ac97_read(ac97, AC97_AD_MISC);
1502 /* switch front/surround line-out/hp-out */
1503 /* center/LFE, mic in 3.75V mode */
1504 /* AD-compatible mode */
1505 /* Stereo mutes enabled */
1506 /* in accordance with ADI driver: misc | 0x5c28 */
1507 snd_ac97_write_cache(ac97, AC97_AD_MISC, misc |
1508 AC97_AD198X_VREFH |
1509 AC97_AD198X_LOSEL |
1510 AC97_AD198X_HPSEL |
1511 AC97_AD198X_CLDIS |
1512 AC97_AD198X_LODIS |
1513 AC97_AD198X_MSPLT |
1514 AC97_AD198X_AC97NC);
1515 ac97->flags |= AC97_STEREO_MUTES;
1516 /* on AD1985 rev. 3, AC'97 revision bits are zero */
1517 ac97->ext_id = (ac97->ext_id & ~AC97_EI_REV_MASK) | AC97_EI_REV_23;
1518 return 0;
1519}
1520
1521/*
1522 * realtek ALC65x/850 codecs
1523 */
1524static int snd_ac97_alc650_mic_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
1525{
1526 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1527 ucontrol->value.integer.value[0] = (ac97->regs[AC97_ALC650_MULTICH] >> 10) & 1;
1528 return 0;
1529}
1530
1531static int snd_ac97_alc650_mic_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
1532{
1533 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1534 int change, val;
1535 val = !!(snd_ac97_read(ac97, AC97_ALC650_MULTICH) & (1 << 10));
1536 change = (ucontrol->value.integer.value[0] != val);
1537 if (change) {
1538 /* disable/enable vref */
1539 snd_ac97_update_bits(ac97, AC97_ALC650_CLOCK, 1 << 12,
1540 ucontrol->value.integer.value[0] ? (1 << 12) : 0);
1541 /* turn on/off center-on-mic */
1542 snd_ac97_update_bits(ac97, AC97_ALC650_MULTICH, 1 << 10,
1543 ucontrol->value.integer.value[0] ? (1 << 10) : 0);
1544 /* GPIO0 high for mic */
1545 snd_ac97_update_bits(ac97, AC97_ALC650_GPIO_STATUS, 0x100,
1546 ucontrol->value.integer.value[0] ? 0 : 0x100);
1547 }
1548 return change;
1549}
1550
1551static const snd_kcontrol_new_t snd_ac97_controls_alc650[] = {
1552 AC97_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0),
1553 AC97_SINGLE("Surround Down Mix", AC97_ALC650_MULTICH, 1, 1, 0),
1554 AC97_SINGLE("Center/LFE Down Mix", AC97_ALC650_MULTICH, 2, 1, 0),
1555 AC97_SINGLE("Exchange Center/LFE", AC97_ALC650_MULTICH, 3, 1, 0),
1556 /* 4: Analog Input To Surround */
1557 /* 5: Analog Input To Center/LFE */
1558 /* 6: Independent Master Volume Right */
1559 /* 7: Independent Master Volume Left */
1560 /* 8: reserved */
1561 AC97_SINGLE("Line-In As Surround", AC97_ALC650_MULTICH, 9, 1, 0),
1562 /* 10: mic, see below */
1563 /* 11-13: in IEC958 controls */
1564 AC97_SINGLE("Swap Surround Slot", AC97_ALC650_MULTICH, 14, 1, 0),
1565#if 0 /* always set in patch_alc650 */
1566 AC97_SINGLE("IEC958 Input Clock Enable", AC97_ALC650_CLOCK, 0, 1, 0),
1567 AC97_SINGLE("IEC958 Input Pin Enable", AC97_ALC650_CLOCK, 1, 1, 0),
1568 AC97_SINGLE("Surround DAC Switch", AC97_ALC650_SURR_DAC_VOL, 15, 1, 1),
1569 AC97_DOUBLE("Surround DAC Volume", AC97_ALC650_SURR_DAC_VOL, 8, 0, 31, 1),
1570 AC97_SINGLE("Center/LFE DAC Switch", AC97_ALC650_LFE_DAC_VOL, 15, 1, 1),
1571 AC97_DOUBLE("Center/LFE DAC Volume", AC97_ALC650_LFE_DAC_VOL, 8, 0, 31, 1),
1572#endif
1573 {
1574 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1575 .name = "Mic As Center/LFE",
1576 .info = snd_ac97_info_volsw,
1577 .get = snd_ac97_alc650_mic_get,
1578 .put = snd_ac97_alc650_mic_put,
1579 .private_value = AC97_SINGLE_VALUE(0, 0, 1, 0) /* only mask needed */
1580 },
1581};
1582
1583static const snd_kcontrol_new_t snd_ac97_spdif_controls_alc650[] = {
1584 AC97_SINGLE("IEC958 Capture Switch", AC97_ALC650_MULTICH, 11, 1, 0),
1585 AC97_SINGLE("Analog to IEC958 Output", AC97_ALC650_MULTICH, 12, 1, 0),
1586 /* disable this controls since it doesn't work as expected */
1587 /* AC97_SINGLE("IEC958 Input Monitor", AC97_ALC650_MULTICH, 13, 1, 0), */
1588};
1589
1590static int patch_alc650_specific(ac97_t * ac97)
1591{
1592 int err;
1593
1594 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc650, ARRAY_SIZE(snd_ac97_controls_alc650))) < 0)
1595 return err;
1596 if (ac97->ext_id & AC97_EI_SPDIF) {
1597 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc650, ARRAY_SIZE(snd_ac97_spdif_controls_alc650))) < 0)
1598 return err;
1599 }
1600 return 0;
1601}
1602
1603static struct snd_ac97_build_ops patch_alc650_ops = {
1604 .build_specific = patch_alc650_specific
1605};
1606
1607int patch_alc650(ac97_t * ac97)
1608{
1609 unsigned short val;
1610
1611 ac97->build_ops = &patch_alc650_ops;
1612
1613 /* determine the revision */
1614 val = snd_ac97_read(ac97, AC97_ALC650_REVISION) & 0x3f;
1615 if (val < 3)
1616 ac97->id = 0x414c4720; /* Old version */
1617 else if (val < 0x10)
1618 ac97->id = 0x414c4721; /* D version */
1619 else if (val < 0x20)
1620 ac97->id = 0x414c4722; /* E version */
1621 else if (val < 0x30)
1622 ac97->id = 0x414c4723; /* F version */
1623
1624 /* revision E or F */
1625 /* FIXME: what about revision D ? */
1626 ac97->spec.dev_flags = (ac97->id == 0x414c4722 ||
1627 ac97->id == 0x414c4723);
1628
1629 /* enable AC97_ALC650_GPIO_SETUP, AC97_ALC650_CLOCK for R/W */
1630 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_STATUS,
1631 snd_ac97_read(ac97, AC97_ALC650_GPIO_STATUS) | 0x8000);
1632
1633 /* Enable SPDIF-IN only on Rev.E and above */
1634 val = snd_ac97_read(ac97, AC97_ALC650_CLOCK);
1635 /* SPDIF IN with pin 47 */
1636 if (ac97->spec.dev_flags)
1637 val |= 0x03; /* enable */
1638 else
1639 val &= ~0x03; /* disable */
1640 snd_ac97_write_cache(ac97, AC97_ALC650_CLOCK, val);
1641
1642 /* set default: slot 3,4,7,8,6,9
1643 spdif-in monitor off, analog-spdif off, spdif-in off
1644 center on mic off, surround on line-in off
1645 downmix off, duplicate front off
1646 */
1647 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 0);
1648
1649 /* set GPIO0 for mic bias */
1650 /* GPIO0 pin output, no interrupt, high */
1651 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_SETUP,
1652 snd_ac97_read(ac97, AC97_ALC650_GPIO_SETUP) | 0x01);
1653 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_STATUS,
1654 (snd_ac97_read(ac97, AC97_ALC650_GPIO_STATUS) | 0x100) & ~0x10);
1655
1656 /* full DAC volume */
1657 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808);
1658 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808);
1659 return 0;
1660}
1661
1662static int snd_ac97_alc655_mic_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
1663{
1664 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1665 ucontrol->value.integer.value[0] = (ac97->regs[AC97_ALC650_MULTICH] >> 10) & 1;
1666 return 0;
1667}
1668
1669static int snd_ac97_alc655_mic_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
1670{
1671 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1672
1673 /* misc control; vrefout disable */
1674 snd_ac97_update_bits(ac97, AC97_ALC650_CLOCK, 1 << 12,
1675 ucontrol->value.integer.value[0] ? (1 << 12) : 0);
1676 return ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 1 << 10,
1677 ucontrol->value.integer.value[0] ? (1 << 10) : 0,
1678 0);
1679}
1680
1681
1682static const snd_kcontrol_new_t snd_ac97_controls_alc655[] = {
1683 AC97_PAGE_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0, 0),
1684 AC97_PAGE_SINGLE("Line-In As Surround", AC97_ALC650_MULTICH, 9, 1, 0, 0),
1685 {
1686 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1687 .name = "Mic As Center/LFE",
1688 .info = snd_ac97_info_volsw,
1689 .get = snd_ac97_alc655_mic_get,
1690 .put = snd_ac97_alc655_mic_put,
1691 .private_value = AC97_SINGLE_VALUE(0, 0, 1, 0) /* only mask needed */
1692 },
1693};
1694
1695static int alc655_iec958_route_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
1696{
1697 static char *texts_655[3] = { "PCM", "Analog In", "IEC958 In" };
1698 static char *texts_658[4] = { "PCM", "Analog1 In", "Analog2 In", "IEC958 In" };
1699 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1700
1701 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1702 uinfo->count = 1;
1703 uinfo->value.enumerated.items = ac97->spec.dev_flags ? 4 : 3;
1704 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1705 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1706 strcpy(uinfo->value.enumerated.name,
1707 ac97->spec.dev_flags ?
1708 texts_658[uinfo->value.enumerated.item] :
1709 texts_655[uinfo->value.enumerated.item]);
1710 return 0;
1711}
1712
1713static int alc655_iec958_route_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
1714{
1715 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1716 unsigned short val;
1717
1718 val = ac97->regs[AC97_ALC650_MULTICH];
1719 val = (val >> 12) & 3;
1720 if (ac97->spec.dev_flags && val == 3)
1721 val = 0;
1722 ucontrol->value.enumerated.item[0] = val;
1723 return 0;
1724}
1725
1726static int alc655_iec958_route_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
1727{
1728 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1729
1730 return ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 3 << 12,
1731 (unsigned short)ucontrol->value.enumerated.item[0] << 12,
1732 0);
1733}
1734
1735static const snd_kcontrol_new_t snd_ac97_spdif_controls_alc655[] = {
1736 AC97_PAGE_SINGLE("IEC958 Capture Switch", AC97_ALC650_MULTICH, 11, 1, 0, 0),
1737 /* disable this controls since it doesn't work as expected */
1738 /* AC97_PAGE_SINGLE("IEC958 Input Monitor", AC97_ALC650_MULTICH, 14, 1, 0, 0), */
1739 {
1740 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1741 .name = "IEC958 Playback Route",
1742 .info = alc655_iec958_route_info,
1743 .get = alc655_iec958_route_get,
1744 .put = alc655_iec958_route_put,
1745 },
1746};
1747
1748static int patch_alc655_specific(ac97_t * ac97)
1749{
1750 int err;
1751
1752 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc655, ARRAY_SIZE(snd_ac97_controls_alc655))) < 0)
1753 return err;
1754 if (ac97->ext_id & AC97_EI_SPDIF) {
1755 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc655, ARRAY_SIZE(snd_ac97_spdif_controls_alc655))) < 0)
1756 return err;
1757 }
1758 return 0;
1759}
1760
1761static struct snd_ac97_build_ops patch_alc655_ops = {
1762 .build_specific = patch_alc655_specific
1763};
1764
1765int patch_alc655(ac97_t * ac97)
1766{
1767 unsigned int val;
1768
1769 ac97->spec.dev_flags = (ac97->id == 0x414c4780); /* ALC658 */
1770
1771 ac97->build_ops = &patch_alc655_ops;
1772
1773 /* assume only page 0 for writing cache */
1774 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR);
1775
1776 /* adjust default values */
1777 val = snd_ac97_read(ac97, 0x7a); /* misc control */
1778 if (ac97->id == 0x414c4780) /* ALC658 */
1779 val &= ~(1 << 1); /* Pin 47 is spdif input pin */
1780 else /* ALC655 */
1781 val |= (1 << 1); /* Pin 47 is spdif input pin */
1782 val &= ~(1 << 12); /* vref enable */
1783 snd_ac97_write_cache(ac97, 0x7a, val);
1784 /* set default: spdif-in enabled,
1785 spdif-in monitor off, spdif-in PCM off
1786 center on mic off, surround on line-in off
1787 duplicate front off
1788 */
1789 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 1<<15);
1790
1791 /* full DAC volume */
1792 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808);
1793 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808);
1794 return 0;
1795}
1796
1797
1798#define AC97_ALC850_JACK_SELECT 0x76
1799#define AC97_ALC850_MISC1 0x7a
1800
1801static int ac97_alc850_surround_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
1802{
1803 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1804 ucontrol->value.integer.value[0] = ((ac97->regs[AC97_ALC850_JACK_SELECT] >> 12) & 7) == 2;
1805 return 0;
1806}
1807
1808static int ac97_alc850_surround_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
1809{
1810 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1811
1812 /* SURR 1kOhm (bit4), Amp (bit5) */
1813 snd_ac97_update_bits(ac97, AC97_ALC850_MISC1, (1<<4)|(1<<5),
1814 ucontrol->value.integer.value[0] ? (1<<5) : (1<<4));
1815 /* LINE-IN = 0, SURROUND = 2 */
1816 return snd_ac97_update_bits(ac97, AC97_ALC850_JACK_SELECT, 7 << 12,
1817 ucontrol->value.integer.value[0] ? (2<<12) : (0<<12));
1818}
1819
1820static int ac97_alc850_mic_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
1821{
1822 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1823 ucontrol->value.integer.value[0] = ((ac97->regs[AC97_ALC850_JACK_SELECT] >> 4) & 7) == 2;
1824 return 0;
1825}
1826
1827static int ac97_alc850_mic_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
1828{
1829 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1830
1831 /* Vref disable (bit12), 1kOhm (bit13) */
1832 snd_ac97_update_bits(ac97, AC97_ALC850_MISC1, (1<<12)|(1<<13),
1833 ucontrol->value.integer.value[0] ? (1<<12) : (1<<13));
1834 /* MIC-IN = 1, CENTER-LFE = 2 */
1835 return snd_ac97_update_bits(ac97, AC97_ALC850_JACK_SELECT, 7 << 4,
1836 ucontrol->value.integer.value[0] ? (2<<4) : (1<<4));
1837}
1838
1839static const snd_kcontrol_new_t snd_ac97_controls_alc850[] = {
1840 AC97_PAGE_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0, 0),
1841 {
1842 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1843 .name = "Line-In As Surround",
1844 .info = snd_ac97_info_volsw,
1845 .get = ac97_alc850_surround_get,
1846 .put = ac97_alc850_surround_put,
1847 .private_value = AC97_SINGLE_VALUE(0, 0, 1, 0) /* only mask needed */
1848 },
1849 {
1850 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1851 .name = "Mic As Center/LFE",
1852 .info = snd_ac97_info_volsw,
1853 .get = ac97_alc850_mic_get,
1854 .put = ac97_alc850_mic_put,
1855 .private_value = AC97_SINGLE_VALUE(0, 0, 1, 0) /* only mask needed */
1856 },
1857
1858};
1859
1860static int patch_alc850_specific(ac97_t *ac97)
1861{
1862 int err;
1863
1864 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc850, ARRAY_SIZE(snd_ac97_controls_alc850))) < 0)
1865 return err;
1866 if (ac97->ext_id & AC97_EI_SPDIF) {
1867 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc655, ARRAY_SIZE(snd_ac97_spdif_controls_alc655))) < 0)
1868 return err;
1869 }
1870 return 0;
1871}
1872
1873static struct snd_ac97_build_ops patch_alc850_ops = {
1874 .build_specific = patch_alc850_specific
1875};
1876
1877int patch_alc850(ac97_t *ac97)
1878{
1879 ac97->build_ops = &patch_alc850_ops;
1880
1881 ac97->spec.dev_flags = 0; /* for IEC958 playback route - ALC655 compatible */
1882
1883 /* assume only page 0 for writing cache */
1884 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR);
1885
1886 /* adjust default values */
1887 /* set default: spdif-in enabled,
1888 spdif-in monitor off, spdif-in PCM off
1889 center on mic off, surround on line-in off
1890 duplicate front off
1891 */
1892 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 1<<15);
1893 /* SURR_OUT: on, Surr 1kOhm: on, Surr Amp: off, Front 1kOhm: off
1894 * Front Amp: on, Vref: enable, Center 1kOhm: on, Mix: on
1895 */
1896 snd_ac97_write_cache(ac97, 0x7a, (1<<1)|(1<<4)|(0<<5)|(1<<6)|
1897 (1<<7)|(0<<12)|(1<<13)|(0<<14));
1898 /* detection UIO2,3: all path floating, UIO3: MIC, Vref2: disable,
1899 * UIO1: FRONT, Vref3: disable, UIO3: LINE, Front-Mic: mute
1900 */
1901 snd_ac97_write_cache(ac97, 0x76, (0<<0)|(0<<2)|(1<<4)|(1<<7)|(2<<8)|
1902 (1<<11)|(0<<12)|(1<<15));
1903
1904 /* full DAC volume */
1905 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808);
1906 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808);
1907 return 0;
1908}
1909
1910
1911/*
1912 * C-Media CM97xx codecs
1913 */
1914static const snd_kcontrol_new_t snd_ac97_cm9738_controls[] = {
1915 AC97_SINGLE("Line-In As Surround", AC97_CM9738_VENDOR_CTRL, 10, 1, 0),
1916 AC97_SINGLE("Duplicate Front", AC97_CM9738_VENDOR_CTRL, 13, 1, 0),
1917};
1918
1919static int patch_cm9738_specific(ac97_t * ac97)
1920{
1921 return patch_build_controls(ac97, snd_ac97_cm9738_controls, ARRAY_SIZE(snd_ac97_cm9738_controls));
1922}
1923
1924static struct snd_ac97_build_ops patch_cm9738_ops = {
1925 .build_specific = patch_cm9738_specific
1926};
1927
1928int patch_cm9738(ac97_t * ac97)
1929{
1930 ac97->build_ops = &patch_cm9738_ops;
1931 /* FIXME: can anyone confirm below? */
1932 /* CM9738 has no PCM volume although the register reacts */
1933 ac97->flags |= AC97_HAS_NO_PCM_VOL;
1934 snd_ac97_write_cache(ac97, AC97_PCM, 0x8000);
1935
1936 return 0;
1937}
1938
1939static int snd_ac97_cmedia_spdif_playback_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1940{
1941 static char *texts[] = { "Analog", "Digital" };
1942
1943 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1944 uinfo->count = 1;
1945 uinfo->value.enumerated.items = 2;
1946 if (uinfo->value.enumerated.item > 1)
1947 uinfo->value.enumerated.item = 1;
1948 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1949 return 0;
1950}
1951
1952static int snd_ac97_cmedia_spdif_playback_source_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1953{
1954 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1955 unsigned short val;
1956
1957 val = ac97->regs[AC97_CM9739_SPDIF_CTRL];
1958 ucontrol->value.enumerated.item[0] = (val >> 1) & 0x01;
1959 return 0;
1960}
1961
1962static int snd_ac97_cmedia_spdif_playback_source_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1963{
1964 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1965
1966 return snd_ac97_update_bits(ac97, AC97_CM9739_SPDIF_CTRL,
1967 0x01 << 1,
1968 (ucontrol->value.enumerated.item[0] & 0x01) << 1);
1969}
1970
1971static const snd_kcontrol_new_t snd_ac97_cm9739_controls_spdif[] = {
1972 /* BIT 0: SPDI_EN - always true */
1973 { /* BIT 1: SPDIFS */
1974 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1975 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1976 .info = snd_ac97_cmedia_spdif_playback_source_info,
1977 .get = snd_ac97_cmedia_spdif_playback_source_get,
1978 .put = snd_ac97_cmedia_spdif_playback_source_put,
1979 },
1980 /* BIT 2: IG_SPIV */
1981 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Valid Switch", AC97_CM9739_SPDIF_CTRL, 2, 1, 0),
1982 /* BIT 3: SPI2F */
1983 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Monitor", AC97_CM9739_SPDIF_CTRL, 3, 1, 0),
1984 /* BIT 4: SPI2SDI */
1985 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_CM9739_SPDIF_CTRL, 4, 1, 0),
1986 /* BIT 8: SPD32 - 32bit SPDIF - not supported yet */
1987};
1988
1989static int snd_ac97_cm9739_center_mic_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1990{
1991 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
1992 if (ac97->regs[AC97_CM9739_MULTI_CHAN] & 0x1000)
1993 ucontrol->value.integer.value[0] = 1;
1994 else
1995 ucontrol->value.integer.value[0] = 0;
1996 return 0;
1997}
1998
1999static int snd_ac97_cm9739_center_mic_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2000{
2001 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
2002 return snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 0x3000,
2003 ucontrol->value.integer.value[0] ?
2004 0x1000 : 0x2000);
2005}
2006
2007static const snd_kcontrol_new_t snd_ac97_cm9739_controls[] = {
2008 AC97_SINGLE("Line-In As Surround", AC97_CM9739_MULTI_CHAN, 10, 1, 0),
2009 {
2010 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2011 .name = "Mic As Center/LFE",
2012 .info = snd_ac97_info_volsw,
2013 .get = snd_ac97_cm9739_center_mic_get,
2014 .put = snd_ac97_cm9739_center_mic_put,
2015 .private_value = AC97_SINGLE_VALUE(0, 0, 1, 0) /* only mask needed */
2016 },
2017};
2018
2019static int patch_cm9739_specific(ac97_t * ac97)
2020{
2021 return patch_build_controls(ac97, snd_ac97_cm9739_controls, ARRAY_SIZE(snd_ac97_cm9739_controls));
2022}
2023
2024static int patch_cm9739_post_spdif(ac97_t * ac97)
2025{
2026 return patch_build_controls(ac97, snd_ac97_cm9739_controls_spdif, ARRAY_SIZE(snd_ac97_cm9739_controls_spdif));
2027}
2028
2029static struct snd_ac97_build_ops patch_cm9739_ops = {
2030 .build_specific = patch_cm9739_specific,
2031 .build_post_spdif = patch_cm9739_post_spdif
2032};
2033
2034int patch_cm9739(ac97_t * ac97)
2035{
2036 unsigned short val;
2037
2038 ac97->build_ops = &patch_cm9739_ops;
2039
2040 /* CM9739/A has no Master and PCM volume although the register reacts */
2041 ac97->flags |= AC97_HAS_NO_MASTER_VOL | AC97_HAS_NO_PCM_VOL;
2042 snd_ac97_write_cache(ac97, AC97_MASTER, 0x8000);
2043 snd_ac97_write_cache(ac97, AC97_PCM, 0x8000);
2044
2045 /* check spdif */
2046 val = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
2047 if (val & AC97_EA_SPCV) {
2048 /* enable spdif in */
2049 snd_ac97_write_cache(ac97, AC97_CM9739_SPDIF_CTRL,
2050 snd_ac97_read(ac97, AC97_CM9739_SPDIF_CTRL) | 0x01);
2051 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */
2052 } else {
2053 ac97->ext_id &= ~AC97_EI_SPDIF; /* disable extended-id */
2054 ac97->rates[AC97_RATES_SPDIF] = 0;
2055 }
2056
2057 /* set-up multi channel */
2058 /* bit 14: 0 = SPDIF, 1 = EAPD */
2059 /* bit 13: enable internal vref output for mic */
2060 /* bit 12: disable center/lfe (swithable) */
2061 /* bit 10: disable surround/line (switchable) */
2062 /* bit 9: mix 2 surround off */
2063 /* bit 4: undocumented; 0 mutes the CM9739A, which defaults to 1 */
2064 /* bit 3: undocumented; surround? */
2065 /* bit 0: dB */
2066 val = snd_ac97_read(ac97, AC97_CM9739_MULTI_CHAN) & (1 << 4);
2067 val |= (1 << 3);
2068 val |= (1 << 13);
2069 if (! (ac97->ext_id & AC97_EI_SPDIF))
2070 val |= (1 << 14);
2071 snd_ac97_write_cache(ac97, AC97_CM9739_MULTI_CHAN, val);
2072
2073 /* FIXME: set up GPIO */
2074 snd_ac97_write_cache(ac97, 0x70, 0x0100);
2075 snd_ac97_write_cache(ac97, 0x72, 0x0020);
2076 /* Special exception for ASUS W1000/CMI9739. It does not have an SPDIF in. */
2077 if (ac97->pci &&
2078 ac97->subsystem_vendor == 0x1043 &&
2079 ac97->subsystem_device == 0x1843) {
2080 snd_ac97_write_cache(ac97, AC97_CM9739_SPDIF_CTRL,
2081 snd_ac97_read(ac97, AC97_CM9739_SPDIF_CTRL) & ~0x01);
2082 snd_ac97_write_cache(ac97, AC97_CM9739_MULTI_CHAN,
2083 snd_ac97_read(ac97, AC97_CM9739_MULTI_CHAN) | (1 << 14));
2084 }
2085
2086 return 0;
2087}
2088
2089#define AC97_CM9761_MULTI_CHAN 0x64
2090#define AC97_CM9761_SPDIF_CTRL 0x6c
2091
2092static int snd_ac97_cm9761_linein_rear_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2093{
2094 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
2095 if (ac97->regs[AC97_CM9739_MULTI_CHAN] & 0x0400)
2096 ucontrol->value.integer.value[0] = 1;
2097 else
2098 ucontrol->value.integer.value[0] = 0;
2099 return 0;
2100}
2101
2102static int snd_ac97_cm9761_linein_rear_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2103{
2104 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
2105 unsigned short vals[2][2] = {
2106 { 0x0008, 0x0400 }, /* off, on */
2107 { 0x0000, 0x0408 }, /* off, on (9761-82 rev.B) */
2108 };
2109 return snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 0x0408,
2110 vals[ac97->spec.dev_flags][!!ucontrol->value.integer.value[0]]);
2111}
2112
2113static int snd_ac97_cm9761_center_mic_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2114{
2115 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
2116 if (ac97->regs[AC97_CM9739_MULTI_CHAN] & 0x1000)
2117 ucontrol->value.integer.value[0] = 1;
2118 else
2119 ucontrol->value.integer.value[0] = 0;
2120 if (ac97->spec.dev_flags) /* 9761-82 rev.B */
2121 ucontrol->value.integer.value[0] = !ucontrol->value.integer.value[0];
2122 return 0;
2123}
2124
2125static int snd_ac97_cm9761_center_mic_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2126{
2127 ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
2128 unsigned short vals[2][2] = {
2129 { 0x2000, 0x1880 }, /* off, on */
2130 { 0x1000, 0x2880 }, /* off, on (9761-82 rev.B) */
2131 };
2132 return snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 0x3880,
2133 vals[ac97->spec.dev_flags][!!ucontrol->value.integer.value[0]]);
2134}
2135
2136static const snd_kcontrol_new_t snd_ac97_cm9761_controls[] = {
2137 {
2138 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2139 .name = "Line-In As Surround",
2140 .info = snd_ac97_info_volsw,
2141 .get = snd_ac97_cm9761_linein_rear_get,
2142 .put = snd_ac97_cm9761_linein_rear_put,
2143 .private_value = AC97_SINGLE_VALUE(0, 0, 1, 0) /* only mask needed */
2144 },
2145 {
2146 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2147 .name = "Mic As Center/LFE",
2148 .info = snd_ac97_info_volsw,
2149 .get = snd_ac97_cm9761_center_mic_get,
2150 .put = snd_ac97_cm9761_center_mic_put,
2151 .private_value = AC97_SINGLE_VALUE(0, 0, 1, 0) /* only mask needed */
2152 },
2153};
2154
2155static int patch_cm9761_specific(ac97_t * ac97)
2156{
2157 return patch_build_controls(ac97, snd_ac97_cm9761_controls, ARRAY_SIZE(snd_ac97_cm9761_controls));
2158}
2159
2160static struct snd_ac97_build_ops patch_cm9761_ops = {
2161 .build_specific = patch_cm9761_specific,
2162 .build_post_spdif = patch_cm9739_post_spdif /* hope it's identical... */
2163};
2164
2165int patch_cm9761(ac97_t *ac97)
2166{
2167 unsigned short val;
2168
2169 /* CM9761 has no PCM volume although the register reacts */
2170 /* Master volume seems to have _some_ influence on the analog
2171 * input sounds
2172 */
2173 ac97->flags |= /*AC97_HAS_NO_MASTER_VOL |*/ AC97_HAS_NO_PCM_VOL;
2174 snd_ac97_write_cache(ac97, AC97_MASTER, 0x8808);
2175 snd_ac97_write_cache(ac97, AC97_PCM, 0x8808);
2176
2177 ac97->spec.dev_flags = 0; /* 1 = model 82 revision B */
2178 if (ac97->id == AC97_ID_CM9761_82) {
2179 unsigned short tmp;
2180 /* check page 1, reg 0x60 */
2181 val = snd_ac97_read(ac97, AC97_INT_PAGING);
2182 snd_ac97_write_cache(ac97, AC97_INT_PAGING, (val & ~0x0f) | 0x01);
2183 tmp = snd_ac97_read(ac97, 0x60);
2184 ac97->spec.dev_flags = tmp & 1; /* revision B? */
2185 snd_ac97_write_cache(ac97, AC97_INT_PAGING, val);
2186 }
2187
2188 ac97->build_ops = &patch_cm9761_ops;
2189
2190 /* enable spdif */
2191 /* force the SPDIF bit in ext_id - codec doesn't set this bit! */
2192 ac97->ext_id |= AC97_EI_SPDIF;
2193 /* to be sure: we overwrite the ext status bits */
2194 snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, 0x05c0);
2195 /* Don't set 0x0200 here. This results in the silent analog output */
2196 snd_ac97_write_cache(ac97, AC97_CM9761_SPDIF_CTRL, 0x0009);
2197 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */
2198
2199 /* set-up multi channel */
2200 /* bit 15: pc master beep off
2201 * bit 14: ??
2202 * bit 13: vref ctl [= cm9739]
2203 * bit 12: center/mic [= cm9739] (reverted on rev B)
2204 * bit 11: ?? (mic/center/lfe) (reverted on rev B)
2205 * bit 10: suddound/line [= cm9739]
2206 * bit 9: mix 2 surround
2207 * bit 8: ?
2208 * bit 7: ?? (mic/center/lfe)
2209 * bit 4: ?? (front)
2210 * bit 3: ?? (line-in/rear share) (revereted with rev B)
2211 * bit 2: ?? (surround)
2212 * bit 1: front mic
2213 * bit 0: mic boost
2214 */
2215
2216#if 0
2217 if (ac97->spec.dev_flags)
2218 val = 0x0214;
2219 else
2220 val = 0x321c;
2221#endif
2222 val = snd_ac97_read(ac97, AC97_CM9761_MULTI_CHAN);
2223 val |= (1 << 4); /* front on */
2224 snd_ac97_write_cache(ac97, AC97_CM9761_MULTI_CHAN, val);
2225
2226 /* FIXME: set up GPIO */
2227 snd_ac97_write_cache(ac97, 0x70, 0x0100);
2228 snd_ac97_write_cache(ac97, 0x72, 0x0020);
2229
2230 return 0;
2231}
2232
2233
2234/*
2235 * VIA VT1616 codec
2236 */
2237static const snd_kcontrol_new_t snd_ac97_controls_vt1616[] = {
2238AC97_SINGLE("DC Offset removal", 0x5a, 10, 1, 0),
2239AC97_SINGLE("Alternate Level to Surround Out", 0x5a, 15, 1, 0),
2240AC97_SINGLE("Downmix LFE and Center to Front", 0x5a, 12, 1, 0),
2241AC97_SINGLE("Downmix Surround to Front", 0x5a, 11, 1, 0),
2242};
2243
2244static int patch_vt1616_specific(ac97_t * ac97)
2245{
2246 int err;
2247
2248 if (snd_ac97_try_bit(ac97, 0x5a, 9))
2249 if ((err = patch_build_controls(ac97, &snd_ac97_controls_vt1616[0], 1)) < 0)
2250 return err;
2251 if ((err = patch_build_controls(ac97, &snd_ac97_controls_vt1616[1], ARRAY_SIZE(snd_ac97_controls_vt1616) - 1)) < 0)
2252 return err;
2253 return 0;
2254}
2255
2256static struct snd_ac97_build_ops patch_vt1616_ops = {
2257 .build_specific = patch_vt1616_specific
2258};
2259
2260int patch_vt1616(ac97_t * ac97)
2261{
2262 ac97->build_ops = &patch_vt1616_ops;
2263 return 0;
2264}
2265
2266static const snd_kcontrol_new_t snd_ac97_controls_it2646[] = {
2267 AC97_SINGLE("Line-In As Surround", 0x76, 9, 1, 0),
2268 AC97_SINGLE("Mic As Center/LFE", 0x76, 10, 1, 0),
2269};
2270
2271static const snd_kcontrol_new_t snd_ac97_spdif_controls_it2646[] = {
2272 AC97_SINGLE("IEC958 Capture Switch", 0x76, 11, 1, 0),
2273 AC97_SINGLE("Analog to IEC958 Output", 0x76, 12, 1, 0),
2274 AC97_SINGLE("IEC958 Input Monitor", 0x76, 13, 1, 0),
2275};
2276
2277static int patch_it2646_specific(ac97_t * ac97)
2278{
2279 int err;
2280 if ((err = patch_build_controls(ac97, snd_ac97_controls_it2646, ARRAY_SIZE(snd_ac97_controls_it2646))) < 0)
2281 return err;
2282 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_it2646, ARRAY_SIZE(snd_ac97_spdif_controls_it2646))) < 0)
2283 return err;
2284 return 0;
2285}
2286
2287static struct snd_ac97_build_ops patch_it2646_ops = {
2288 .build_specific = patch_it2646_specific
2289};
2290
2291int patch_it2646(ac97_t * ac97)
2292{
2293 ac97->build_ops = &patch_it2646_ops;
2294 /* full DAC volume */
2295 snd_ac97_write_cache(ac97, 0x5E, 0x0808);
2296 snd_ac97_write_cache(ac97, 0x7A, 0x0808);
2297 return 0;
2298}
2299
2300/* Si3036/8 specific registers */
2301#define AC97_SI3036_CHIP_ID 0x5a
2302
2303int mpatch_si3036(ac97_t * ac97)
2304{
2305 //printk("mpatch_si3036: chip id = %x\n", snd_ac97_read(ac97, 0x5a));
2306 snd_ac97_write_cache(ac97, 0x5c, 0xf210 );
2307 snd_ac97_write_cache(ac97, 0x68, 0);
2308 return 0;
2309}
diff --git a/sound/pci/ac97/ac97_patch.h b/sound/pci/ac97/ac97_patch.h
new file mode 100644
index 000000000000..6db51c96f5d0
--- /dev/null
+++ b/sound/pci/ac97/ac97_patch.h
@@ -0,0 +1,59 @@
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Universal interface for Audio Codec '97
4 *
5 * For more details look to AC '97 component specification revision 2.2
6 * by Intel Corporation (http://developer.intel.com).
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 */
24
25int patch_yamaha_ymf753(ac97_t * ac97);
26int patch_wolfson00(ac97_t * ac97);
27int patch_wolfson03(ac97_t * ac97);
28int patch_wolfson04(ac97_t * ac97);
29int patch_wolfson05(ac97_t * ac97);
30int patch_wolfson11(ac97_t * ac97);
31int patch_wolfson13(ac97_t * ac97);
32int patch_tritech_tr28028(ac97_t * ac97);
33int patch_sigmatel_stac9700(ac97_t * ac97);
34int patch_sigmatel_stac9708(ac97_t * ac97);
35int patch_sigmatel_stac9721(ac97_t * ac97);
36int patch_sigmatel_stac9744(ac97_t * ac97);
37int patch_sigmatel_stac9756(ac97_t * ac97);
38int patch_sigmatel_stac9758(ac97_t * ac97);
39int patch_cirrus_cs4299(ac97_t * ac97);
40int patch_cirrus_spdif(ac97_t * ac97);
41int patch_conexant(ac97_t * ac97);
42int patch_ad1819(ac97_t * ac97);
43int patch_ad1881(ac97_t * ac97);
44int patch_ad1885(ac97_t * ac97);
45int patch_ad1886(ac97_t * ac97);
46int patch_ad1888(ac97_t * ac97);
47int patch_ad1980(ac97_t * ac97);
48int patch_ad1981a(ac97_t * ac97);
49int patch_ad1981b(ac97_t * ac97);
50int patch_ad1985(ac97_t * ac97);
51int patch_alc650(ac97_t * ac97);
52int patch_alc655(ac97_t * ac97);
53int patch_alc850(ac97_t * ac97);
54int patch_cm9738(ac97_t * ac97);
55int patch_cm9739(ac97_t * ac97);
56int patch_cm9761(ac97_t * ac97);
57int patch_vt1616(ac97_t * ac97);
58int patch_it2646(ac97_t * ac97);
59int mpatch_si3036(ac97_t * ac97);
diff --git a/sound/pci/ac97/ac97_pcm.c b/sound/pci/ac97/ac97_pcm.c
new file mode 100644
index 000000000000..dd289b9512e1
--- /dev/null
+++ b/sound/pci/ac97/ac97_pcm.c
@@ -0,0 +1,700 @@
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Universal interface for Audio Codec '97
4 *
5 * For more details look to AC '97 component specification revision 2.2
6 * by Intel Corporation (http://developer.intel.com) and to datasheets
7 * for specific codecs.
8 *
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
25
26#include <sound/driver.h>
27#include <linux/delay.h>
28#include <linux/init.h>
29#include <linux/slab.h>
30#include <sound/core.h>
31#include <sound/pcm.h>
32#include <sound/control.h>
33#include <sound/ac97_codec.h>
34#include <sound/asoundef.h>
35#include "ac97_patch.h"
36#include "ac97_id.h"
37#include "ac97_local.h"
38
39/*
40 * PCM support
41 */
42
43static unsigned char rate_reg_tables[2][4][9] = {
44{
45 /* standard rates */
46 {
47 /* 3&4 front, 7&8 rear, 6&9 center/lfe */
48 AC97_PCM_FRONT_DAC_RATE, /* slot 3 */
49 AC97_PCM_FRONT_DAC_RATE, /* slot 4 */
50 0xff, /* slot 5 */
51 AC97_PCM_LFE_DAC_RATE, /* slot 6 */
52 AC97_PCM_SURR_DAC_RATE, /* slot 7 */
53 AC97_PCM_SURR_DAC_RATE, /* slot 8 */
54 AC97_PCM_LFE_DAC_RATE, /* slot 9 */
55 0xff, /* slot 10 */
56 0xff, /* slot 11 */
57 },
58 {
59 /* 7&8 front, 6&9 rear, 10&11 center/lfe */
60 0xff, /* slot 3 */
61 0xff, /* slot 4 */
62 0xff, /* slot 5 */
63 AC97_PCM_SURR_DAC_RATE, /* slot 6 */
64 AC97_PCM_FRONT_DAC_RATE, /* slot 7 */
65 AC97_PCM_FRONT_DAC_RATE, /* slot 8 */
66 AC97_PCM_SURR_DAC_RATE, /* slot 9 */
67 AC97_PCM_LFE_DAC_RATE, /* slot 10 */
68 AC97_PCM_LFE_DAC_RATE, /* slot 11 */
69 },
70 {
71 /* 6&9 front, 10&11 rear, 3&4 center/lfe */
72 AC97_PCM_LFE_DAC_RATE, /* slot 3 */
73 AC97_PCM_LFE_DAC_RATE, /* slot 4 */
74 0xff, /* slot 5 */
75 AC97_PCM_FRONT_DAC_RATE, /* slot 6 */
76 0xff, /* slot 7 */
77 0xff, /* slot 8 */
78 AC97_PCM_FRONT_DAC_RATE, /* slot 9 */
79 AC97_PCM_SURR_DAC_RATE, /* slot 10 */
80 AC97_PCM_SURR_DAC_RATE, /* slot 11 */
81 },
82 {
83 /* 10&11 front, 3&4 rear, 7&8 center/lfe */
84 AC97_PCM_SURR_DAC_RATE, /* slot 3 */
85 AC97_PCM_SURR_DAC_RATE, /* slot 4 */
86 0xff, /* slot 5 */
87 0xff, /* slot 6 */
88 AC97_PCM_LFE_DAC_RATE, /* slot 7 */
89 AC97_PCM_LFE_DAC_RATE, /* slot 8 */
90 0xff, /* slot 9 */
91 AC97_PCM_FRONT_DAC_RATE, /* slot 10 */
92 AC97_PCM_FRONT_DAC_RATE, /* slot 11 */
93 },
94},
95{
96 /* double rates */
97 {
98 /* 3&4 front, 7&8 front (t+1) */
99 AC97_PCM_FRONT_DAC_RATE, /* slot 3 */
100 AC97_PCM_FRONT_DAC_RATE, /* slot 4 */
101 0xff, /* slot 5 */
102 0xff, /* slot 6 */
103 AC97_PCM_FRONT_DAC_RATE, /* slot 7 */
104 AC97_PCM_FRONT_DAC_RATE, /* slot 8 */
105 0xff, /* slot 9 */
106 0xff, /* slot 10 */
107 0xff, /* slot 11 */
108 },
109 {
110 /* not specified in the specification */
111 0xff, /* slot 3 */
112 0xff, /* slot 4 */
113 0xff, /* slot 5 */
114 0xff, /* slot 6 */
115 0xff, /* slot 7 */
116 0xff, /* slot 8 */
117 0xff, /* slot 9 */
118 0xff, /* slot 10 */
119 0xff, /* slot 11 */
120 },
121 {
122 0xff, /* slot 3 */
123 0xff, /* slot 4 */
124 0xff, /* slot 5 */
125 0xff, /* slot 6 */
126 0xff, /* slot 7 */
127 0xff, /* slot 8 */
128 0xff, /* slot 9 */
129 0xff, /* slot 10 */
130 0xff, /* slot 11 */
131 },
132 {
133 0xff, /* slot 3 */
134 0xff, /* slot 4 */
135 0xff, /* slot 5 */
136 0xff, /* slot 6 */
137 0xff, /* slot 7 */
138 0xff, /* slot 8 */
139 0xff, /* slot 9 */
140 0xff, /* slot 10 */
141 0xff, /* slot 11 */
142 }
143}};
144
145/* FIXME: more various mappings for ADC? */
146static unsigned char rate_cregs[9] = {
147 AC97_PCM_LR_ADC_RATE, /* 3 */
148 AC97_PCM_LR_ADC_RATE, /* 4 */
149 0xff, /* 5 */
150 AC97_PCM_MIC_ADC_RATE, /* 6 */
151 0xff, /* 7 */
152 0xff, /* 8 */
153 0xff, /* 9 */
154 0xff, /* 10 */
155 0xff, /* 11 */
156};
157
158static unsigned char get_slot_reg(struct ac97_pcm *pcm, unsigned short cidx,
159 unsigned short slot, int dbl)
160{
161 if (slot < 3)
162 return 0xff;
163 if (slot > 11)
164 return 0xff;
165 if (pcm->spdif)
166 return AC97_SPDIF; /* pseudo register */
167 if (pcm->stream == SNDRV_PCM_STREAM_PLAYBACK)
168 return rate_reg_tables[dbl][pcm->r[dbl].rate_table[cidx]][slot - 3];
169 else
170 return rate_cregs[slot - 3];
171}
172
173static int set_spdif_rate(ac97_t *ac97, unsigned short rate)
174{
175 unsigned short old, bits, reg, mask;
176 unsigned int sbits;
177
178 if (! (ac97->ext_id & AC97_EI_SPDIF))
179 return -ENODEV;
180
181 /* TODO: double rate support */
182 if (ac97->flags & AC97_CS_SPDIF) {
183 switch (rate) {
184 case 48000: bits = 0; break;
185 case 44100: bits = 1 << AC97_SC_SPSR_SHIFT; break;
186 default: /* invalid - disable output */
187 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
188 return -EINVAL;
189 }
190 reg = AC97_CSR_SPDIF;
191 mask = 1 << AC97_SC_SPSR_SHIFT;
192 } else {
193 if (ac97->id == AC97_ID_CM9739 && rate != 48000) {
194 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
195 return -EINVAL;
196 }
197 switch (rate) {
198 case 44100: bits = AC97_SC_SPSR_44K; break;
199 case 48000: bits = AC97_SC_SPSR_48K; break;
200 case 32000: bits = AC97_SC_SPSR_32K; break;
201 default: /* invalid - disable output */
202 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
203 return -EINVAL;
204 }
205 reg = AC97_SPDIF;
206 mask = AC97_SC_SPSR_MASK;
207 }
208
209 down(&ac97->reg_mutex);
210 old = snd_ac97_read(ac97, reg) & mask;
211 if (old != bits) {
212 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
213 snd_ac97_update_bits_nolock(ac97, reg, mask, bits);
214 /* update the internal spdif bits */
215 sbits = ac97->spdif_status;
216 if (sbits & IEC958_AES0_PROFESSIONAL) {
217 sbits &= ~IEC958_AES0_PRO_FS;
218 switch (rate) {
219 case 44100: sbits |= IEC958_AES0_PRO_FS_44100; break;
220 case 48000: sbits |= IEC958_AES0_PRO_FS_48000; break;
221 case 32000: sbits |= IEC958_AES0_PRO_FS_32000; break;
222 }
223 } else {
224 sbits &= ~(IEC958_AES3_CON_FS << 24);
225 switch (rate) {
226 case 44100: sbits |= IEC958_AES3_CON_FS_44100<<24; break;
227 case 48000: sbits |= IEC958_AES3_CON_FS_48000<<24; break;
228 case 32000: sbits |= IEC958_AES3_CON_FS_32000<<24; break;
229 }
230 }
231 ac97->spdif_status = sbits;
232 }
233 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF);
234 up(&ac97->reg_mutex);
235 return 0;
236}
237
238/**
239 * snd_ac97_set_rate - change the rate of the given input/output.
240 * @ac97: the ac97 instance
241 * @reg: the register to change
242 * @rate: the sample rate to set
243 *
244 * Changes the rate of the given input/output on the codec.
245 * If the codec doesn't support VAR, the rate must be 48000 (except
246 * for SPDIF).
247 *
248 * The valid registers are AC97_PMC_MIC_ADC_RATE,
249 * AC97_PCM_FRONT_DAC_RATE, AC97_PCM_LR_ADC_RATE.
250 * AC97_PCM_SURR_DAC_RATE and AC97_PCM_LFE_DAC_RATE are accepted
251 * if the codec supports them.
252 * AC97_SPDIF is accepted as a pseudo register to modify the SPDIF
253 * status bits.
254 *
255 * Returns zero if successful, or a negative error code on failure.
256 */
257int snd_ac97_set_rate(ac97_t *ac97, int reg, unsigned int rate)
258{
259 int dbl;
260 unsigned int tmp;
261
262 dbl = rate > 48000;
263 if (dbl) {
264 if (!(ac97->flags & AC97_DOUBLE_RATE))
265 return -EINVAL;
266 if (reg != AC97_PCM_FRONT_DAC_RATE)
267 return -EINVAL;
268 }
269
270 switch (reg) {
271 case AC97_PCM_MIC_ADC_RATE:
272 if ((ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_VRM) == 0) /* MIC VRA */
273 if (rate != 48000)
274 return -EINVAL;
275 break;
276 case AC97_PCM_FRONT_DAC_RATE:
277 case AC97_PCM_LR_ADC_RATE:
278 if ((ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_VRA) == 0) /* VRA */
279 if (rate != 48000 && rate != 96000)
280 return -EINVAL;
281 break;
282 case AC97_PCM_SURR_DAC_RATE:
283 if (! (ac97->scaps & AC97_SCAP_SURROUND_DAC))
284 return -EINVAL;
285 break;
286 case AC97_PCM_LFE_DAC_RATE:
287 if (! (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC))
288 return -EINVAL;
289 break;
290 case AC97_SPDIF:
291 /* special case */
292 return set_spdif_rate(ac97, rate);
293 default:
294 return -EINVAL;
295 }
296 if (dbl)
297 rate /= 2;
298 tmp = (rate * ac97->bus->clock) / 48000;
299 if (tmp > 65535)
300 return -EINVAL;
301 if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE)
302 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
303 AC97_EA_DRA, dbl ? AC97_EA_DRA : 0);
304 snd_ac97_update(ac97, reg, tmp & 0xffff);
305 snd_ac97_read(ac97, reg);
306 return 0;
307}
308
309static unsigned short get_pslots(ac97_t *ac97, unsigned char *rate_table, unsigned short *spdif_slots)
310{
311 if (!ac97_is_audio(ac97))
312 return 0;
313 if (ac97_is_rev22(ac97) || ac97_can_amap(ac97)) {
314 unsigned short slots = 0;
315 if (ac97_is_rev22(ac97)) {
316 /* Note: it's simply emulation of AMAP behaviour */
317 u16 es;
318 es = ac97->regs[AC97_EXTENDED_ID] &= ~AC97_EI_DACS_SLOT_MASK;
319 switch (ac97->addr) {
320 case 1:
321 case 2: es |= (1<<AC97_EI_DACS_SLOT_SHIFT); break;
322 case 3: es |= (2<<AC97_EI_DACS_SLOT_SHIFT); break;
323 }
324 snd_ac97_write_cache(ac97, AC97_EXTENDED_ID, es);
325 }
326 switch (ac97->addr) {
327 case 0:
328 slots |= (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT);
329 if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
330 slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT);
331 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
332 slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE);
333 if (ac97->ext_id & AC97_EI_SPDIF) {
334 if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC))
335 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT)|(1<<AC97_SLOT_SPDIF_RIGHT);
336 else if (!(ac97->scaps & AC97_SCAP_CENTER_LFE_DAC))
337 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1);
338 else
339 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2);
340 }
341 *rate_table = 0;
342 break;
343 case 1:
344 case 2:
345 slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT);
346 if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
347 slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE);
348 if (ac97->ext_id & AC97_EI_SPDIF) {
349 if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC))
350 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1);
351 else
352 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2);
353 }
354 *rate_table = 1;
355 break;
356 case 3:
357 slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE);
358 if (ac97->ext_id & AC97_EI_SPDIF)
359 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2);
360 *rate_table = 2;
361 break;
362 }
363 return slots;
364 } else {
365 unsigned short slots;
366 slots = (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT);
367 if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
368 slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT);
369 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
370 slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE);
371 if (ac97->ext_id & AC97_EI_SPDIF) {
372 if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC))
373 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT)|(1<<AC97_SLOT_SPDIF_RIGHT);
374 else if (!(ac97->scaps & AC97_SCAP_CENTER_LFE_DAC))
375 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1);
376 else
377 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2);
378 }
379 *rate_table = 0;
380 return slots;
381 }
382}
383
384static unsigned short get_cslots(ac97_t *ac97)
385{
386 unsigned short slots;
387
388 if (!ac97_is_audio(ac97))
389 return 0;
390 slots = (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT);
391 slots |= (1<<AC97_SLOT_MIC);
392 return slots;
393}
394
395static unsigned int get_rates(struct ac97_pcm *pcm, unsigned int cidx, unsigned short slots, int dbl)
396{
397 int i, idx;
398 unsigned int rates = ~0;
399 unsigned char reg;
400
401 for (i = 3; i < 12; i++) {
402 if (!(slots & (1 << i)))
403 continue;
404 reg = get_slot_reg(pcm, cidx, i, dbl);
405 switch (reg) {
406 case AC97_PCM_FRONT_DAC_RATE: idx = AC97_RATES_FRONT_DAC; break;
407 case AC97_PCM_SURR_DAC_RATE: idx = AC97_RATES_SURR_DAC; break;
408 case AC97_PCM_LFE_DAC_RATE: idx = AC97_RATES_LFE_DAC; break;
409 case AC97_PCM_LR_ADC_RATE: idx = AC97_RATES_ADC; break;
410 case AC97_PCM_MIC_ADC_RATE: idx = AC97_RATES_MIC_ADC; break;
411 default: idx = AC97_RATES_SPDIF; break;
412 }
413 rates &= pcm->r[dbl].codec[cidx]->rates[idx];
414 }
415 if (!dbl)
416 rates &= ~(SNDRV_PCM_RATE_64000 | SNDRV_PCM_RATE_88200 |
417 SNDRV_PCM_RATE_96000);
418 return rates;
419}
420
421/**
422 * snd_ac97_pcm_assign - assign AC97 slots to given PCM streams
423 * @bus: the ac97 bus instance
424 * @pcms_count: count of PCMs to be assigned
425 * @pcms: PCMs to be assigned
426 *
427 * It assigns available AC97 slots for given PCMs. If none or only
428 * some slots are available, pcm->xxx.slots and pcm->xxx.rslots[] members
429 * are reduced and might be zero.
430 */
431int snd_ac97_pcm_assign(ac97_bus_t *bus,
432 unsigned short pcms_count,
433 const struct ac97_pcm *pcms)
434{
435 int i, j, k;
436 const struct ac97_pcm *pcm;
437 struct ac97_pcm *rpcms, *rpcm;
438 unsigned short avail_slots[2][4];
439 unsigned char rate_table[2][4];
440 unsigned short tmp, slots;
441 unsigned short spdif_slots[4];
442 unsigned int rates;
443 ac97_t *codec;
444
445 rpcms = kcalloc(pcms_count, sizeof(struct ac97_pcm), GFP_KERNEL);
446 if (rpcms == NULL)
447 return -ENOMEM;
448 memset(avail_slots, 0, sizeof(avail_slots));
449 memset(rate_table, 0, sizeof(rate_table));
450 memset(spdif_slots, 0, sizeof(spdif_slots));
451 for (i = 0; i < 4; i++) {
452 codec = bus->codec[i];
453 if (!codec)
454 continue;
455 avail_slots[0][i] = get_pslots(codec, &rate_table[0][i], &spdif_slots[i]);
456 avail_slots[1][i] = get_cslots(codec);
457 if (!(codec->scaps & AC97_SCAP_INDEP_SDIN)) {
458 for (j = 0; j < i; j++) {
459 if (bus->codec[j])
460 avail_slots[1][i] &= ~avail_slots[1][j];
461 }
462 }
463 }
464 /* first step - exclusive devices */
465 for (i = 0; i < pcms_count; i++) {
466 pcm = &pcms[i];
467 rpcm = &rpcms[i];
468 /* low-level driver thinks that it's more clever */
469 if (pcm->copy_flag) {
470 *rpcm = *pcm;
471 continue;
472 }
473 rpcm->stream = pcm->stream;
474 rpcm->exclusive = pcm->exclusive;
475 rpcm->spdif = pcm->spdif;
476 rpcm->private_value = pcm->private_value;
477 rpcm->bus = bus;
478 rpcm->rates = ~0;
479 slots = pcm->r[0].slots;
480 for (j = 0; j < 4 && slots; j++) {
481 if (!bus->codec[j])
482 continue;
483 rates = ~0;
484 if (pcm->spdif && pcm->stream == 0)
485 tmp = spdif_slots[j];
486 else
487 tmp = avail_slots[pcm->stream][j];
488 if (pcm->exclusive) {
489 /* exclusive access */
490 tmp &= slots;
491 for (k = 0; k < i; k++) {
492 if (rpcm->stream == rpcms[k].stream)
493 tmp &= ~rpcms[k].r[0].rslots[j];
494 }
495 } else {
496 /* non-exclusive access */
497 tmp &= pcm->r[0].slots;
498 }
499 if (tmp) {
500 rpcm->r[0].rslots[j] = tmp;
501 rpcm->r[0].codec[j] = bus->codec[j];
502 rpcm->r[0].rate_table[j] = rate_table[pcm->stream][j];
503 if (bus->no_vra)
504 rates = SNDRV_PCM_RATE_48000;
505 else
506 rates = get_rates(rpcm, j, tmp, 0);
507 if (pcm->exclusive)
508 avail_slots[pcm->stream][j] &= ~tmp;
509 }
510 slots &= ~tmp;
511 rpcm->r[0].slots |= tmp;
512 rpcm->rates &= rates;
513 }
514 /* for double rate, we check the first codec only */
515 if (pcm->stream == SNDRV_PCM_STREAM_PLAYBACK &&
516 bus->codec[0] && (bus->codec[0]->flags & AC97_DOUBLE_RATE) &&
517 rate_table[pcm->stream][0] == 0) {
518 tmp = (1<<AC97_SLOT_PCM_LEFT) | (1<<AC97_SLOT_PCM_RIGHT) |
519 (1<<AC97_SLOT_PCM_LEFT_0) | (1<<AC97_SLOT_PCM_RIGHT_0);
520 if ((tmp & pcm->r[1].slots) == tmp) {
521 rpcm->r[1].slots = tmp;
522 rpcm->r[1].rslots[0] = tmp;
523 rpcm->r[1].rate_table[0] = 0;
524 rpcm->r[1].codec[0] = bus->codec[0];
525 if (pcm->exclusive)
526 avail_slots[pcm->stream][0] &= ~tmp;
527 if (bus->no_vra)
528 rates = SNDRV_PCM_RATE_96000;
529 else
530 rates = get_rates(rpcm, 0, tmp, 1);
531 rpcm->rates |= rates;
532 }
533 }
534 if (rpcm->rates == ~0)
535 rpcm->rates = 0; /* not used */
536 }
537 bus->pcms_count = pcms_count;
538 bus->pcms = rpcms;
539 return 0;
540}
541
542/**
543 * snd_ac97_pcm_open - opens the given AC97 pcm
544 * @pcm: the ac97 pcm instance
545 * @rate: rate in Hz, if codec does not support VRA, this value must be 48000Hz
546 * @cfg: output stream characteristics
547 * @slots: a subset of allocated slots (snd_ac97_pcm_assign) for this pcm
548 *
549 * It locks the specified slots and sets the given rate to AC97 registers.
550 */
551int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate,
552 enum ac97_pcm_cfg cfg, unsigned short slots)
553{
554 ac97_bus_t *bus;
555 int i, cidx, r, ok_flag;
556 unsigned int reg_ok[4] = {0,0,0,0};
557 unsigned char reg;
558 int err = 0;
559
560 r = rate > 48000;
561 bus = pcm->bus;
562 if (cfg == AC97_PCM_CFG_SPDIF) {
563 int err;
564 for (cidx = 0; cidx < 4; cidx++)
565 if (bus->codec[cidx] && (bus->codec[cidx]->ext_id & AC97_EI_SPDIF)) {
566 err = set_spdif_rate(bus->codec[cidx], rate);
567 if (err < 0)
568 return err;
569 }
570 }
571 spin_lock_irq(&pcm->bus->bus_lock);
572 for (i = 3; i < 12; i++) {
573 if (!(slots & (1 << i)))
574 continue;
575 ok_flag = 0;
576 for (cidx = 0; cidx < 4; cidx++) {
577 if (bus->used_slots[pcm->stream][cidx] & (1 << i)) {
578 spin_unlock_irq(&pcm->bus->bus_lock);
579 err = -EBUSY;
580 goto error;
581 }
582 if (pcm->r[r].rslots[cidx] & (1 << i)) {
583 bus->used_slots[pcm->stream][cidx] |= (1 << i);
584 ok_flag++;
585 }
586 }
587 if (!ok_flag) {
588 spin_unlock_irq(&pcm->bus->bus_lock);
589 snd_printk(KERN_ERR "cannot find configuration for AC97 slot %i\n", i);
590 err = -EAGAIN;
591 goto error;
592 }
593 }
594 spin_unlock_irq(&pcm->bus->bus_lock);
595 for (i = 3; i < 12; i++) {
596 if (!(slots & (1 << i)))
597 continue;
598 for (cidx = 0; cidx < 4; cidx++) {
599 if (pcm->r[r].rslots[cidx] & (1 << i)) {
600 reg = get_slot_reg(pcm, cidx, i, r);
601 if (reg == 0xff) {
602 snd_printk(KERN_ERR "invalid AC97 slot %i?\n", i);
603 continue;
604 }
605 if (reg_ok[cidx] & (1 << (reg - AC97_PCM_FRONT_DAC_RATE)))
606 continue;
607 //printk(KERN_DEBUG "setting ac97 reg 0x%x to rate %d\n", reg, rate);
608 err = snd_ac97_set_rate(pcm->r[r].codec[cidx], reg, rate);
609 if (err < 0)
610 snd_printk(KERN_ERR "error in snd_ac97_set_rate: cidx=%d, reg=0x%x, rate=%d, err=%d\n", cidx, reg, rate, err);
611 else
612 reg_ok[cidx] |= (1 << (reg - AC97_PCM_FRONT_DAC_RATE));
613 }
614 }
615 }
616 pcm->aslots = slots;
617 return 0;
618
619 error:
620 pcm->aslots = slots;
621 snd_ac97_pcm_close(pcm);
622 return err;
623}
624
625/**
626 * snd_ac97_pcm_close - closes the given AC97 pcm
627 * @pcm: the ac97 pcm instance
628 *
629 * It frees the locked AC97 slots.
630 */
631int snd_ac97_pcm_close(struct ac97_pcm *pcm)
632{
633 ac97_bus_t *bus;
634 unsigned short slots = pcm->aslots;
635 int i, cidx;
636
637 bus = pcm->bus;
638 spin_lock_irq(&pcm->bus->bus_lock);
639 for (i = 3; i < 12; i++) {
640 if (!(slots & (1 << i)))
641 continue;
642 for (cidx = 0; cidx < 4; cidx++)
643 bus->used_slots[pcm->stream][cidx] &= ~(1 << i);
644 }
645 pcm->aslots = 0;
646 spin_unlock_irq(&pcm->bus->bus_lock);
647 return 0;
648}
649
650static int double_rate_hw_constraint_rate(snd_pcm_hw_params_t *params,
651 snd_pcm_hw_rule_t *rule)
652{
653 snd_interval_t *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
654 if (channels->min > 2) {
655 static const snd_interval_t single_rates = {
656 .min = 1,
657 .max = 48000,
658 };
659 snd_interval_t *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
660 return snd_interval_refine(rate, &single_rates);
661 }
662 return 0;
663}
664
665static int double_rate_hw_constraint_channels(snd_pcm_hw_params_t *params,
666 snd_pcm_hw_rule_t *rule)
667{
668 snd_interval_t *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
669 if (rate->min > 48000) {
670 static const snd_interval_t double_rate_channels = {
671 .min = 2,
672 .max = 2,
673 };
674 snd_interval_t *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
675 return snd_interval_refine(channels, &double_rate_channels);
676 }
677 return 0;
678}
679
680/**
681 * snd_ac97_pcm_double_rate_rules - set double rate constraints
682 * @runtime: the runtime of the ac97 front playback pcm
683 *
684 * Installs the hardware constraint rules to prevent using double rates and
685 * more than two channels at the same time.
686 */
687int snd_ac97_pcm_double_rate_rules(snd_pcm_runtime_t *runtime)
688{
689 int err;
690
691 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
692 double_rate_hw_constraint_rate, NULL,
693 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
694 if (err < 0)
695 return err;
696 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
697 double_rate_hw_constraint_channels, NULL,
698 SNDRV_PCM_HW_PARAM_RATE, -1);
699 return err;
700}
diff --git a/sound/pci/ac97/ac97_proc.c b/sound/pci/ac97/ac97_proc.c
new file mode 100644
index 000000000000..a040b2666ed7
--- /dev/null
+++ b/sound/pci/ac97/ac97_proc.c
@@ -0,0 +1,449 @@
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Universal interface for Audio Codec '97
4 *
5 * For more details look to AC '97 component specification revision 2.2
6 * by Intel Corporation (http://developer.intel.com).
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 */
24
25#include <sound/driver.h>
26#include <linux/slab.h>
27#include <sound/core.h>
28#include <sound/ac97_codec.h>
29#include <sound/asoundef.h>
30#include "ac97_local.h"
31#include "ac97_id.h"
32
33/*
34 * proc interface
35 */
36
37static void snd_ac97_proc_read_functions(ac97_t *ac97, snd_info_buffer_t *buffer)
38{
39 int header = 0, function;
40 unsigned short info, sense_info;
41 static const char *function_names[12] = {
42 "Master Out", "AUX Out", "Center/LFE Out", "SPDIF Out",
43 "Phone In", "Mic 1", "Mic 2", "Line In", "CD In", "Video In",
44 "Aux In", "Mono Out"
45 };
46 static const char *locations[8] = {
47 "Rear I/O Panel", "Front Panel", "Motherboard", "Dock/External",
48 "reserved", "reserved", "reserved", "NC/unused"
49 };
50
51 for (function = 0; function < 12; ++function) {
52 snd_ac97_write(ac97, AC97_FUNC_SELECT, function << 1);
53 info = snd_ac97_read(ac97, AC97_FUNC_INFO);
54 if (!(info & 0x0001))
55 continue;
56 if (!header) {
57 snd_iprintf(buffer, "\n Gain Inverted Buffer delay Location\n");
58 header = 1;
59 }
60 sense_info = snd_ac97_read(ac97, AC97_SENSE_INFO);
61 snd_iprintf(buffer, "%-17s: %3d.%d dBV %c %2d/fs %s\n",
62 function_names[function],
63 (info & 0x8000 ? -1 : 1) * ((info & 0x7000) >> 12) * 3 / 2,
64 ((info & 0x0800) >> 11) * 5,
65 info & 0x0400 ? 'X' : '-',
66 (info & 0x03e0) >> 5,
67 locations[sense_info >> 13]);
68 }
69}
70
71static void snd_ac97_proc_read_main(ac97_t *ac97, snd_info_buffer_t * buffer, int subidx)
72{
73 char name[64];
74 unsigned short val, tmp, ext, mext;
75 static const char *spdif_slots[4] = { " SPDIF=3/4", " SPDIF=7/8", " SPDIF=6/9", " SPDIF=10/11" };
76 static const char *spdif_rates[4] = { " Rate=44.1kHz", " Rate=res", " Rate=48kHz", " Rate=32kHz" };
77 static const char *spdif_rates_cs4205[4] = { " Rate=48kHz", " Rate=44.1kHz", " Rate=res", " Rate=res" };
78 static const char *double_rate_slots[4] = { "10/11", "7/8", "reserved", "reserved" };
79
80 snd_ac97_get_name(NULL, ac97->id, name, 0);
81 snd_iprintf(buffer, "%d-%d/%d: %s\n\n", ac97->addr, ac97->num, subidx, name);
82 if ((ac97->scaps & AC97_SCAP_AUDIO) == 0)
83 goto __modem;
84
85 if ((ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23) {
86 val = snd_ac97_read(ac97, AC97_INT_PAGING);
87 snd_ac97_update_bits(ac97, AC97_INT_PAGING,
88 AC97_PAGE_MASK, AC97_PAGE_1);
89 tmp = snd_ac97_read(ac97, AC97_CODEC_CLASS_REV);
90 snd_iprintf(buffer, "Revision : 0x%02x\n", tmp & 0xff);
91 snd_iprintf(buffer, "Compat. Class : 0x%02x\n", (tmp >> 8) & 0x1f);
92 snd_iprintf(buffer, "Subsys. Vendor ID: 0x%04x\n",
93 snd_ac97_read(ac97, AC97_PCI_SVID));
94 snd_iprintf(buffer, "Subsys. ID : 0x%04x\n\n",
95 snd_ac97_read(ac97, AC97_PCI_SID));
96 snd_ac97_update_bits(ac97, AC97_INT_PAGING,
97 AC97_PAGE_MASK, val & AC97_PAGE_MASK);
98 }
99
100 // val = snd_ac97_read(ac97, AC97_RESET);
101 val = ac97->caps;
102 snd_iprintf(buffer, "Capabilities :%s%s%s%s%s%s\n",
103 val & AC97_BC_DEDICATED_MIC ? " -dedicated MIC PCM IN channel-" : "",
104 val & AC97_BC_RESERVED1 ? " -reserved1-" : "",
105 val & AC97_BC_BASS_TREBLE ? " -bass & treble-" : "",
106 val & AC97_BC_SIM_STEREO ? " -simulated stereo-" : "",
107 val & AC97_BC_HEADPHONE ? " -headphone out-" : "",
108 val & AC97_BC_LOUDNESS ? " -loudness-" : "");
109 tmp = ac97->caps & AC97_BC_DAC_MASK;
110 snd_iprintf(buffer, "DAC resolution : %s%s%s%s\n",
111 tmp == AC97_BC_16BIT_DAC ? "16-bit" : "",
112 tmp == AC97_BC_18BIT_DAC ? "18-bit" : "",
113 tmp == AC97_BC_20BIT_DAC ? "20-bit" : "",
114 tmp == AC97_BC_DAC_MASK ? "???" : "");
115 tmp = ac97->caps & AC97_BC_ADC_MASK;
116 snd_iprintf(buffer, "ADC resolution : %s%s%s%s\n",
117 tmp == AC97_BC_16BIT_ADC ? "16-bit" : "",
118 tmp == AC97_BC_18BIT_ADC ? "18-bit" : "",
119 tmp == AC97_BC_20BIT_ADC ? "20-bit" : "",
120 tmp == AC97_BC_ADC_MASK ? "???" : "");
121 snd_iprintf(buffer, "3D enhancement : %s\n",
122 snd_ac97_stereo_enhancements[(val >> 10) & 0x1f]);
123 snd_iprintf(buffer, "\nCurrent setup\n");
124 val = snd_ac97_read(ac97, AC97_MIC);
125 snd_iprintf(buffer, "Mic gain : %s [%s]\n", val & 0x0040 ? "+20dB" : "+0dB", ac97->regs[AC97_MIC] & 0x0040 ? "+20dB" : "+0dB");
126 val = snd_ac97_read(ac97, AC97_GENERAL_PURPOSE);
127 snd_iprintf(buffer, "POP path : %s 3D\n"
128 "Sim. stereo : %s\n"
129 "3D enhancement : %s\n"
130 "Loudness : %s\n"
131 "Mono output : %s\n"
132 "Mic select : %s\n"
133 "ADC/DAC loopback : %s\n",
134 val & 0x8000 ? "post" : "pre",
135 val & 0x4000 ? "on" : "off",
136 val & 0x2000 ? "on" : "off",
137 val & 0x1000 ? "on" : "off",
138 val & 0x0200 ? "Mic" : "MIX",
139 val & 0x0100 ? "Mic2" : "Mic1",
140 val & 0x0080 ? "on" : "off");
141 if (ac97->ext_id & AC97_EI_DRA)
142 snd_iprintf(buffer, "Double rate slots: %s\n",
143 double_rate_slots[(val >> 10) & 3]);
144
145 ext = snd_ac97_read(ac97, AC97_EXTENDED_ID);
146 if (ext == 0)
147 goto __modem;
148
149 snd_iprintf(buffer, "Extended ID : codec=%i rev=%i%s%s%s%s DSA=%i%s%s%s%s\n",
150 (ext & AC97_EI_ADDR_MASK) >> AC97_EI_ADDR_SHIFT,
151 (ext & AC97_EI_REV_MASK) >> AC97_EI_REV_SHIFT,
152 ext & AC97_EI_AMAP ? " AMAP" : "",
153 ext & AC97_EI_LDAC ? " LDAC" : "",
154 ext & AC97_EI_SDAC ? " SDAC" : "",
155 ext & AC97_EI_CDAC ? " CDAC" : "",
156 (ext & AC97_EI_DACS_SLOT_MASK) >> AC97_EI_DACS_SLOT_SHIFT,
157 ext & AC97_EI_VRM ? " VRM" : "",
158 ext & AC97_EI_SPDIF ? " SPDIF" : "",
159 ext & AC97_EI_DRA ? " DRA" : "",
160 ext & AC97_EI_VRA ? " VRA" : "");
161 val = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
162 snd_iprintf(buffer, "Extended status :%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
163 val & AC97_EA_PRL ? " PRL" : "",
164 val & AC97_EA_PRK ? " PRK" : "",
165 val & AC97_EA_PRJ ? " PRJ" : "",
166 val & AC97_EA_PRI ? " PRI" : "",
167 val & AC97_EA_SPCV ? " SPCV" : "",
168 val & AC97_EA_MDAC ? " MADC" : "",
169 val & AC97_EA_LDAC ? " LDAC" : "",
170 val & AC97_EA_SDAC ? " SDAC" : "",
171 val & AC97_EA_CDAC ? " CDAC" : "",
172 ext & AC97_EI_SPDIF ? spdif_slots[(val & AC97_EA_SPSA_SLOT_MASK) >> AC97_EA_SPSA_SLOT_SHIFT] : "",
173 val & AC97_EA_VRM ? " VRM" : "",
174 val & AC97_EA_SPDIF ? " SPDIF" : "",
175 val & AC97_EA_DRA ? " DRA" : "",
176 val & AC97_EA_VRA ? " VRA" : "");
177 if (ext & AC97_EI_VRA) { /* VRA */
178 val = snd_ac97_read(ac97, AC97_PCM_FRONT_DAC_RATE);
179 snd_iprintf(buffer, "PCM front DAC : %iHz\n", val);
180 if (ext & AC97_EI_SDAC) {
181 val = snd_ac97_read(ac97, AC97_PCM_SURR_DAC_RATE);
182 snd_iprintf(buffer, "PCM Surr DAC : %iHz\n", val);
183 }
184 if (ext & AC97_EI_LDAC) {
185 val = snd_ac97_read(ac97, AC97_PCM_LFE_DAC_RATE);
186 snd_iprintf(buffer, "PCM LFE DAC : %iHz\n", val);
187 }
188 val = snd_ac97_read(ac97, AC97_PCM_LR_ADC_RATE);
189 snd_iprintf(buffer, "PCM ADC : %iHz\n", val);
190 }
191 if (ext & AC97_EI_VRM) {
192 val = snd_ac97_read(ac97, AC97_PCM_MIC_ADC_RATE);
193 snd_iprintf(buffer, "PCM MIC ADC : %iHz\n", val);
194 }
195 if ((ext & AC97_EI_SPDIF) || (ac97->flags & AC97_CS_SPDIF)) {
196 if (ac97->flags & AC97_CS_SPDIF)
197 val = snd_ac97_read(ac97, AC97_CSR_SPDIF);
198 else
199 val = snd_ac97_read(ac97, AC97_SPDIF);
200
201 snd_iprintf(buffer, "SPDIF Control :%s%s%s%s Category=0x%x Generation=%i%s%s%s\n",
202 val & AC97_SC_PRO ? " PRO" : " Consumer",
203 val & AC97_SC_NAUDIO ? " Non-audio" : " PCM",
204 val & AC97_SC_COPY ? "" : " Copyright",
205 val & AC97_SC_PRE ? " Preemph50/15" : "",
206 (val & AC97_SC_CC_MASK) >> AC97_SC_CC_SHIFT,
207 (val & AC97_SC_L) >> 11,
208 (ac97->flags & AC97_CS_SPDIF) ?
209 spdif_rates_cs4205[(val & AC97_SC_SPSR_MASK) >> AC97_SC_SPSR_SHIFT] :
210 spdif_rates[(val & AC97_SC_SPSR_MASK) >> AC97_SC_SPSR_SHIFT],
211 (ac97->flags & AC97_CS_SPDIF) ?
212 (val & AC97_SC_DRS ? " Validity" : "") :
213 (val & AC97_SC_DRS ? " DRS" : ""),
214 (ac97->flags & AC97_CS_SPDIF) ?
215 (val & AC97_SC_V ? " Enabled" : "") :
216 (val & AC97_SC_V ? " Validity" : ""));
217 /* ALC650 specific*/
218 if ((ac97->id & 0xfffffff0) == 0x414c4720 &&
219 (snd_ac97_read(ac97, AC97_ALC650_CLOCK) & 0x01)) {
220 val = snd_ac97_read(ac97, AC97_ALC650_SPDIF_INPUT_STATUS2);
221 if (val & AC97_ALC650_CLOCK_LOCK) {
222 val = snd_ac97_read(ac97, AC97_ALC650_SPDIF_INPUT_STATUS1);
223 snd_iprintf(buffer, "SPDIF In Status :%s%s%s%s Category=0x%x Generation=%i",
224 val & AC97_ALC650_PRO ? " PRO" : " Consumer",
225 val & AC97_ALC650_NAUDIO ? " Non-audio" : " PCM",
226 val & AC97_ALC650_COPY ? "" : " Copyright",
227 val & AC97_ALC650_PRE ? " Preemph50/15" : "",
228 (val & AC97_ALC650_CC_MASK) >> AC97_ALC650_CC_SHIFT,
229 (val & AC97_ALC650_L) >> 15);
230 val = snd_ac97_read(ac97, AC97_ALC650_SPDIF_INPUT_STATUS2);
231 snd_iprintf(buffer, "%s Accuracy=%i%s%s\n",
232 spdif_rates[(val & AC97_ALC650_SPSR_MASK) >> AC97_ALC650_SPSR_SHIFT],
233 (val & AC97_ALC650_CLOCK_ACCURACY) >> AC97_ALC650_CLOCK_SHIFT,
234 (val & AC97_ALC650_CLOCK_LOCK ? " Locked" : " Unlocked"),
235 (val & AC97_ALC650_V ? " Validity?" : ""));
236 } else {
237 snd_iprintf(buffer, "SPDIF In Status : Not Locked\n");
238 }
239 }
240 }
241 if ((ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23) {
242 val = snd_ac97_read(ac97, AC97_INT_PAGING);
243 snd_ac97_update_bits(ac97, AC97_INT_PAGING,
244 AC97_PAGE_MASK, AC97_PAGE_1);
245 snd_ac97_proc_read_functions(ac97, buffer);
246 snd_ac97_update_bits(ac97, AC97_INT_PAGING,
247 AC97_PAGE_MASK, val & AC97_PAGE_MASK);
248 }
249
250
251 __modem:
252 mext = snd_ac97_read(ac97, AC97_EXTENDED_MID);
253 if (mext == 0)
254 return;
255
256 snd_iprintf(buffer, "Extended modem ID: codec=%i%s%s%s%s%s\n",
257 (mext & AC97_MEI_ADDR_MASK) >> AC97_MEI_ADDR_SHIFT,
258 mext & AC97_MEI_CID2 ? " CID2" : "",
259 mext & AC97_MEI_CID1 ? " CID1" : "",
260 mext & AC97_MEI_HANDSET ? " HSET" : "",
261 mext & AC97_MEI_LINE2 ? " LIN2" : "",
262 mext & AC97_MEI_LINE1 ? " LIN1" : "");
263 val = snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS);
264 snd_iprintf(buffer, "Modem status :%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
265 val & AC97_MEA_GPIO ? " GPIO" : "",
266 val & AC97_MEA_MREF ? " MREF" : "",
267 val & AC97_MEA_ADC1 ? " ADC1" : "",
268 val & AC97_MEA_DAC1 ? " DAC1" : "",
269 val & AC97_MEA_ADC2 ? " ADC2" : "",
270 val & AC97_MEA_DAC2 ? " DAC2" : "",
271 val & AC97_MEA_HADC ? " HADC" : "",
272 val & AC97_MEA_HDAC ? " HDAC" : "",
273 val & AC97_MEA_PRA ? " PRA(GPIO)" : "",
274 val & AC97_MEA_PRB ? " PRB(res)" : "",
275 val & AC97_MEA_PRC ? " PRC(ADC1)" : "",
276 val & AC97_MEA_PRD ? " PRD(DAC1)" : "",
277 val & AC97_MEA_PRE ? " PRE(ADC2)" : "",
278 val & AC97_MEA_PRF ? " PRF(DAC2)" : "",
279 val & AC97_MEA_PRG ? " PRG(HADC)" : "",
280 val & AC97_MEA_PRH ? " PRH(HDAC)" : "");
281 if (mext & AC97_MEI_LINE1) {
282 val = snd_ac97_read(ac97, AC97_LINE1_RATE);
283 snd_iprintf(buffer, "Line1 rate : %iHz\n", val);
284 }
285 if (mext & AC97_MEI_LINE2) {
286 val = snd_ac97_read(ac97, AC97_LINE2_RATE);
287 snd_iprintf(buffer, "Line2 rate : %iHz\n", val);
288 }
289 if (mext & AC97_MEI_HANDSET) {
290 val = snd_ac97_read(ac97, AC97_HANDSET_RATE);
291 snd_iprintf(buffer, "Headset rate : %iHz\n", val);
292 }
293}
294
295static void snd_ac97_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
296{
297 ac97_t *ac97 = entry->private_data;
298
299 down(&ac97->page_mutex);
300 if ((ac97->id & 0xffffff40) == AC97_ID_AD1881) { // Analog Devices AD1881/85/86
301 int idx;
302 for (idx = 0; idx < 3; idx++)
303 if (ac97->spec.ad18xx.id[idx]) {
304 /* select single codec */
305 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
306 ac97->spec.ad18xx.unchained[idx] | ac97->spec.ad18xx.chained[idx]);
307 snd_ac97_proc_read_main(ac97, buffer, idx);
308 snd_iprintf(buffer, "\n\n");
309 }
310 /* select all codecs */
311 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
312
313 snd_iprintf(buffer, "\nAD18XX configuration\n");
314 snd_iprintf(buffer, "Unchained : 0x%04x,0x%04x,0x%04x\n",
315 ac97->spec.ad18xx.unchained[0],
316 ac97->spec.ad18xx.unchained[1],
317 ac97->spec.ad18xx.unchained[2]);
318 snd_iprintf(buffer, "Chained : 0x%04x,0x%04x,0x%04x\n",
319 ac97->spec.ad18xx.chained[0],
320 ac97->spec.ad18xx.chained[1],
321 ac97->spec.ad18xx.chained[2]);
322 } else {
323 snd_ac97_proc_read_main(ac97, buffer, 0);
324 }
325 up(&ac97->page_mutex);
326}
327
328#ifdef CONFIG_SND_DEBUG
329/* direct register write for debugging */
330static void snd_ac97_proc_regs_write(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
331{
332 ac97_t *ac97 = entry->private_data;
333 char line[64];
334 unsigned int reg, val;
335 down(&ac97->page_mutex);
336 while (!snd_info_get_line(buffer, line, sizeof(line))) {
337 if (sscanf(line, "%x %x", &reg, &val) != 2)
338 continue;
339 /* register must be even */
340 if (reg < 0x80 && (reg & 1) == 0 && val <= 0xffff)
341 snd_ac97_write_cache(ac97, reg, val);
342 }
343 up(&ac97->page_mutex);
344}
345#endif
346
347static void snd_ac97_proc_regs_read_main(ac97_t *ac97, snd_info_buffer_t * buffer, int subidx)
348{
349 int reg, val;
350
351 for (reg = 0; reg < 0x80; reg += 2) {
352 val = snd_ac97_read(ac97, reg);
353 snd_iprintf(buffer, "%i:%02x = %04x\n", subidx, reg, val);
354 }
355}
356
357static void snd_ac97_proc_regs_read(snd_info_entry_t *entry,
358 snd_info_buffer_t * buffer)
359{
360 ac97_t *ac97 = entry->private_data;
361
362 down(&ac97->page_mutex);
363 if ((ac97->id & 0xffffff40) == AC97_ID_AD1881) { // Analog Devices AD1881/85/86
364
365 int idx;
366 for (idx = 0; idx < 3; idx++)
367 if (ac97->spec.ad18xx.id[idx]) {
368 /* select single codec */
369 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
370 ac97->spec.ad18xx.unchained[idx] | ac97->spec.ad18xx.chained[idx]);
371 snd_ac97_proc_regs_read_main(ac97, buffer, idx);
372 }
373 /* select all codecs */
374 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
375 } else {
376 snd_ac97_proc_regs_read_main(ac97, buffer, 0);
377 }
378 up(&ac97->page_mutex);
379}
380
381void snd_ac97_proc_init(ac97_t * ac97)
382{
383 snd_info_entry_t *entry;
384 char name[32];
385 const char *prefix;
386
387 if (ac97->bus->proc == NULL)
388 return;
389 prefix = ac97_is_audio(ac97) ? "ac97" : "mc97";
390 sprintf(name, "%s#%d-%d", prefix, ac97->addr, ac97->num);
391 if ((entry = snd_info_create_card_entry(ac97->bus->card, name, ac97->bus->proc)) != NULL) {
392 snd_info_set_text_ops(entry, ac97, 1024, snd_ac97_proc_read);
393 if (snd_info_register(entry) < 0) {
394 snd_info_free_entry(entry);
395 entry = NULL;
396 }
397 }
398 ac97->proc = entry;
399 sprintf(name, "%s#%d-%d+regs", prefix, ac97->addr, ac97->num);
400 if ((entry = snd_info_create_card_entry(ac97->bus->card, name, ac97->bus->proc)) != NULL) {
401 snd_info_set_text_ops(entry, ac97, 1024, snd_ac97_proc_regs_read);
402#ifdef CONFIG_SND_DEBUG
403 entry->mode |= S_IWUSR;
404 entry->c.text.write_size = 1024;
405 entry->c.text.write = snd_ac97_proc_regs_write;
406#endif
407 if (snd_info_register(entry) < 0) {
408 snd_info_free_entry(entry);
409 entry = NULL;
410 }
411 }
412 ac97->proc_regs = entry;
413}
414
415void snd_ac97_proc_done(ac97_t * ac97)
416{
417 if (ac97->proc_regs) {
418 snd_info_unregister(ac97->proc_regs);
419 ac97->proc_regs = NULL;
420 }
421 if (ac97->proc) {
422 snd_info_unregister(ac97->proc);
423 ac97->proc = NULL;
424 }
425}
426
427void snd_ac97_bus_proc_init(ac97_bus_t * bus)
428{
429 snd_info_entry_t *entry;
430 char name[32];
431
432 sprintf(name, "codec97#%d", bus->num);
433 if ((entry = snd_info_create_card_entry(bus->card, name, bus->card->proc_root)) != NULL) {
434 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
435 if (snd_info_register(entry) < 0) {
436 snd_info_free_entry(entry);
437 entry = NULL;
438 }
439 }
440 bus->proc = entry;
441}
442
443void snd_ac97_bus_proc_done(ac97_bus_t * bus)
444{
445 if (bus->proc) {
446 snd_info_unregister(bus->proc);
447 bus->proc = NULL;
448 }
449}
diff --git a/sound/pci/ac97/ak4531_codec.c b/sound/pci/ac97/ak4531_codec.c
new file mode 100644
index 000000000000..f9ce0fd2f52f
--- /dev/null
+++ b/sound/pci/ac97/ak4531_codec.c
@@ -0,0 +1,437 @@
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Universal routines for AK4531 codec
4 *
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
22#include <sound/driver.h>
23#include <linux/delay.h>
24#include <linux/init.h>
25#include <linux/slab.h>
26#include <sound/core.h>
27#include <sound/ak4531_codec.h>
28
29MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
30MODULE_DESCRIPTION("Universal routines for AK4531 codec");
31MODULE_LICENSE("GPL");
32
33static void snd_ak4531_proc_init(snd_card_t * card, ak4531_t * ak4531);
34
35/*
36 *
37 */
38
39#if 0
40
41static void snd_ak4531_dump(ak4531_t *ak4531)
42{
43 int idx;
44
45 for (idx = 0; idx < 0x19; idx++)
46 printk("ak4531 0x%x: 0x%x\n", idx, ak4531->regs[idx]);
47}
48
49#endif
50
51/*
52 *
53 */
54
55#define AK4531_SINGLE(xname, xindex, reg, shift, mask, invert) \
56{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
57 .info = snd_ak4531_info_single, \
58 .get = snd_ak4531_get_single, .put = snd_ak4531_put_single, \
59 .private_value = reg | (shift << 16) | (mask << 24) | (invert << 22) }
60
61static int snd_ak4531_info_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo)
62{
63 int mask = (kcontrol->private_value >> 24) & 0xff;
64
65 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
66 uinfo->count = 1;
67 uinfo->value.integer.min = 0;
68 uinfo->value.integer.max = mask;
69 return 0;
70}
71
72static int snd_ak4531_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
73{
74 ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol);
75 int reg = kcontrol->private_value & 0xff;
76 int shift = (kcontrol->private_value >> 16) & 0x07;
77 int mask = (kcontrol->private_value >> 24) & 0xff;
78 int invert = (kcontrol->private_value >> 22) & 1;
79 int val;
80
81 down(&ak4531->reg_mutex);
82 val = (ak4531->regs[reg] >> shift) & mask;
83 up(&ak4531->reg_mutex);
84 if (invert) {
85 val = mask - val;
86 }
87 ucontrol->value.integer.value[0] = val;
88 return 0;
89}
90
91static int snd_ak4531_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
92{
93 ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol);
94 int reg = kcontrol->private_value & 0xff;
95 int shift = (kcontrol->private_value >> 16) & 0x07;
96 int mask = (kcontrol->private_value >> 24) & 0xff;
97 int invert = (kcontrol->private_value >> 22) & 1;
98 int change;
99 int val;
100
101 val = ucontrol->value.integer.value[0] & mask;
102 if (invert) {
103 val = mask - val;
104 }
105 val <<= shift;
106 down(&ak4531->reg_mutex);
107 val = (ak4531->regs[reg] & ~(mask << shift)) | val;
108 change = val != ak4531->regs[reg];
109 ak4531->write(ak4531, reg, ak4531->regs[reg] = val);
110 up(&ak4531->reg_mutex);
111 return change;
112}
113
114#define AK4531_DOUBLE(xname, xindex, left_reg, right_reg, left_shift, right_shift, mask, invert) \
115{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
116 .info = snd_ak4531_info_double, \
117 .get = snd_ak4531_get_double, .put = snd_ak4531_put_double, \
118 .private_value = left_reg | (right_reg << 8) | (left_shift << 16) | (right_shift << 19) | (mask << 24) | (invert << 22) }
119
120static int snd_ak4531_info_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo)
121{
122 int mask = (kcontrol->private_value >> 24) & 0xff;
123
124 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
125 uinfo->count = 2;
126 uinfo->value.integer.min = 0;
127 uinfo->value.integer.max = mask;
128 return 0;
129}
130
131static int snd_ak4531_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
132{
133 ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol);
134 int left_reg = kcontrol->private_value & 0xff;
135 int right_reg = (kcontrol->private_value >> 8) & 0xff;
136 int left_shift = (kcontrol->private_value >> 16) & 0x07;
137 int right_shift = (kcontrol->private_value >> 19) & 0x07;
138 int mask = (kcontrol->private_value >> 24) & 0xff;
139 int invert = (kcontrol->private_value >> 22) & 1;
140 int left, right;
141
142 down(&ak4531->reg_mutex);
143 left = (ak4531->regs[left_reg] >> left_shift) & mask;
144 right = (ak4531->regs[right_reg] >> right_shift) & mask;
145 up(&ak4531->reg_mutex);
146 if (invert) {
147 left = mask - left;
148 right = mask - right;
149 }
150 ucontrol->value.integer.value[0] = left;
151 ucontrol->value.integer.value[1] = right;
152 return 0;
153}
154
155static int snd_ak4531_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
156{
157 ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol);
158 int left_reg = kcontrol->private_value & 0xff;
159 int right_reg = (kcontrol->private_value >> 8) & 0xff;
160 int left_shift = (kcontrol->private_value >> 16) & 0x07;
161 int right_shift = (kcontrol->private_value >> 19) & 0x07;
162 int mask = (kcontrol->private_value >> 24) & 0xff;
163 int invert = (kcontrol->private_value >> 22) & 1;
164 int change;
165 int left, right;
166
167 left = ucontrol->value.integer.value[0] & mask;
168 right = ucontrol->value.integer.value[1] & mask;
169 if (invert) {
170 left = mask - left;
171 right = mask - right;
172 }
173 left <<= left_shift;
174 right <<= right_shift;
175 down(&ak4531->reg_mutex);
176 if (left_reg == right_reg) {
177 left = (ak4531->regs[left_reg] & ~((mask << left_shift) | (mask << right_shift))) | left | right;
178 change = left != ak4531->regs[left_reg];
179 ak4531->write(ak4531, left_reg, ak4531->regs[left_reg] = left);
180 } else {
181 left = (ak4531->regs[left_reg] & ~(mask << left_shift)) | left;
182 right = (ak4531->regs[right_reg] & ~(mask << right_shift)) | right;
183 change = left != ak4531->regs[left_reg] || right != ak4531->regs[right_reg];
184 ak4531->write(ak4531, left_reg, ak4531->regs[left_reg] = left);
185 ak4531->write(ak4531, right_reg, ak4531->regs[right_reg] = right);
186 }
187 up(&ak4531->reg_mutex);
188 return change;
189}
190
191#define AK4531_INPUT_SW(xname, xindex, reg1, reg2, left_shift, right_shift) \
192{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
193 .info = snd_ak4531_info_input_sw, \
194 .get = snd_ak4531_get_input_sw, .put = snd_ak4531_put_input_sw, \
195 .private_value = reg1 | (reg2 << 8) | (left_shift << 16) | (right_shift << 24) }
196
197static int snd_ak4531_info_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo)
198{
199 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
200 uinfo->count = 4;
201 uinfo->value.integer.min = 0;
202 uinfo->value.integer.max = 1;
203 return 0;
204}
205
206static int snd_ak4531_get_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
207{
208 ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol);
209 int reg1 = kcontrol->private_value & 0xff;
210 int reg2 = (kcontrol->private_value >> 8) & 0xff;
211 int left_shift = (kcontrol->private_value >> 16) & 0x0f;
212 int right_shift = (kcontrol->private_value >> 24) & 0x0f;
213
214 down(&ak4531->reg_mutex);
215 ucontrol->value.integer.value[0] = (ak4531->regs[reg1] >> left_shift) & 1;
216 ucontrol->value.integer.value[1] = (ak4531->regs[reg2] >> left_shift) & 1;
217 ucontrol->value.integer.value[2] = (ak4531->regs[reg1] >> right_shift) & 1;
218 ucontrol->value.integer.value[3] = (ak4531->regs[reg2] >> right_shift) & 1;
219 up(&ak4531->reg_mutex);
220 return 0;
221}
222
223static int snd_ak4531_put_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
224{
225 ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol);
226 int reg1 = kcontrol->private_value & 0xff;
227 int reg2 = (kcontrol->private_value >> 8) & 0xff;
228 int left_shift = (kcontrol->private_value >> 16) & 0x0f;
229 int right_shift = (kcontrol->private_value >> 24) & 0x0f;
230 int change;
231 int val1, val2;
232
233 down(&ak4531->reg_mutex);
234 val1 = ak4531->regs[reg1] & ~((1 << left_shift) | (1 << right_shift));
235 val2 = ak4531->regs[reg2] & ~((1 << left_shift) | (1 << right_shift));
236 val1 |= (ucontrol->value.integer.value[0] & 1) << left_shift;
237 val2 |= (ucontrol->value.integer.value[1] & 1) << left_shift;
238 val1 |= (ucontrol->value.integer.value[2] & 1) << right_shift;
239 val2 |= (ucontrol->value.integer.value[3] & 1) << right_shift;
240 change = val1 != ak4531->regs[reg1] || val2 != ak4531->regs[reg2];
241 ak4531->write(ak4531, reg1, ak4531->regs[reg1] = val1);
242 ak4531->write(ak4531, reg2, ak4531->regs[reg2] = val2);
243 up(&ak4531->reg_mutex);
244 return change;
245}
246
247static snd_kcontrol_new_t snd_ak4531_controls[] = {
248
249AK4531_DOUBLE("Master Playback Switch", 0, AK4531_LMASTER, AK4531_RMASTER, 7, 7, 1, 1),
250AK4531_DOUBLE("Master Playback Volume", 0, AK4531_LMASTER, AK4531_RMASTER, 0, 0, 0x1f, 1),
251
252AK4531_SINGLE("Master Mono Playback Switch", 0, AK4531_MONO_OUT, 7, 1, 1),
253AK4531_SINGLE("Master Mono Playback Volume", 0, AK4531_MONO_OUT, 0, 0x07, 1),
254
255AK4531_DOUBLE("PCM Switch", 0, AK4531_LVOICE, AK4531_RVOICE, 7, 7, 1, 1),
256AK4531_DOUBLE("PCM Volume", 0, AK4531_LVOICE, AK4531_RVOICE, 0, 0, 0x1f, 1),
257AK4531_DOUBLE("PCM Playback Switch", 0, AK4531_OUT_SW2, AK4531_OUT_SW2, 3, 2, 1, 0),
258AK4531_DOUBLE("PCM Capture Switch", 0, AK4531_LIN_SW2, AK4531_RIN_SW2, 2, 2, 1, 0),
259
260AK4531_DOUBLE("PCM Switch", 1, AK4531_LFM, AK4531_RFM, 7, 7, 1, 1),
261AK4531_DOUBLE("PCM Volume", 1, AK4531_LFM, AK4531_RFM, 0, 0, 0x1f, 1),
262AK4531_DOUBLE("PCM Playback Switch", 1, AK4531_OUT_SW1, AK4531_OUT_SW1, 6, 5, 1, 0),
263AK4531_INPUT_SW("PCM Capture Route", 1, AK4531_LIN_SW1, AK4531_RIN_SW1, 6, 5),
264
265AK4531_DOUBLE("CD Switch", 0, AK4531_LCD, AK4531_RCD, 7, 7, 1, 1),
266AK4531_DOUBLE("CD Volume", 0, AK4531_LCD, AK4531_RCD, 0, 0, 0x1f, 1),
267AK4531_DOUBLE("CD Playback Switch", 0, AK4531_OUT_SW1, AK4531_OUT_SW1, 2, 1, 1, 0),
268AK4531_INPUT_SW("CD Capture Route", 0, AK4531_LIN_SW1, AK4531_RIN_SW1, 2, 1),
269
270AK4531_DOUBLE("Line Switch", 0, AK4531_LLINE, AK4531_RLINE, 7, 7, 1, 1),
271AK4531_DOUBLE("Line Volume", 0, AK4531_LLINE, AK4531_RLINE, 0, 0, 0x1f, 1),
272AK4531_DOUBLE("Line Playback Switch", 0, AK4531_OUT_SW1, AK4531_OUT_SW1, 4, 3, 1, 0),
273AK4531_INPUT_SW("Line Capture Route", 0, AK4531_LIN_SW1, AK4531_RIN_SW1, 4, 3),
274
275AK4531_DOUBLE("Aux Switch", 0, AK4531_LAUXA, AK4531_RAUXA, 7, 7, 1, 1),
276AK4531_DOUBLE("Aux Volume", 0, AK4531_LAUXA, AK4531_RAUXA, 0, 0, 0x1f, 1),
277AK4531_DOUBLE("Aux Playback Switch", 0, AK4531_OUT_SW2, AK4531_OUT_SW2, 5, 4, 1, 0),
278AK4531_INPUT_SW("Aux Capture Route", 0, AK4531_LIN_SW2, AK4531_RIN_SW2, 4, 3),
279
280AK4531_SINGLE("Mono Switch", 0, AK4531_MONO1, 7, 1, 1),
281AK4531_SINGLE("Mono Volume", 0, AK4531_MONO1, 0, 0x1f, 1),
282AK4531_SINGLE("Mono Playback Switch", 0, AK4531_OUT_SW2, 0, 1, 0),
283AK4531_DOUBLE("Mono Capture Switch", 0, AK4531_LIN_SW2, AK4531_RIN_SW2, 0, 0, 1, 0),
284
285AK4531_SINGLE("Mono Switch", 1, AK4531_MONO2, 7, 1, 1),
286AK4531_SINGLE("Mono Volume", 1, AK4531_MONO2, 0, 0x1f, 1),
287AK4531_SINGLE("Mono Playback Switch", 1, AK4531_OUT_SW2, 1, 1, 0),
288AK4531_DOUBLE("Mono Capture Switch", 1, AK4531_LIN_SW2, AK4531_RIN_SW2, 1, 1, 1, 0),
289
290AK4531_SINGLE("Mic Volume", 0, AK4531_MIC, 0, 0x1f, 1),
291AK4531_SINGLE("Mic Switch", 0, AK4531_MIC, 7, 1, 1),
292AK4531_SINGLE("Mic Playback Switch", 0, AK4531_OUT_SW1, 0, 1, 0),
293AK4531_DOUBLE("Mic Capture Switch", 0, AK4531_LIN_SW1, AK4531_RIN_SW1, 0, 0, 1, 0),
294
295AK4531_DOUBLE("Mic Bypass Capture Switch", 0, AK4531_LIN_SW2, AK4531_RIN_SW2, 7, 7, 1, 0),
296AK4531_DOUBLE("Mono1 Bypass Capture Switch", 0, AK4531_LIN_SW2, AK4531_RIN_SW2, 6, 6, 1, 0),
297AK4531_DOUBLE("Mono2 Bypass Capture Switch", 0, AK4531_LIN_SW2, AK4531_RIN_SW2, 5, 5, 1, 0),
298
299AK4531_SINGLE("AD Input Select", 0, AK4531_AD_IN, 0, 1, 0),
300AK4531_SINGLE("Mic Boost (+30dB)", 0, AK4531_MIC_GAIN, 0, 1, 0)
301};
302
303static int snd_ak4531_free(ak4531_t *ak4531)
304{
305 if (ak4531) {
306 if (ak4531->private_free)
307 ak4531->private_free(ak4531);
308 kfree(ak4531);
309 }
310 return 0;
311}
312
313static int snd_ak4531_dev_free(snd_device_t *device)
314{
315 ak4531_t *ak4531 = device->device_data;
316 return snd_ak4531_free(ak4531);
317}
318
319static u8 snd_ak4531_initial_map[0x19 + 1] = {
320 0x9f, /* 00: Master Volume Lch */
321 0x9f, /* 01: Master Volume Rch */
322 0x9f, /* 02: Voice Volume Lch */
323 0x9f, /* 03: Voice Volume Rch */
324 0x9f, /* 04: FM Volume Lch */
325 0x9f, /* 05: FM Volume Rch */
326 0x9f, /* 06: CD Audio Volume Lch */
327 0x9f, /* 07: CD Audio Volume Rch */
328 0x9f, /* 08: Line Volume Lch */
329 0x9f, /* 09: Line Volume Rch */
330 0x9f, /* 0a: Aux Volume Lch */
331 0x9f, /* 0b: Aux Volume Rch */
332 0x9f, /* 0c: Mono1 Volume */
333 0x9f, /* 0d: Mono2 Volume */
334 0x9f, /* 0e: Mic Volume */
335 0x87, /* 0f: Mono-out Volume */
336 0x00, /* 10: Output Mixer SW1 */
337 0x00, /* 11: Output Mixer SW2 */
338 0x00, /* 12: Lch Input Mixer SW1 */
339 0x00, /* 13: Rch Input Mixer SW1 */
340 0x00, /* 14: Lch Input Mixer SW2 */
341 0x00, /* 15: Rch Input Mixer SW2 */
342 0x00, /* 16: Reset & Power Down */
343 0x00, /* 17: Clock Select */
344 0x00, /* 18: AD Input Select */
345 0x01 /* 19: Mic Amp Setup */
346};
347
348int snd_ak4531_mixer(snd_card_t * card, ak4531_t * _ak4531, ak4531_t ** rak4531)
349{
350 unsigned int idx;
351 int err;
352 ak4531_t * ak4531;
353 static snd_device_ops_t ops = {
354 .dev_free = snd_ak4531_dev_free,
355 };
356
357 snd_assert(rak4531 != NULL, return -EINVAL);
358 *rak4531 = NULL;
359 snd_assert(card != NULL && _ak4531 != NULL, return -EINVAL);
360 ak4531 = kcalloc(1, sizeof(*ak4531), GFP_KERNEL);
361 if (ak4531 == NULL)
362 return -ENOMEM;
363 *ak4531 = *_ak4531;
364 init_MUTEX(&ak4531->reg_mutex);
365 if ((err = snd_component_add(card, "AK4531")) < 0) {
366 snd_ak4531_free(ak4531);
367 return err;
368 }
369 strcpy(card->mixername, "Asahi Kasei AK4531");
370 ak4531->write(ak4531, AK4531_RESET, 0x03); /* no RST, PD */
371 udelay(100);
372 ak4531->write(ak4531, AK4531_CLOCK, 0x00); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off LRCLK2 PLL */
373 for (idx = 0; idx < 0x19; idx++) {
374 if (idx == AK4531_RESET || idx == AK4531_CLOCK)
375 continue;
376 ak4531->write(ak4531, idx, ak4531->regs[idx] = snd_ak4531_initial_map[idx]); /* recording source is mixer */
377 }
378 for (idx = 0; idx < ARRAY_SIZE(snd_ak4531_controls); idx++) {
379 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_ak4531_controls[idx], ak4531))) < 0) {
380 snd_ak4531_free(ak4531);
381 return err;
382 }
383 }
384 snd_ak4531_proc_init(card, ak4531);
385 if ((err = snd_device_new(card, SNDRV_DEV_CODEC, ak4531, &ops)) < 0) {
386 snd_ak4531_free(ak4531);
387 return err;
388 }
389
390#if 0
391 snd_ak4531_dump(ak4531);
392#endif
393 *rak4531 = ak4531;
394 return 0;
395}
396
397/*
398
399 */
400
401static void snd_ak4531_proc_read(snd_info_entry_t *entry,
402 snd_info_buffer_t * buffer)
403{
404 ak4531_t *ak4531 = entry->private_data;
405
406 snd_iprintf(buffer, "Asahi Kasei AK4531\n\n");
407 snd_iprintf(buffer, "Recording source : %s\n"
408 "MIC gain : %s\n",
409 ak4531->regs[AK4531_AD_IN] & 1 ? "external" : "mixer",
410 ak4531->regs[AK4531_MIC_GAIN] & 1 ? "+30dB" : "+0dB");
411}
412
413static void snd_ak4531_proc_init(snd_card_t * card, ak4531_t * ak4531)
414{
415 snd_info_entry_t *entry;
416
417 if (! snd_card_proc_new(card, "ak4531", &entry))
418 snd_info_set_text_ops(entry, ak4531, 1024, snd_ak4531_proc_read);
419}
420
421EXPORT_SYMBOL(snd_ak4531_mixer);
422
423/*
424 * INIT part
425 */
426
427static int __init alsa_ak4531_init(void)
428{
429 return 0;
430}
431
432static void __exit alsa_ak4531_exit(void)
433{
434}
435
436module_init(alsa_ak4531_init)
437module_exit(alsa_ak4531_exit)
generated by cgit v1.2.2 (git 2.25.0) at 2026-01-10 22:21:01 -0500