xref: /openbmc/linux/sound/pci/ice1712/maya44.c (revision f16a4e96)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *   ALSA driver for ICEnsemble VT1724 (Envy24HT)
4  *
5  *   Lowlevel functions for ESI Maya44 cards
6  *
7  *	Copyright (c) 2009 Takashi Iwai <tiwai@suse.de>
8  *	Based on the patches by Rainer Zimmermann <mail@lightshed.de>
9  */
10 
11 #include <linux/init.h>
12 #include <linux/slab.h>
13 #include <sound/core.h>
14 #include <sound/control.h>
15 #include <sound/pcm.h>
16 #include <sound/tlv.h>
17 
18 #include "ice1712.h"
19 #include "envy24ht.h"
20 #include "maya44.h"
21 
22 /* WM8776 register indexes */
23 #define WM8776_REG_HEADPHONE_L		0x00
24 #define WM8776_REG_HEADPHONE_R		0x01
25 #define WM8776_REG_HEADPHONE_MASTER	0x02
26 #define WM8776_REG_DAC_ATTEN_L		0x03
27 #define WM8776_REG_DAC_ATTEN_R		0x04
28 #define WM8776_REG_DAC_ATTEN_MASTER	0x05
29 #define WM8776_REG_DAC_PHASE		0x06
30 #define WM8776_REG_DAC_CONTROL		0x07
31 #define WM8776_REG_DAC_MUTE		0x08
32 #define WM8776_REG_DAC_DEEMPH		0x09
33 #define WM8776_REG_DAC_IF_CONTROL	0x0a
34 #define WM8776_REG_ADC_IF_CONTROL	0x0b
35 #define WM8776_REG_MASTER_MODE_CONTROL	0x0c
36 #define WM8776_REG_POWERDOWN		0x0d
37 #define WM8776_REG_ADC_ATTEN_L		0x0e
38 #define WM8776_REG_ADC_ATTEN_R		0x0f
39 #define WM8776_REG_ADC_ALC1		0x10
40 #define WM8776_REG_ADC_ALC2		0x11
41 #define WM8776_REG_ADC_ALC3		0x12
42 #define WM8776_REG_ADC_NOISE_GATE	0x13
43 #define WM8776_REG_ADC_LIMITER		0x14
44 #define WM8776_REG_ADC_MUX		0x15
45 #define WM8776_REG_OUTPUT_MUX		0x16
46 #define WM8776_REG_RESET		0x17
47 
48 #define WM8776_NUM_REGS			0x18
49 
50 /* clock ratio identifiers for snd_wm8776_set_rate() */
51 #define WM8776_CLOCK_RATIO_128FS	0
52 #define WM8776_CLOCK_RATIO_192FS	1
53 #define WM8776_CLOCK_RATIO_256FS	2
54 #define WM8776_CLOCK_RATIO_384FS	3
55 #define WM8776_CLOCK_RATIO_512FS	4
56 #define WM8776_CLOCK_RATIO_768FS	5
57 
58 enum { WM_VOL_HP, WM_VOL_DAC, WM_VOL_ADC, WM_NUM_VOLS };
59 enum { WM_SW_DAC, WM_SW_BYPASS, WM_NUM_SWITCHES };
60 
61 struct snd_wm8776 {
62 	unsigned char addr;
63 	unsigned short regs[WM8776_NUM_REGS];
64 	unsigned char volumes[WM_NUM_VOLS][2];
65 	unsigned int switch_bits;
66 };
67 
68 struct snd_maya44 {
69 	struct snd_ice1712 *ice;
70 	struct snd_wm8776 wm[2];
71 	struct mutex mutex;
72 };
73 
74 
75 /* write the given register and save the data to the cache */
wm8776_write(struct snd_ice1712 * ice,struct snd_wm8776 * wm,unsigned char reg,unsigned short val)76 static void wm8776_write(struct snd_ice1712 *ice, struct snd_wm8776 *wm,
77 			 unsigned char reg, unsigned short val)
78 {
79 	/*
80 	 * WM8776 registers are up to 9 bits wide, bit 8 is placed in the LSB
81 	 * of the address field
82 	 */
83 	snd_vt1724_write_i2c(ice, wm->addr,
84 			     (reg << 1) | ((val >> 8) & 1),
85 			     val & 0xff);
86 	wm->regs[reg] = val;
87 }
88 
89 /*
90  * update the given register with and/or mask and save the data to the cache
91  */
wm8776_write_bits(struct snd_ice1712 * ice,struct snd_wm8776 * wm,unsigned char reg,unsigned short mask,unsigned short val)92 static int wm8776_write_bits(struct snd_ice1712 *ice, struct snd_wm8776 *wm,
93 			     unsigned char reg,
94 			     unsigned short mask, unsigned short val)
95 {
96 	val |= wm->regs[reg] & ~mask;
97 	if (val != wm->regs[reg]) {
98 		wm8776_write(ice, wm, reg, val);
99 		return 1;
100 	}
101 	return 0;
102 }
103 
104 
105 /*
106  * WM8776 volume controls
107  */
108 
109 struct maya_vol_info {
110 	unsigned int maxval;		/* volume range: 0..maxval */
111 	unsigned char regs[2];		/* left and right registers */
112 	unsigned short mask;		/* value mask */
113 	unsigned short offset;		/* zero-value offset */
114 	unsigned short mute;		/* mute bit */
115 	unsigned short update;		/* update bits */
116 	unsigned char mux_bits[2];	/* extra bits for ADC mute */
117 };
118 
119 static const struct maya_vol_info vol_info[WM_NUM_VOLS] = {
120 	[WM_VOL_HP] = {
121 		.maxval = 80,
122 		.regs = { WM8776_REG_HEADPHONE_L, WM8776_REG_HEADPHONE_R },
123 		.mask = 0x7f,
124 		.offset = 0x30,
125 		.mute = 0x00,
126 		.update = 0x180,	/* update and zero-cross enable */
127 	},
128 	[WM_VOL_DAC] = {
129 		.maxval = 255,
130 		.regs = { WM8776_REG_DAC_ATTEN_L, WM8776_REG_DAC_ATTEN_R },
131 		.mask = 0xff,
132 		.offset = 0x01,
133 		.mute = 0x00,
134 		.update = 0x100,	/* zero-cross enable */
135 	},
136 	[WM_VOL_ADC] = {
137 		.maxval = 91,
138 		.regs = { WM8776_REG_ADC_ATTEN_L, WM8776_REG_ADC_ATTEN_R },
139 		.mask = 0xff,
140 		.offset = 0xa5,
141 		.mute = 0xa5,
142 		.update = 0x100,	/* update */
143 		.mux_bits = { 0x80, 0x40 }, /* ADCMUX bits */
144 	},
145 };
146 
147 /*
148  * dB tables
149  */
150 /* headphone output: mute, -73..+6db (1db step) */
151 static const DECLARE_TLV_DB_SCALE(db_scale_hp, -7400, 100, 1);
152 /* DAC output: mute, -127..0db (0.5db step) */
153 static const DECLARE_TLV_DB_SCALE(db_scale_dac, -12750, 50, 1);
154 /* ADC gain: mute, -21..+24db (0.5db step) */
155 static const DECLARE_TLV_DB_SCALE(db_scale_adc, -2100, 50, 1);
156 
maya_vol_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)157 static int maya_vol_info(struct snd_kcontrol *kcontrol,
158 			 struct snd_ctl_elem_info *uinfo)
159 {
160 	unsigned int idx = kcontrol->private_value;
161 	const struct maya_vol_info *vol = &vol_info[idx];
162 
163 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
164 	uinfo->count = 2;
165 	uinfo->value.integer.min = 0;
166 	uinfo->value.integer.max = vol->maxval;
167 	return 0;
168 }
169 
maya_vol_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)170 static int maya_vol_get(struct snd_kcontrol *kcontrol,
171 			struct snd_ctl_elem_value *ucontrol)
172 {
173 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
174 	struct snd_wm8776 *wm =
175 		&chip->wm[snd_ctl_get_ioff(kcontrol, &ucontrol->id)];
176 	unsigned int idx = kcontrol->private_value;
177 
178 	mutex_lock(&chip->mutex);
179 	ucontrol->value.integer.value[0] = wm->volumes[idx][0];
180 	ucontrol->value.integer.value[1] = wm->volumes[idx][1];
181 	mutex_unlock(&chip->mutex);
182 	return 0;
183 }
184 
maya_vol_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)185 static int maya_vol_put(struct snd_kcontrol *kcontrol,
186 			struct snd_ctl_elem_value *ucontrol)
187 {
188 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
189 	struct snd_wm8776 *wm =
190 		&chip->wm[snd_ctl_get_ioff(kcontrol, &ucontrol->id)];
191 	unsigned int idx = kcontrol->private_value;
192 	const struct maya_vol_info *vol = &vol_info[idx];
193 	unsigned int val, data;
194 	int ch, changed = 0;
195 
196 	mutex_lock(&chip->mutex);
197 	for (ch = 0; ch < 2; ch++) {
198 		val = ucontrol->value.integer.value[ch];
199 		if (val > vol->maxval)
200 			val = vol->maxval;
201 		if (val == wm->volumes[idx][ch])
202 			continue;
203 		if (!val)
204 			data = vol->mute;
205 		else
206 			data = (val - 1) + vol->offset;
207 		data |= vol->update;
208 		changed |= wm8776_write_bits(chip->ice, wm, vol->regs[ch],
209 					     vol->mask | vol->update, data);
210 		if (vol->mux_bits[ch])
211 			wm8776_write_bits(chip->ice, wm, WM8776_REG_ADC_MUX,
212 					  vol->mux_bits[ch],
213 					  val ? 0 : vol->mux_bits[ch]);
214 		wm->volumes[idx][ch] = val;
215 	}
216 	mutex_unlock(&chip->mutex);
217 	return changed;
218 }
219 
220 /*
221  * WM8776 switch controls
222  */
223 
224 #define COMPOSE_SW_VAL(idx, reg, mask)	((idx) | ((reg) << 8) | ((mask) << 16))
225 #define GET_SW_VAL_IDX(val)	((val) & 0xff)
226 #define GET_SW_VAL_REG(val)	(((val) >> 8) & 0xff)
227 #define GET_SW_VAL_MASK(val)	(((val) >> 16) & 0xff)
228 
229 #define maya_sw_info	snd_ctl_boolean_mono_info
230 
maya_sw_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)231 static int maya_sw_get(struct snd_kcontrol *kcontrol,
232 		       struct snd_ctl_elem_value *ucontrol)
233 {
234 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
235 	struct snd_wm8776 *wm =
236 		&chip->wm[snd_ctl_get_ioff(kcontrol, &ucontrol->id)];
237 	unsigned int idx = GET_SW_VAL_IDX(kcontrol->private_value);
238 
239 	ucontrol->value.integer.value[0] = (wm->switch_bits >> idx) & 1;
240 	return 0;
241 }
242 
maya_sw_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)243 static int maya_sw_put(struct snd_kcontrol *kcontrol,
244 		       struct snd_ctl_elem_value *ucontrol)
245 {
246 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
247 	struct snd_wm8776 *wm =
248 		&chip->wm[snd_ctl_get_ioff(kcontrol, &ucontrol->id)];
249 	unsigned int idx = GET_SW_VAL_IDX(kcontrol->private_value);
250 	unsigned int mask, val;
251 	int changed;
252 
253 	mutex_lock(&chip->mutex);
254 	mask = 1 << idx;
255 	wm->switch_bits &= ~mask;
256 	val = ucontrol->value.integer.value[0];
257 	if (val)
258 		wm->switch_bits |= mask;
259 	mask = GET_SW_VAL_MASK(kcontrol->private_value);
260 	changed = wm8776_write_bits(chip->ice, wm,
261 				    GET_SW_VAL_REG(kcontrol->private_value),
262 				    mask, val ? mask : 0);
263 	mutex_unlock(&chip->mutex);
264 	return changed;
265 }
266 
267 /*
268  * GPIO pins (known ones for maya44)
269  */
270 #define GPIO_PHANTOM_OFF	2
271 #define GPIO_MIC_RELAY		4
272 #define GPIO_SPDIF_IN_INV	5
273 #define GPIO_MUST_BE_0		7
274 
275 /*
276  * GPIO switch controls
277  */
278 
279 #define COMPOSE_GPIO_VAL(shift, inv)	((shift) | ((inv) << 8))
280 #define GET_GPIO_VAL_SHIFT(val)		((val) & 0xff)
281 #define GET_GPIO_VAL_INV(val)		(((val) >> 8) & 1)
282 
maya_set_gpio_bits(struct snd_ice1712 * ice,unsigned int mask,unsigned int bits)283 static int maya_set_gpio_bits(struct snd_ice1712 *ice, unsigned int mask,
284 			      unsigned int bits)
285 {
286 	unsigned int data;
287 	data = snd_ice1712_gpio_read(ice);
288 	if ((data & mask) == bits)
289 		return 0;
290 	snd_ice1712_gpio_write(ice, (data & ~mask) | bits);
291 	return 1;
292 }
293 
294 #define maya_gpio_sw_info	snd_ctl_boolean_mono_info
295 
maya_gpio_sw_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)296 static int maya_gpio_sw_get(struct snd_kcontrol *kcontrol,
297 			    struct snd_ctl_elem_value *ucontrol)
298 {
299 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
300 	unsigned int shift = GET_GPIO_VAL_SHIFT(kcontrol->private_value);
301 	unsigned int val;
302 
303 	val = (snd_ice1712_gpio_read(chip->ice) >> shift) & 1;
304 	if (GET_GPIO_VAL_INV(kcontrol->private_value))
305 		val = !val;
306 	ucontrol->value.integer.value[0] = val;
307 	return 0;
308 }
309 
maya_gpio_sw_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)310 static int maya_gpio_sw_put(struct snd_kcontrol *kcontrol,
311 			    struct snd_ctl_elem_value *ucontrol)
312 {
313 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
314 	unsigned int shift = GET_GPIO_VAL_SHIFT(kcontrol->private_value);
315 	unsigned int val, mask;
316 	int changed;
317 
318 	mutex_lock(&chip->mutex);
319 	mask = 1 << shift;
320 	val = ucontrol->value.integer.value[0];
321 	if (GET_GPIO_VAL_INV(kcontrol->private_value))
322 		val = !val;
323 	val = val ? mask : 0;
324 	changed = maya_set_gpio_bits(chip->ice, mask, val);
325 	mutex_unlock(&chip->mutex);
326 	return changed;
327 }
328 
329 /*
330  * capture source selection
331  */
332 
333 /* known working input slots (0-4) */
334 #define MAYA_LINE_IN	1	/* in-2 */
335 #define MAYA_MIC_IN	3	/* in-4 */
336 
wm8776_select_input(struct snd_maya44 * chip,int idx,int line)337 static void wm8776_select_input(struct snd_maya44 *chip, int idx, int line)
338 {
339 	wm8776_write_bits(chip->ice, &chip->wm[idx], WM8776_REG_ADC_MUX,
340 			  0x1f, 1 << line);
341 }
342 
maya_rec_src_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)343 static int maya_rec_src_info(struct snd_kcontrol *kcontrol,
344 			     struct snd_ctl_elem_info *uinfo)
345 {
346 	static const char * const texts[] = { "Line", "Mic" };
347 
348 	return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
349 }
350 
maya_rec_src_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)351 static int maya_rec_src_get(struct snd_kcontrol *kcontrol,
352 			    struct snd_ctl_elem_value *ucontrol)
353 {
354 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
355 	int sel;
356 
357 	if (snd_ice1712_gpio_read(chip->ice) & (1 << GPIO_MIC_RELAY))
358 		sel = 1;
359 	else
360 		sel = 0;
361 	ucontrol->value.enumerated.item[0] = sel;
362 	return 0;
363 }
364 
maya_rec_src_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)365 static int maya_rec_src_put(struct snd_kcontrol *kcontrol,
366 			    struct snd_ctl_elem_value *ucontrol)
367 {
368 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
369 	int sel = ucontrol->value.enumerated.item[0];
370 	int changed;
371 
372 	mutex_lock(&chip->mutex);
373 	changed = maya_set_gpio_bits(chip->ice, 1 << GPIO_MIC_RELAY,
374 				     sel ? (1 << GPIO_MIC_RELAY) : 0);
375 	wm8776_select_input(chip, 0, sel ? MAYA_MIC_IN : MAYA_LINE_IN);
376 	mutex_unlock(&chip->mutex);
377 	return changed;
378 }
379 
380 /*
381  * Maya44 routing switch settings have different meanings than the standard
382  * ice1724 switches as defined in snd_vt1724_pro_route_info (ice1724.c).
383  */
maya_pb_route_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)384 static int maya_pb_route_info(struct snd_kcontrol *kcontrol,
385 			      struct snd_ctl_elem_info *uinfo)
386 {
387 	static const char * const texts[] = {
388 		"PCM Out", /* 0 */
389 		"Input 1", "Input 2", "Input 3", "Input 4"
390 	};
391 
392 	return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
393 }
394 
maya_pb_route_shift(int idx)395 static int maya_pb_route_shift(int idx)
396 {
397 	static const unsigned char shift[10] =
398 		{ 8, 20, 0, 3, 11, 23, 14, 26, 17, 29 };
399 	return shift[idx % 10];
400 }
401 
maya_pb_route_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)402 static int maya_pb_route_get(struct snd_kcontrol *kcontrol,
403 			     struct snd_ctl_elem_value *ucontrol)
404 {
405 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
406 	int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
407 	ucontrol->value.enumerated.item[0] =
408 		snd_ice1724_get_route_val(chip->ice, maya_pb_route_shift(idx));
409 	return 0;
410 }
411 
maya_pb_route_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)412 static int maya_pb_route_put(struct snd_kcontrol *kcontrol,
413 			     struct snd_ctl_elem_value *ucontrol)
414 {
415 	struct snd_maya44 *chip = snd_kcontrol_chip(kcontrol);
416 	int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
417 	return snd_ice1724_put_route_val(chip->ice,
418 					 ucontrol->value.enumerated.item[0],
419 					 maya_pb_route_shift(idx));
420 }
421 
422 
423 /*
424  * controls to be added
425  */
426 
427 static const struct snd_kcontrol_new maya_controls[] = {
428 	{
429 		.name = "Crossmix Playback Volume",
430 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
431 		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
432 			SNDRV_CTL_ELEM_ACCESS_TLV_READ,
433 		.info = maya_vol_info,
434 		.get = maya_vol_get,
435 		.put = maya_vol_put,
436 		.tlv = { .p = db_scale_hp },
437 		.private_value = WM_VOL_HP,
438 		.count = 2,
439 	},
440 	{
441 		.name = "PCM Playback Volume",
442 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
443 		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
444 			SNDRV_CTL_ELEM_ACCESS_TLV_READ,
445 		.info = maya_vol_info,
446 		.get = maya_vol_get,
447 		.put = maya_vol_put,
448 		.tlv = { .p = db_scale_dac },
449 		.private_value = WM_VOL_DAC,
450 		.count = 2,
451 	},
452 	{
453 		.name = "Line Capture Volume",
454 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
455 		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
456 			SNDRV_CTL_ELEM_ACCESS_TLV_READ,
457 		.info = maya_vol_info,
458 		.get = maya_vol_get,
459 		.put = maya_vol_put,
460 		.tlv = { .p = db_scale_adc },
461 		.private_value = WM_VOL_ADC,
462 		.count = 2,
463 	},
464 	{
465 		.name = "PCM Playback Switch",
466 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
467 		.info = maya_sw_info,
468 		.get = maya_sw_get,
469 		.put = maya_sw_put,
470 		.private_value = COMPOSE_SW_VAL(WM_SW_DAC,
471 						WM8776_REG_OUTPUT_MUX, 0x01),
472 		.count = 2,
473 	},
474 	{
475 		.name = "Bypass Playback Switch",
476 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
477 		.info = maya_sw_info,
478 		.get = maya_sw_get,
479 		.put = maya_sw_put,
480 		.private_value = COMPOSE_SW_VAL(WM_SW_BYPASS,
481 						WM8776_REG_OUTPUT_MUX, 0x04),
482 		.count = 2,
483 	},
484 	{
485 		.name = "Capture Source",
486 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
487 		.info = maya_rec_src_info,
488 		.get = maya_rec_src_get,
489 		.put = maya_rec_src_put,
490 	},
491 	{
492 		.name = "Mic Phantom Power Switch",
493 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
494 		.info = maya_gpio_sw_info,
495 		.get = maya_gpio_sw_get,
496 		.put = maya_gpio_sw_put,
497 		.private_value = COMPOSE_GPIO_VAL(GPIO_PHANTOM_OFF, 1),
498 	},
499 	{
500 		.name = "SPDIF Capture Switch",
501 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
502 		.info = maya_gpio_sw_info,
503 		.get = maya_gpio_sw_get,
504 		.put = maya_gpio_sw_put,
505 		.private_value = COMPOSE_GPIO_VAL(GPIO_SPDIF_IN_INV, 1),
506 	},
507 	{
508 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
509 		.name = "H/W Playback Route",
510 		.info = maya_pb_route_info,
511 		.get = maya_pb_route_get,
512 		.put = maya_pb_route_put,
513 		.count = 4,  /* FIXME: do controls 5-9 have any meaning? */
514 	},
515 };
516 
maya44_add_controls(struct snd_ice1712 * ice)517 static int maya44_add_controls(struct snd_ice1712 *ice)
518 {
519 	int err, i;
520 
521 	for (i = 0; i < ARRAY_SIZE(maya_controls); i++) {
522 		err = snd_ctl_add(ice->card, snd_ctl_new1(&maya_controls[i],
523 							  ice->spec));
524 		if (err < 0)
525 			return err;
526 	}
527 	return 0;
528 }
529 
530 
531 /*
532  * initialize a wm8776 chip
533  */
wm8776_init(struct snd_ice1712 * ice,struct snd_wm8776 * wm,unsigned int addr)534 static void wm8776_init(struct snd_ice1712 *ice,
535 			struct snd_wm8776 *wm, unsigned int addr)
536 {
537 	static const unsigned short inits_wm8776[] = {
538 		0x02, 0x100, /* R2: headphone L+R muted + update */
539 		0x05, 0x100, /* R5: DAC output L+R muted + update */
540 		0x06, 0x000, /* R6: DAC output phase normal */
541 		0x07, 0x091, /* R7: DAC enable zero cross detection,
542 				normal output */
543 		0x08, 0x000, /* R8: DAC soft mute off */
544 		0x09, 0x000, /* R9: no deemph, DAC zero detect disabled */
545 		0x0a, 0x022, /* R10: DAC I2C mode, std polarities, 24bit */
546 		0x0b, 0x022, /* R11: ADC I2C mode, std polarities, 24bit,
547 				highpass filter enabled */
548 		0x0c, 0x042, /* R12: ADC+DAC slave, ADC+DAC 44,1kHz */
549 		0x0d, 0x000, /* R13: all power up */
550 		0x0e, 0x100, /* R14: ADC left muted,
551 				enable zero cross detection */
552 		0x0f, 0x100, /* R15: ADC right muted,
553 				enable zero cross detection */
554 			     /* R16: ALC...*/
555 		0x11, 0x000, /* R17: disable ALC */
556 			     /* R18: ALC...*/
557 			     /* R19: noise gate...*/
558 		0x15, 0x000, /* R21: ADC input mux init, mute all inputs */
559 		0x16, 0x001, /* R22: output mux, select DAC */
560 		0xff, 0xff
561 	};
562 
563 	const unsigned short *ptr;
564 	unsigned char reg;
565 	unsigned short data;
566 
567 	wm->addr = addr;
568 	/* enable DAC output; mute bypass, aux & all inputs */
569 	wm->switch_bits = (1 << WM_SW_DAC);
570 
571 	ptr = inits_wm8776;
572 	while (*ptr != 0xff) {
573 		reg = *ptr++;
574 		data = *ptr++;
575 		wm8776_write(ice, wm, reg, data);
576 	}
577 }
578 
579 
580 /*
581  * change the rate on the WM8776 codecs.
582  * this assumes that the VT17xx's rate is changed by the calling function.
583  * NOTE: even though the WM8776's are running in slave mode and rate
584  * selection is automatic, we need to call snd_wm8776_set_rate() here
585  * to make sure some flags are set correctly.
586  */
set_rate(struct snd_ice1712 * ice,unsigned int rate)587 static void set_rate(struct snd_ice1712 *ice, unsigned int rate)
588 {
589 	struct snd_maya44 *chip = ice->spec;
590 	unsigned int ratio, adc_ratio, val;
591 	int i;
592 
593 	switch (rate) {
594 	case 192000:
595 		ratio = WM8776_CLOCK_RATIO_128FS;
596 		break;
597 	case 176400:
598 		ratio = WM8776_CLOCK_RATIO_128FS;
599 		break;
600 	case 96000:
601 		ratio = WM8776_CLOCK_RATIO_256FS;
602 		break;
603 	case 88200:
604 		ratio = WM8776_CLOCK_RATIO_384FS;
605 		break;
606 	case 48000:
607 		ratio = WM8776_CLOCK_RATIO_512FS;
608 		break;
609 	case 44100:
610 		ratio = WM8776_CLOCK_RATIO_512FS;
611 		break;
612 	case 32000:
613 		ratio = WM8776_CLOCK_RATIO_768FS;
614 		break;
615 	case 0:
616 		/* no hint - S/PDIF input is master, simply return */
617 		return;
618 	default:
619 		snd_BUG();
620 		return;
621 	}
622 
623 	/*
624 	 * this currently sets the same rate for ADC and DAC, but limits
625 	 * ADC rate to 256X (96kHz). For 256X mode (96kHz), this sets ADC
626 	 * oversampling to 64x, as recommended by WM8776 datasheet.
627 	 * Setting the rate is not really necessary in slave mode.
628 	 */
629 	adc_ratio = ratio;
630 	if (adc_ratio < WM8776_CLOCK_RATIO_256FS)
631 		adc_ratio = WM8776_CLOCK_RATIO_256FS;
632 
633 	val = adc_ratio;
634 	if (adc_ratio == WM8776_CLOCK_RATIO_256FS)
635 		val |= 8;
636 	val |= ratio << 4;
637 
638 	mutex_lock(&chip->mutex);
639 	for (i = 0; i < 2; i++)
640 		wm8776_write_bits(ice, &chip->wm[i],
641 				  WM8776_REG_MASTER_MODE_CONTROL,
642 				  0x180, val);
643 	mutex_unlock(&chip->mutex);
644 }
645 
646 /*
647  * supported sample rates (to override the default one)
648  */
649 
650 static const unsigned int rates[] = {
651 	32000, 44100, 48000, 64000, 88200, 96000, 176400, 192000
652 };
653 
654 /* playback rates: 32..192 kHz */
655 static const struct snd_pcm_hw_constraint_list dac_rates = {
656 	.count = ARRAY_SIZE(rates),
657 	.list = rates,
658 	.mask = 0
659 };
660 
661 
662 /*
663  * chip addresses on I2C bus
664  */
665 static const unsigned char wm8776_addr[2] = {
666 	0x34, 0x36, /* codec 0 & 1 */
667 };
668 
669 /*
670  * initialize the chip
671  */
maya44_init(struct snd_ice1712 * ice)672 static int maya44_init(struct snd_ice1712 *ice)
673 {
674 	int i;
675 	struct snd_maya44 *chip;
676 
677 	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
678 	if (!chip)
679 		return -ENOMEM;
680 	mutex_init(&chip->mutex);
681 	chip->ice = ice;
682 	ice->spec = chip;
683 
684 	/* initialise codecs */
685 	ice->num_total_dacs = 4;
686 	ice->num_total_adcs = 4;
687 	ice->akm_codecs = 0;
688 
689 	for (i = 0; i < 2; i++) {
690 		wm8776_init(ice, &chip->wm[i], wm8776_addr[i]);
691 		wm8776_select_input(chip, i, MAYA_LINE_IN);
692 	}
693 
694 	/* set card specific rates */
695 	ice->hw_rates = &dac_rates;
696 
697 	/* register change rate notifier */
698 	ice->gpio.set_pro_rate = set_rate;
699 
700 	/* RDMA1 (2nd input channel) is used for ADC by default */
701 	ice->force_rdma1 = 1;
702 
703 	/* have an own routing control */
704 	ice->own_routing = 1;
705 
706 	return 0;
707 }
708 
709 
710 /*
711  * Maya44 boards don't provide the EEPROM data except for the vendor IDs.
712  * hence the driver needs to sets up it properly.
713  */
714 
715 static const unsigned char maya44_eeprom[] = {
716 	[ICE_EEP2_SYSCONF]     = 0x45,
717 		/* clock xin1=49.152MHz, mpu401, 2 stereo ADCs+DACs */
718 	[ICE_EEP2_ACLINK]      = 0x80,
719 		/* I2S */
720 	[ICE_EEP2_I2S]         = 0xf8,
721 		/* vol, 96k, 24bit, 192k */
722 	[ICE_EEP2_SPDIF]       = 0xc3,
723 		/* enable spdif out, spdif out supp, spdif-in, ext spdif out */
724 	[ICE_EEP2_GPIO_DIR]    = 0xff,
725 	[ICE_EEP2_GPIO_DIR1]   = 0xff,
726 	[ICE_EEP2_GPIO_DIR2]   = 0xff,
727 	[ICE_EEP2_GPIO_MASK]   = 0/*0x9f*/,
728 	[ICE_EEP2_GPIO_MASK1]  = 0/*0xff*/,
729 	[ICE_EEP2_GPIO_MASK2]  = 0/*0x7f*/,
730 	[ICE_EEP2_GPIO_STATE]  = (1 << GPIO_PHANTOM_OFF) |
731 			(1 << GPIO_SPDIF_IN_INV),
732 	[ICE_EEP2_GPIO_STATE1] = 0x00,
733 	[ICE_EEP2_GPIO_STATE2] = 0x00,
734 };
735 
736 /* entry point */
737 struct snd_ice1712_card_info snd_vt1724_maya44_cards[] = {
738 	{
739 		.subvendor = VT1724_SUBDEVICE_MAYA44,
740 		.name = "ESI Maya44",
741 		.model = "maya44",
742 		.chip_init = maya44_init,
743 		.build_controls = maya44_add_controls,
744 		.eeprom_size = sizeof(maya44_eeprom),
745 		.eeprom_data = maya44_eeprom,
746 	},
747 	{ } /* terminator */
748 };
749