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