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