?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / sound / i2c / other / ak4xxx-adda.c
blobcef813d23641afcd39b56a57c5fc8058cb99bfb0
1 /*
2 * ALSA driver for AK4524 / AK4528 / AK4529 / AK4355 / AK4358 / AK4381
3 * AD and DA converters
4 *
5 * Copyright (c) 2000-2004 Jaroslav Kysela <perex@perex.cz>,
6 * Takashi Iwai <tiwai@suse.de>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
24 #include <asm/io.h>
25 #include <linux/delay.h>
26 #include <linux/interrupt.h>
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <sound/core.h>
30 #include <sound/control.h>
31 #include <sound/tlv.h>
32 #include <sound/ak4xxx-adda.h>
33 #include <sound/info.h>
34
35 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
36 MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters");
37 MODULE_LICENSE("GPL");
38
39 /* write the given register and save the data to the cache */
40 void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg,
41 unsigned char val)
42 {
43 ak->ops.lock(ak, chip);
44 ak->ops.write(ak, chip, reg, val);
45
46 /* save the data */
47 snd_akm4xxx_set(ak, chip, reg, val);
48 ak->ops.unlock(ak, chip);
49 }
50
51 EXPORT_SYMBOL(snd_akm4xxx_write);
52
53 /* reset procedure for AK4524 and AK4528 */
54 static void ak4524_reset(struct snd_akm4xxx *ak, int state)
55 {
56 unsigned int chip;
57 unsigned char reg;
58
59 for (chip = 0; chip < ak->num_dacs/2; chip++) {
60 snd_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03);
61 if (state)
62 continue;
63 /* DAC volumes */
64 for (reg = 0x04; reg < ak->total_regs; reg++)
65 snd_akm4xxx_write(ak, chip, reg,
66 snd_akm4xxx_get(ak, chip, reg));
67 }
68 }
69
70 /* reset procedure for AK4355 and AK4358 */
71 static void ak435X_reset(struct snd_akm4xxx *ak, int state)
72 {
73 unsigned char reg;
74
75 if (state) {
76 snd_akm4xxx_write(ak, 0, 0x01, 0x02); /* reset and soft-mute */
77 return;
78 }
79 for (reg = 0x00; reg < ak->total_regs; reg++)
80 if (reg != 0x01)
81 snd_akm4xxx_write(ak, 0, reg,
82 snd_akm4xxx_get(ak, 0, reg));
83 snd_akm4xxx_write(ak, 0, 0x01, 0x01); /* un-reset, unmute */
84 }
85
86 /* reset procedure for AK4381 */
87 static void ak4381_reset(struct snd_akm4xxx *ak, int state)
88 {
89 unsigned int chip;
90 unsigned char reg;
91 for (chip = 0; chip < ak->num_dacs/2; chip++) {
92 snd_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f);
93 if (state)
94 continue;
95 for (reg = 0x01; reg < ak->total_regs; reg++)
96 snd_akm4xxx_write(ak, chip, reg,
97 snd_akm4xxx_get(ak, chip, reg));
98 }
99 }
100
101 /*
102 * reset the AKM codecs
103 * @state: 1 = reset codec, 0 = restore the registers
104 *
105 * assert the reset operation and restores the register values to the chips.
106 */
107 void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state)
108 {
109 switch (ak->type) {
110 case SND_AK4524:
111 case SND_AK4528:
112 case SND_AK4620:
113 ak4524_reset(ak, state);
114 break;
115 case SND_AK4529:
116 /* FIXME: needed for ak4529? */
117 break;
118 case SND_AK4355:
119 ak435X_reset(ak, state);
120 break;
121 case SND_AK4358:
122 ak435X_reset(ak, state);
123 break;
124 case SND_AK4381:
125 ak4381_reset(ak, state);
126 break;
127 default:
128 break;
129 }
130 }
131
132 EXPORT_SYMBOL(snd_akm4xxx_reset);
133
134
135 /*
136 * Volume conversion table for non-linear volumes
137 * from -63.5dB (mute) to 0dB step 0.5dB
138 *
139 * Used for AK4524/AK4620 input/ouput attenuation, AK4528, and
140 * AK5365 input attenuation
141 */
142 static const unsigned char vol_cvt_datt[128] = {
143 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04,
144 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06,
145 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x0a,
146 0x0a, 0x0b, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0f,
147 0x10, 0x10, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14,
148 0x15, 0x16, 0x17, 0x17, 0x18, 0x19, 0x1a, 0x1c,
149 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x23,
150 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 0x2b, 0x2d,
151 0x2e, 0x30, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
152 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3e, 0x3f, 0x40,
153 0x41, 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x4a,
154 0x4b, 0x4d, 0x4e, 0x50, 0x51, 0x52, 0x53, 0x54,
155 0x55, 0x56, 0x58, 0x59, 0x5b, 0x5c, 0x5e, 0x5f,
156 0x60, 0x61, 0x62, 0x64, 0x65, 0x66, 0x67, 0x69,
157 0x6a, 0x6c, 0x6d, 0x6f, 0x70, 0x71, 0x72, 0x73,
158 0x75, 0x76, 0x77, 0x79, 0x7a, 0x7c, 0x7d, 0x7f,
159 };
160
161 /*
162 * dB tables
163 */
164 static const DECLARE_TLV_DB_SCALE(db_scale_vol_datt, -6350, 50, 1);
165 static const DECLARE_TLV_DB_SCALE(db_scale_8bit, -12750, 50, 1);
166 static const DECLARE_TLV_DB_SCALE(db_scale_7bit, -6350, 50, 1);
167 static const DECLARE_TLV_DB_LINEAR(db_scale_linear, TLV_DB_GAIN_MUTE, 0);
168
169 /*
170 * initialize all the ak4xxx chips
171 */
172 void snd_akm4xxx_init(struct snd_akm4xxx *ak)
173 {
174 static const unsigned char inits_ak4524[] = {
175 0x00, 0x07, /* 0: all power up */
176 0x01, 0x00, /* 1: ADC/DAC reset */
177 0x02, 0x60, /* 2: 24bit I2S */
178 0x03, 0x19, /* 3: deemphasis off */
179 0x01, 0x03, /* 1: ADC/DAC enable */
180 0x04, 0x00, /* 4: ADC left muted */
181 0x05, 0x00, /* 5: ADC right muted */
182 0x06, 0x00, /* 6: DAC left muted */
183 0x07, 0x00, /* 7: DAC right muted */
184 0xff, 0xff
185 };
186 static const unsigned char inits_ak4528[] = {
187 0x00, 0x07, /* 0: all power up */
188 0x01, 0x00, /* 1: ADC/DAC reset */
189 0x02, 0x60, /* 2: 24bit I2S */
190 0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */
191 0x01, 0x03, /* 1: ADC/DAC enable */
192 0x04, 0x00, /* 4: ADC left muted */
193 0x05, 0x00, /* 5: ADC right muted */
194 0xff, 0xff
195 };
196 static const unsigned char inits_ak4529[] = {
197 0x09, 0x01, /* 9: ATS=0, RSTN=1 */
198 0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
199 0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
200 0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
201 0x02, 0xff, /* 2: LOUT1 muted */
202 0x03, 0xff, /* 3: ROUT1 muted */
203 0x04, 0xff, /* 4: LOUT2 muted */
204 0x05, 0xff, /* 5: ROUT2 muted */
205 0x06, 0xff, /* 6: LOUT3 muted */
206 0x07, 0xff, /* 7: ROUT3 muted */
207 0x0b, 0xff, /* B: LOUT4 muted */
208 0x0c, 0xff, /* C: ROUT4 muted */
209 0x08, 0x55, /* 8: deemphasis all off */
210 0xff, 0xff
211 };
212 static const unsigned char inits_ak4355[] = {
213 0x01, 0x02, /* 1: reset and soft-mute */
214 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect,
215 * disable DZF, sharp roll-off, RSTN#=0 */
216 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */
217 // 0x02, 0x2e, /* quad speed */
218 0x03, 0x01, /* 3: de-emphasis off */
219 0x04, 0x00, /* 4: LOUT1 volume muted */
220 0x05, 0x00, /* 5: ROUT1 volume muted */
221 0x06, 0x00, /* 6: LOUT2 volume muted */
222 0x07, 0x00, /* 7: ROUT2 volume muted */
223 0x08, 0x00, /* 8: LOUT3 volume muted */
224 0x09, 0x00, /* 9: ROUT3 volume muted */
225 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
226 0x01, 0x01, /* 1: un-reset, unmute */
227 0xff, 0xff
228 };
229 static const unsigned char inits_ak4358[] = {
230 0x01, 0x02, /* 1: reset and soft-mute */
231 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect,
232 * disable DZF, sharp roll-off, RSTN#=0 */
233 0x02, 0x4e, /* 2: DA's power up, normal speed, RSTN#=0 */
234 /* 0x02, 0x6e,*/ /* quad speed */
235 0x03, 0x01, /* 3: de-emphasis off */
236 0x04, 0x00, /* 4: LOUT1 volume muted */
237 0x05, 0x00, /* 5: ROUT1 volume muted */
238 0x06, 0x00, /* 6: LOUT2 volume muted */
239 0x07, 0x00, /* 7: ROUT2 volume muted */
240 0x08, 0x00, /* 8: LOUT3 volume muted */
241 0x09, 0x00, /* 9: ROUT3 volume muted */
242 0x0b, 0x00, /* b: LOUT4 volume muted */
243 0x0c, 0x00, /* c: ROUT4 volume muted */
244 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
245 0x01, 0x01, /* 1: un-reset, unmute */
246 0xff, 0xff
247 };
248 static const unsigned char inits_ak4381[] = {
249 0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */
250 0x01, 0x02, /* 1: de-emphasis off, normal speed,
251 * sharp roll-off, DZF off */
252 // 0x01, 0x12, /* quad speed */
253 0x02, 0x00, /* 2: DZF disabled */
254 0x03, 0x00, /* 3: LATT 0 */
255 0x04, 0x00, /* 4: RATT 0 */
256 0x00, 0x0f, /* 0: power-up, un-reset */
257 0xff, 0xff
258 };
259 static const unsigned char inits_ak4620[] = {
260 0x00, 0x07, /* 0: normal */
261 0x01, 0x00, /* 0: reset */
262 0x01, 0x02, /* 1: RSTAD */
263 0x01, 0x03, /* 1: RSTDA */
264 0x01, 0x0f, /* 1: normal */
265 0x02, 0x60, /* 2: 24bit I2S */
266 0x03, 0x01, /* 3: deemphasis off */
267 0x04, 0x00, /* 4: LIN muted */
268 0x05, 0x00, /* 5: RIN muted */
269 0x06, 0x00, /* 6: LOUT muted */
270 0x07, 0x00, /* 7: ROUT muted */
271 0xff, 0xff
272 };
273
274 int chip;
275 const unsigned char *ptr, *inits;
276 unsigned char reg, data;
277
278 memset(ak->images, 0, sizeof(ak->images));
279 memset(ak->volumes, 0, sizeof(ak->volumes));
280
281 switch (ak->type) {
282 case SND_AK4524:
283 inits = inits_ak4524;
284 ak->num_chips = ak->num_dacs / 2;
285 ak->name = "ak4524";
286 ak->total_regs = 0x08;
287 break;
288 case SND_AK4528:
289 inits = inits_ak4528;
290 ak->num_chips = ak->num_dacs / 2;
291 ak->name = "ak4528";
292 ak->total_regs = 0x06;
293 break;
294 case SND_AK4529:
295 inits = inits_ak4529;
296 ak->num_chips = 1;
297 ak->name = "ak4529";
298 ak->total_regs = 0x0d;
299 break;
300 case SND_AK4355:
301 inits = inits_ak4355;
302 ak->num_chips = 1;
303 ak->name = "ak4355";
304 ak->total_regs = 0x0b;
305 break;
306 case SND_AK4358:
307 inits = inits_ak4358;
308 ak->num_chips = 1;
309 ak->name = "ak4358";
310 ak->total_regs = 0x10;
311 break;
312 case SND_AK4381:
313 inits = inits_ak4381;
314 ak->num_chips = ak->num_dacs / 2;
315 ak->name = "ak4381";
316 ak->total_regs = 0x05;
317 break;
318 case SND_AK5365:
319 /* FIXME: any init sequence? */
320 ak->num_chips = 1;
321 ak->name = "ak5365";
322 ak->total_regs = 0x08;
323 return;
324 case SND_AK4620:
325 inits = inits_ak4620;
326 ak->num_chips = ak->num_dacs / 2;
327 ak->name = "ak4620";
328 ak->total_regs = 0x08;
329 break;
330 default:
331 snd_BUG();
332 return;
333 }
334
335 for (chip = 0; chip < ak->num_chips; chip++) {
336 ptr = inits;
337 while (*ptr != 0xff) {
338 reg = *ptr++;
339 data = *ptr++;
340 snd_akm4xxx_write(ak, chip, reg, data);
341 udelay(10);
342 }
343 }
344 }
345
346 EXPORT_SYMBOL(snd_akm4xxx_init);
347
348 /*
349 * Mixer callbacks
350 */
351 #define AK_IPGA (1<<20) /* including IPGA */
352 #define AK_VOL_CVT (1<<21) /* need dB conversion */
353 #define AK_NEEDSMSB (1<<22) /* need MSB update bit */
354 #define AK_INVERT (1<<23) /* data is inverted */
355 #define AK_GET_CHIP(val) (((val) >> 8) & 0xff)
356 #define AK_GET_ADDR(val) ((val) & 0xff)
357 #define AK_GET_SHIFT(val) (((val) >> 16) & 0x0f)
358 #define AK_GET_VOL_CVT(val) (((val) >> 21) & 1)
359 #define AK_GET_IPGA(val) (((val) >> 20) & 1)
360 #define AK_GET_NEEDSMSB(val) (((val) >> 22) & 1)
361 #define AK_GET_INVERT(val) (((val) >> 23) & 1)
362 #define AK_GET_MASK(val) (((val) >> 24) & 0xff)
363 #define AK_COMPOSE(chip,addr,shift,mask) \
364 (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
365
366 static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol,
367 struct snd_ctl_elem_info *uinfo)
368 {
369 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
370
371 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
372 uinfo->count = 1;
373 uinfo->value.integer.min = 0;
374 uinfo->value.integer.max = mask;
375 return 0;
376 }
377
378 static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol,
379 struct snd_ctl_elem_value *ucontrol)
380 {
381 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
382 int chip = AK_GET_CHIP(kcontrol->private_value);
383 int addr = AK_GET_ADDR(kcontrol->private_value);
384
385 ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
386 return 0;
387 }
388
389 static int put_ak_reg(struct snd_kcontrol *kcontrol, int addr,
390 unsigned char nval)
391 {
392 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
393 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
394 int chip = AK_GET_CHIP(kcontrol->private_value);
395
396 if (snd_akm4xxx_get_vol(ak, chip, addr) == nval)
397 return 0;
398
399 snd_akm4xxx_set_vol(ak, chip, addr, nval);
400 if (AK_GET_VOL_CVT(kcontrol->private_value) && nval < 128)
401 nval = vol_cvt_datt[nval];
402 if (AK_GET_IPGA(kcontrol->private_value) && nval >= 128)
403 nval++; /* need to correct + 1 since both 127 and 128 are 0dB */
404 if (AK_GET_INVERT(kcontrol->private_value))
405 nval = mask - nval;
406 if (AK_GET_NEEDSMSB(kcontrol->private_value))
407 nval |= 0x80;
408 /* printk(KERN_DEBUG "DEBUG - AK writing reg: chip %x addr %x,
409 nval %x\n", chip, addr, nval); */
410 snd_akm4xxx_write(ak, chip, addr, nval);
411 return 1;
412 }
413
414 static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol,
415 struct snd_ctl_elem_value *ucontrol)
416 {
417 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
418 unsigned int val = ucontrol->value.integer.value[0];
419 if (val > mask)
420 return -EINVAL;
421 return put_ak_reg(kcontrol, AK_GET_ADDR(kcontrol->private_value), val);
422 }
423
424 static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol *kcontrol,
425 struct snd_ctl_elem_info *uinfo)
426 {
427 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
428
429 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
430 uinfo->count = 2;
431 uinfo->value.integer.min = 0;
432 uinfo->value.integer.max = mask;
433 return 0;
434 }
435
436 static int snd_akm4xxx_stereo_volume_get(struct snd_kcontrol *kcontrol,
437 struct snd_ctl_elem_value *ucontrol)
438 {
439 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
440 int chip = AK_GET_CHIP(kcontrol->private_value);
441 int addr = AK_GET_ADDR(kcontrol->private_value);
442
443 ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
444 ucontrol->value.integer.value[1] = snd_akm4xxx_get_vol(ak, chip, addr+1);
445 return 0;
446 }
447
448 static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol *kcontrol,
449 struct snd_ctl_elem_value *ucontrol)
450 {
451 int addr = AK_GET_ADDR(kcontrol->private_value);
452 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
453 unsigned int val[2];
454 int change;
455
456 val[0] = ucontrol->value.integer.value[0];
457 val[1] = ucontrol->value.integer.value[1];
458 if (val[0] > mask || val[1] > mask)
459 return -EINVAL;
460 change = put_ak_reg(kcontrol, addr, val[0]);
461 change |= put_ak_reg(kcontrol, addr + 1, val[1]);
462 return change;
463 }
464
465 static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol,
466 struct snd_ctl_elem_info *uinfo)
467 {
468 static char *texts[4] = {
469 "44.1kHz", "Off", "48kHz", "32kHz",
470 };
471 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
472 uinfo->count = 1;
473 uinfo->value.enumerated.items = 4;
474 if (uinfo->value.enumerated.item >= 4)
475 uinfo->value.enumerated.item = 3;
476 strcpy(uinfo->value.enumerated.name,
477 texts[uinfo->value.enumerated.item]);
478 return 0;
479 }
480
481 static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol,
482 struct snd_ctl_elem_value *ucontrol)
483 {
484 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
485 int chip = AK_GET_CHIP(kcontrol->private_value);
486 int addr = AK_GET_ADDR(kcontrol->private_value);
487 int shift = AK_GET_SHIFT(kcontrol->private_value);
488 ucontrol->value.enumerated.item[0] =
489 (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3;
490 return 0;
491 }
492
493 static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol,
494 struct snd_ctl_elem_value *ucontrol)
495 {
496 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
497 int chip = AK_GET_CHIP(kcontrol->private_value);
498 int addr = AK_GET_ADDR(kcontrol->private_value);
499 int shift = AK_GET_SHIFT(kcontrol->private_value);
500 unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
501 int change;
502
503 nval = (nval << shift) |
504 (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift));
505 change = snd_akm4xxx_get(ak, chip, addr) != nval;
506 if (change)
507 snd_akm4xxx_write(ak, chip, addr, nval);
508 return change;
509 }
510
511 #define ak4xxx_switch_info snd_ctl_boolean_mono_info
512
513 static int ak4xxx_switch_get(struct snd_kcontrol *kcontrol,
514 struct snd_ctl_elem_value *ucontrol)
515 {
516 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
517 int chip = AK_GET_CHIP(kcontrol->private_value);
518 int addr = AK_GET_ADDR(kcontrol->private_value);
519 int shift = AK_GET_SHIFT(kcontrol->private_value);
520 int invert = AK_GET_INVERT(kcontrol->private_value);
521 /* we observe the (1<<shift) bit only */
522 unsigned char val = snd_akm4xxx_get(ak, chip, addr) & (1<<shift);
523 if (invert)
524 val = ! val;
525 ucontrol->value.integer.value[0] = (val & (1<<shift)) != 0;
526 return 0;
527 }
528
529 static int ak4xxx_switch_put(struct snd_kcontrol *kcontrol,
530 struct snd_ctl_elem_value *ucontrol)
531 {
532 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
533 int chip = AK_GET_CHIP(kcontrol->private_value);
534 int addr = AK_GET_ADDR(kcontrol->private_value);
535 int shift = AK_GET_SHIFT(kcontrol->private_value);
536 int invert = AK_GET_INVERT(kcontrol->private_value);
537 long flag = ucontrol->value.integer.value[0];
538 unsigned char val, oval;
539 int change;
540
541 if (invert)
542 flag = ! flag;
543 oval = snd_akm4xxx_get(ak, chip, addr);
544 if (flag)
545 val = oval | (1<<shift);
546 else
547 val = oval & ~(1<<shift);
548 change = (oval != val);
549 if (change)
550 snd_akm4xxx_write(ak, chip, addr, val);
551 return change;
552 }
553
554 #define AK5365_NUM_INPUTS 5
555
556 static int ak4xxx_capture_num_inputs(struct snd_akm4xxx *ak, int mixer_ch)
557 {
558 int num_names;
559 const char **input_names;
560
561 input_names = ak->adc_info[mixer_ch].input_names;
562 num_names = 0;
563 while (num_names < AK5365_NUM_INPUTS && input_names[num_names])
564 ++num_names;
565 return num_names;
566 }
567
568 static int ak4xxx_capture_source_info(struct snd_kcontrol *kcontrol,
569 struct snd_ctl_elem_info *uinfo)
570 {
571 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
572 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
573 const char **input_names;
574 int num_names, idx;
575
576 num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
577 if (!num_names)
578 return -EINVAL;
579 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
580 uinfo->count = 1;
581 uinfo->value.enumerated.items = num_names;
582 idx = uinfo->value.enumerated.item;
583 if (idx >= num_names)
584 return -EINVAL;
585 input_names = ak->adc_info[mixer_ch].input_names;
586 strncpy(uinfo->value.enumerated.name, input_names[idx],
587 sizeof(uinfo->value.enumerated.name));
588 return 0;
589 }
590
591 static int ak4xxx_capture_source_get(struct snd_kcontrol *kcontrol,
592 struct snd_ctl_elem_value *ucontrol)
593 {
594 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
595 int chip = AK_GET_CHIP(kcontrol->private_value);
596 int addr = AK_GET_ADDR(kcontrol->private_value);
597 int mask = AK_GET_MASK(kcontrol->private_value);
598 unsigned char val;
599
600 val = snd_akm4xxx_get(ak, chip, addr) & mask;
601 ucontrol->value.enumerated.item[0] = val;
602 return 0;
603 }
604
605 static int ak4xxx_capture_source_put(struct snd_kcontrol *kcontrol,
606 struct snd_ctl_elem_value *ucontrol)
607 {
608 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
609 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
610 int chip = AK_GET_CHIP(kcontrol->private_value);
611 int addr = AK_GET_ADDR(kcontrol->private_value);
612 int mask = AK_GET_MASK(kcontrol->private_value);
613 unsigned char oval, val;
614 int num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
615
616 if (ucontrol->value.enumerated.item[0] >= num_names)
617 return -EINVAL;
618
619 oval = snd_akm4xxx_get(ak, chip, addr);
620 val = oval & ~mask;
621 val |= ucontrol->value.enumerated.item[0] & mask;
622 if (val != oval) {
623 snd_akm4xxx_write(ak, chip, addr, val);
624 return 1;
625 }
626 return 0;
627 }
628
629 /*
630 * build AK4xxx controls
631 */
632
633 static int build_dac_controls(struct snd_akm4xxx *ak)
634 {
635 int idx, err, mixer_ch, num_stereo;
636 struct snd_kcontrol_new knew;
637
638 mixer_ch = 0;
639 for (idx = 0; idx < ak->num_dacs; ) {
640 /* mute control for Revolution 7.1 - AK4381 */
641 if (ak->type == SND_AK4381
642 && ak->dac_info[mixer_ch].switch_name) {
643 memset(&knew, 0, sizeof(knew));
644 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
645 knew.count = 1;
646 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
647 knew.name = ak->dac_info[mixer_ch].switch_name;
648 knew.info = ak4xxx_switch_info;
649 knew.get = ak4xxx_switch_get;
650 knew.put = ak4xxx_switch_put;
651 knew.access = 0;
652 /* register 1, bit 0 (SMUTE): 0 = normal operation,
653 1 = mute */
654 knew.private_value =
655 AK_COMPOSE(idx/2, 1, 0, 0) | AK_INVERT;
656 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
657 if (err < 0)
658 return err;
659 }
660 memset(&knew, 0, sizeof(knew));
661 if (! ak->dac_info || ! ak->dac_info[mixer_ch].name) {
662 knew.name = "DAC Volume";
663 knew.index = mixer_ch + ak->idx_offset * 2;
664 num_stereo = 1;
665 } else {
666 knew.name = ak->dac_info[mixer_ch].name;
667 num_stereo = ak->dac_info[mixer_ch].num_channels;
668 }
669 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
670 knew.count = 1;
671 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
672 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
673 if (num_stereo == 2) {
674 knew.info = snd_akm4xxx_stereo_volume_info;
675 knew.get = snd_akm4xxx_stereo_volume_get;
676 knew.put = snd_akm4xxx_stereo_volume_put;
677 } else {
678 knew.info = snd_akm4xxx_volume_info;
679 knew.get = snd_akm4xxx_volume_get;
680 knew.put = snd_akm4xxx_volume_put;
681 }
682 switch (ak->type) {
683 case SND_AK4524:
684 /* register 6 & 7 */
685 knew.private_value =
686 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127) |
687 AK_VOL_CVT;
688 knew.tlv.p = db_scale_vol_datt;
689 break;
690 case SND_AK4528:
691 /* register 4 & 5 */
692 knew.private_value =
693 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127) |
694 AK_VOL_CVT;
695 knew.tlv.p = db_scale_vol_datt;
696 break;
697 case SND_AK4529: {
698 /* registers 2-7 and b,c */
699 int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb;
700 knew.private_value =
701 AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
702 knew.tlv.p = db_scale_8bit;
703 break;
704 }
705 case SND_AK4355:
706 /* register 4-9, chip #0 only */
707 knew.private_value = AK_COMPOSE(0, idx + 4, 0, 255);
708 knew.tlv.p = db_scale_8bit;
709 break;
710 case SND_AK4358: {
711 /* register 4-9 and 11-12, chip #0 only */
712 int addr = idx < 6 ? idx + 4 : idx + 5;
713 knew.private_value =
714 AK_COMPOSE(0, addr, 0, 127) | AK_NEEDSMSB;
715 knew.tlv.p = db_scale_7bit;
716 break;
717 }
718 case SND_AK4381:
719 /* register 3 & 4 */
720 knew.private_value =
721 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255);
722 knew.tlv.p = db_scale_linear;
723 break;
724 case SND_AK4620:
725 /* register 6 & 7 */
726 knew.private_value =
727 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255);
728 knew.tlv.p = db_scale_linear;
729 break;
730 default:
731 return -EINVAL;
732 }
733
734 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
735 if (err < 0)
736 return err;
737
738 idx += num_stereo;
739 mixer_ch++;
740 }
741 return 0;
742 }
743
744 static int build_adc_controls(struct snd_akm4xxx *ak)
745 {
746 int idx, err, mixer_ch, num_stereo, max_steps;
747 struct snd_kcontrol_new knew;
748
749 mixer_ch = 0;
750 if (ak->type == SND_AK4528)
751 return 0; /* no controls */
752 for (idx = 0; idx < ak->num_adcs;) {
753 memset(&knew, 0, sizeof(knew));
754 if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) {
755 knew.name = "ADC Volume";
756 knew.index = mixer_ch + ak->idx_offset * 2;
757 num_stereo = 1;
758 } else {
759 knew.name = ak->adc_info[mixer_ch].name;
760 num_stereo = ak->adc_info[mixer_ch].num_channels;
761 }
762 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
763 knew.count = 1;
764 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
765 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
766 if (num_stereo == 2) {
767 knew.info = snd_akm4xxx_stereo_volume_info;
768 knew.get = snd_akm4xxx_stereo_volume_get;
769 knew.put = snd_akm4xxx_stereo_volume_put;
770 } else {
771 knew.info = snd_akm4xxx_volume_info;
772 knew.get = snd_akm4xxx_volume_get;
773 knew.put = snd_akm4xxx_volume_put;
774 }
775 /* register 4 & 5 */
776 if (ak->type == SND_AK5365)
777 max_steps = 152;
778 else
779 max_steps = 164;
780 knew.private_value =
781 AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) |
782 AK_VOL_CVT | AK_IPGA;
783 knew.tlv.p = db_scale_vol_datt;
784 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
785 if (err < 0)
786 return err;
787
788 if (ak->type == SND_AK5365 && (idx % 2) == 0) {
789 if (! ak->adc_info ||
790 ! ak->adc_info[mixer_ch].switch_name) {
791 knew.name = "Capture Switch";
792 knew.index = mixer_ch + ak->idx_offset * 2;
793 } else
794 knew.name = ak->adc_info[mixer_ch].switch_name;
795 knew.info = ak4xxx_switch_info;
796 knew.get = ak4xxx_switch_get;
797 knew.put = ak4xxx_switch_put;
798 knew.access = 0;
799 /* register 2, bit 0 (SMUTE): 0 = normal operation,
800 1 = mute */
801 knew.private_value =
802 AK_COMPOSE(idx/2, 2, 0, 0) | AK_INVERT;
803 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
804 if (err < 0)
805 return err;
806
807 memset(&knew, 0, sizeof(knew));
808 knew.name = ak->adc_info[mixer_ch].selector_name;
809 if (!knew.name) {
810 knew.name = "Capture Channel";
811 knew.index = mixer_ch + ak->idx_offset * 2;
812 }
813
814 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
815 knew.info = ak4xxx_capture_source_info;
816 knew.get = ak4xxx_capture_source_get;
817 knew.put = ak4xxx_capture_source_put;
818 knew.access = 0;
819 /* input selector control: reg. 1, bits 0-2.
820 * mis-use 'shift' to pass mixer_ch */
821 knew.private_value
822 = AK_COMPOSE(idx/2, 1, mixer_ch, 0x07);
823 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
824 if (err < 0)
825 return err;
826 }
827
828 idx += num_stereo;
829 mixer_ch++;
830 }
831 return 0;
832 }
833
834 static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
835 {
836 int idx, err;
837 struct snd_kcontrol_new knew;
838
839 for (idx = 0; idx < num_emphs; idx++) {
840 memset(&knew, 0, sizeof(knew));
841 knew.name = "Deemphasis";
842 knew.index = idx + ak->idx_offset;
843 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
844 knew.count = 1;
845 knew.info = snd_akm4xxx_deemphasis_info;
846 knew.get = snd_akm4xxx_deemphasis_get;
847 knew.put = snd_akm4xxx_deemphasis_put;
848 switch (ak->type) {
849 case SND_AK4524:
850 case SND_AK4528:
851 case SND_AK4620:
852 /* register 3 */
853 knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
854 break;
855 case SND_AK4529: {
856 int shift = idx == 3 ? 6 : (2 - idx) * 2;
857 /* register 8 with shift */
858 knew.private_value = AK_COMPOSE(0, 8, shift, 0);
859 break;
860 }
861 case SND_AK4355:
862 case SND_AK4358:
863 knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
864 break;
865 case SND_AK4381:
866 knew.private_value = AK_COMPOSE(idx, 1, 1, 0);
867 break;
868 default:
869 return -EINVAL;
870 }
871 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
872 if (err < 0)
873 return err;
874 }
875 return 0;
876 }
877
878 #ifdef CONFIG_PROC_FS
879 static void proc_regs_read(struct snd_info_entry *entry,
880 struct snd_info_buffer *buffer)
881 {
882 struct snd_akm4xxx *ak = entry->private_data;
883 int reg, val, chip;
884 for (chip = 0; chip < ak->num_chips; chip++) {
885 for (reg = 0; reg < ak->total_regs; reg++) {
886 val = snd_akm4xxx_get(ak, chip, reg);
887 snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip,
888 reg, val);
889 }
890 }
891 }
892
893 static int proc_init(struct snd_akm4xxx *ak)
894 {
895 struct snd_info_entry *entry;
896 int err;
897 err = snd_card_proc_new(ak->card, ak->name, &entry);
898 if (err < 0)
899 return err;
900 snd_info_set_text_ops(entry, ak, proc_regs_read);
901 return 0;
902 }
903 #else /* !CONFIG_PROC_FS */
904 static int proc_init(struct snd_akm4xxx *ak) { return 0; }
905 #endif
906
907 int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak)
908 {
909 int err, num_emphs;
910
911 err = build_dac_controls(ak);
912 if (err < 0)
913 return err;
914
915 err = build_adc_controls(ak);
916 if (err < 0)
917 return err;
918 if (ak->type == SND_AK4355 || ak->type == SND_AK4358)
919 num_emphs = 1;
920 else if (ak->type == SND_AK4620)
921 num_emphs = 0;
922 else
923 num_emphs = ak->num_dacs / 2;
924 err = build_deemphasis(ak, num_emphs);
925 if (err < 0)
926 return err;
927 err = proc_init(ak);
928 if (err < 0)
929 return err;
930
931 return 0;
932 }
933 EXPORT_SYMBOL(snd_akm4xxx_build_controls);
934
935 static int __init alsa_akm4xxx_module_init(void)
936 {
937 return 0;
938 }
939
940 static void __exit alsa_akm4xxx_module_exit(void)
941 {
942 }
943
944 module_init(alsa_akm4xxx_module_init)
945 module_exit(alsa_akm4xxx_module_exit)