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 */
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 */
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
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
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
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
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
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
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
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
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
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
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
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
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 */
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
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
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
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
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 */
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 */
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 */
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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.