1 /* 2 * ALSA driver for AK4524 / AK4528 / AK4529 / AK4355 / AK4358 / AK4381 3 * AD and DA converters 4 * 5 * Copyright (c) 2000-2004 Jaroslav Kysela <perex@suse.cz>, 6 * Takashi Iwai <tiwai@suse.de> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24 #include <sound/driver.h> 25 #include <asm/io.h> 26 #include <linux/delay.h> 27 #include <linux/interrupt.h> 28 #include <linux/init.h> 29 #include <sound/core.h> 30 #include <sound/control.h> 31 #include <sound/ak4xxx-adda.h> 32 33 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Takashi Iwai <tiwai@suse.de>"); 34 MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters"); 35 MODULE_LICENSE("GPL"); 36 37 void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg, 38 unsigned char val) 39 { 40 ak->ops.lock(ak, chip); 41 ak->ops.write(ak, chip, reg, val); 42 43 /* save the data */ 44 if (ak->type == SND_AK4524 || ak->type == SND_AK4528) { 45 if ((reg != 0x04 && reg != 0x05) || (val & 0x80) == 0) 46 snd_akm4xxx_set(ak, chip, reg, val); 47 else 48 snd_akm4xxx_set_ipga(ak, chip, reg, val); 49 } else { 50 /* AK4529, or else */ 51 snd_akm4xxx_set(ak, chip, reg, val); 52 } 53 ak->ops.unlock(ak, chip); 54 } 55 56 EXPORT_SYMBOL(snd_akm4xxx_write); 57 58 /* reset procedure for AK4524 and AK4528 */ 59 static void ak4524_reset(struct snd_akm4xxx *ak, int state) 60 { 61 unsigned int chip; 62 unsigned char reg, maxreg; 63 64 if (ak->type == SND_AK4528) 65 maxreg = 0x06; 66 else 67 maxreg = 0x08; 68 for (chip = 0; chip < ak->num_dacs/2; chip++) { 69 snd_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03); 70 if (state) 71 continue; 72 /* DAC volumes */ 73 for (reg = 0x04; reg < maxreg; reg++) 74 snd_akm4xxx_write(ak, chip, reg, 75 snd_akm4xxx_get(ak, chip, reg)); 76 if (ak->type == SND_AK4528) 77 continue; 78 /* IPGA */ 79 for (reg = 0x04; reg < 0x06; reg++) 80 snd_akm4xxx_write(ak, chip, reg, 81 snd_akm4xxx_get_ipga(ak, chip, reg)); 82 } 83 } 84 85 /* reset procedure for AK4355 and AK4358 */ 86 static void ak4355_reset(struct snd_akm4xxx *ak, int state) 87 { 88 unsigned char reg; 89 90 if (state) { 91 snd_akm4xxx_write(ak, 0, 0x01, 0x02); /* reset and soft-mute */ 92 return; 93 } 94 for (reg = 0x00; reg < 0x0b; reg++) 95 if (reg != 0x01) 96 snd_akm4xxx_write(ak, 0, reg, 97 snd_akm4xxx_get(ak, 0, reg)); 98 snd_akm4xxx_write(ak, 0, 0x01, 0x01); /* un-reset, unmute */ 99 } 100 101 /* reset procedure for AK4381 */ 102 static void ak4381_reset(struct snd_akm4xxx *ak, int state) 103 { 104 unsigned int chip; 105 unsigned char reg; 106 107 for (chip = 0; chip < ak->num_dacs/2; chip++) { 108 snd_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f); 109 if (state) 110 continue; 111 for (reg = 0x01; reg < 0x05; reg++) 112 snd_akm4xxx_write(ak, chip, reg, 113 snd_akm4xxx_get(ak, chip, reg)); 114 } 115 } 116 117 /* 118 * reset the AKM codecs 119 * @state: 1 = reset codec, 0 = restore the registers 120 * 121 * assert the reset operation and restores the register values to the chips. 122 */ 123 void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state) 124 { 125 switch (ak->type) { 126 case SND_AK4524: 127 case SND_AK4528: 128 ak4524_reset(ak, state); 129 break; 130 case SND_AK4529: 131 /* FIXME: needed for ak4529? */ 132 break; 133 case SND_AK4355: 134 case SND_AK4358: 135 ak4355_reset(ak, state); 136 break; 137 case SND_AK4381: 138 ak4381_reset(ak, state); 139 break; 140 } 141 } 142 143 EXPORT_SYMBOL(snd_akm4xxx_reset); 144 145 /* 146 * initialize all the ak4xxx chips 147 */ 148 void snd_akm4xxx_init(struct snd_akm4xxx *ak) 149 { 150 static unsigned char inits_ak4524[] = { 151 0x00, 0x07, /* 0: all power up */ 152 0x01, 0x00, /* 1: ADC/DAC reset */ 153 0x02, 0x60, /* 2: 24bit I2S */ 154 0x03, 0x19, /* 3: deemphasis off */ 155 0x01, 0x03, /* 1: ADC/DAC enable */ 156 0x04, 0x00, /* 4: ADC left muted */ 157 0x05, 0x00, /* 5: ADC right muted */ 158 0x04, 0x80, /* 4: ADC IPGA gain 0dB */ 159 0x05, 0x80, /* 5: ADC IPGA gain 0dB */ 160 0x06, 0x00, /* 6: DAC left muted */ 161 0x07, 0x00, /* 7: DAC right muted */ 162 0xff, 0xff 163 }; 164 static unsigned char inits_ak4528[] = { 165 0x00, 0x07, /* 0: all power up */ 166 0x01, 0x00, /* 1: ADC/DAC reset */ 167 0x02, 0x60, /* 2: 24bit I2S */ 168 0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */ 169 0x01, 0x03, /* 1: ADC/DAC enable */ 170 0x04, 0x00, /* 4: ADC left muted */ 171 0x05, 0x00, /* 5: ADC right muted */ 172 0xff, 0xff 173 }; 174 static unsigned char inits_ak4529[] = { 175 0x09, 0x01, /* 9: ATS=0, RSTN=1 */ 176 0x0a, 0x3f, /* A: all power up, no zero/overflow detection */ 177 0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */ 178 0x01, 0x00, /* 1: ACKS=0, ADC, loop off */ 179 0x02, 0xff, /* 2: LOUT1 muted */ 180 0x03, 0xff, /* 3: ROUT1 muted */ 181 0x04, 0xff, /* 4: LOUT2 muted */ 182 0x05, 0xff, /* 5: ROUT2 muted */ 183 0x06, 0xff, /* 6: LOUT3 muted */ 184 0x07, 0xff, /* 7: ROUT3 muted */ 185 0x0b, 0xff, /* B: LOUT4 muted */ 186 0x0c, 0xff, /* C: ROUT4 muted */ 187 0x08, 0x55, /* 8: deemphasis all off */ 188 0xff, 0xff 189 }; 190 static unsigned char inits_ak4355[] = { 191 0x01, 0x02, /* 1: reset and soft-mute */ 192 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect, 193 * disable DZF, sharp roll-off, RSTN#=0 */ 194 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */ 195 // 0x02, 0x2e, /* quad speed */ 196 0x03, 0x01, /* 3: de-emphasis off */ 197 0x04, 0x00, /* 4: LOUT1 volume muted */ 198 0x05, 0x00, /* 5: ROUT1 volume muted */ 199 0x06, 0x00, /* 6: LOUT2 volume muted */ 200 0x07, 0x00, /* 7: ROUT2 volume muted */ 201 0x08, 0x00, /* 8: LOUT3 volume muted */ 202 0x09, 0x00, /* 9: ROUT3 volume muted */ 203 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */ 204 0x01, 0x01, /* 1: un-reset, unmute */ 205 0xff, 0xff 206 }; 207 static unsigned char inits_ak4358[] = { 208 0x01, 0x02, /* 1: reset and soft-mute */ 209 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect, 210 * disable DZF, sharp roll-off, RSTN#=0 */ 211 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */ 212 // 0x02, 0x2e, /* quad speed */ 213 0x03, 0x01, /* 3: de-emphasis off */ 214 0x04, 0x00, /* 4: LOUT1 volume muted */ 215 0x05, 0x00, /* 5: ROUT1 volume muted */ 216 0x06, 0x00, /* 6: LOUT2 volume muted */ 217 0x07, 0x00, /* 7: ROUT2 volume muted */ 218 0x08, 0x00, /* 8: LOUT3 volume muted */ 219 0x09, 0x00, /* 9: ROUT3 volume muted */ 220 0x0b, 0x00, /* b: LOUT4 volume muted */ 221 0x0c, 0x00, /* c: ROUT4 volume muted */ 222 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */ 223 0x01, 0x01, /* 1: un-reset, unmute */ 224 0xff, 0xff 225 }; 226 static unsigned char inits_ak4381[] = { 227 0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */ 228 0x01, 0x02, /* 1: de-emphasis off, normal speed, 229 * sharp roll-off, DZF off */ 230 // 0x01, 0x12, /* quad speed */ 231 0x02, 0x00, /* 2: DZF disabled */ 232 0x03, 0x00, /* 3: LATT 0 */ 233 0x04, 0x00, /* 4: RATT 0 */ 234 0x00, 0x0f, /* 0: power-up, un-reset */ 235 0xff, 0xff 236 }; 237 238 int chip, num_chips; 239 unsigned char *ptr, reg, data, *inits; 240 241 switch (ak->type) { 242 case SND_AK4524: 243 inits = inits_ak4524; 244 num_chips = ak->num_dacs / 2; 245 break; 246 case SND_AK4528: 247 inits = inits_ak4528; 248 num_chips = ak->num_dacs / 2; 249 break; 250 case SND_AK4529: 251 inits = inits_ak4529; 252 num_chips = 1; 253 break; 254 case SND_AK4355: 255 inits = inits_ak4355; 256 num_chips = 1; 257 break; 258 case SND_AK4358: 259 inits = inits_ak4358; 260 num_chips = 1; 261 break; 262 case SND_AK4381: 263 inits = inits_ak4381; 264 num_chips = ak->num_dacs / 2; 265 break; 266 default: 267 snd_BUG(); 268 return; 269 } 270 271 for (chip = 0; chip < num_chips; chip++) { 272 ptr = inits; 273 while (*ptr != 0xff) { 274 reg = *ptr++; 275 data = *ptr++; 276 snd_akm4xxx_write(ak, chip, reg, data); 277 } 278 } 279 } 280 281 EXPORT_SYMBOL(snd_akm4xxx_init); 282 283 #define AK_GET_CHIP(val) (((val) >> 8) & 0xff) 284 #define AK_GET_ADDR(val) ((val) & 0xff) 285 #define AK_GET_SHIFT(val) (((val) >> 16) & 0x7f) 286 #define AK_GET_INVERT(val) (((val) >> 23) & 1) 287 #define AK_GET_MASK(val) (((val) >> 24) & 0xff) 288 #define AK_COMPOSE(chip,addr,shift,mask) \ 289 (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24)) 290 #define AK_INVERT (1<<23) 291 292 static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol, 293 struct snd_ctl_elem_info *uinfo) 294 { 295 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 296 297 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 298 uinfo->count = 1; 299 uinfo->value.integer.min = 0; 300 uinfo->value.integer.max = mask; 301 return 0; 302 } 303 304 static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol, 305 struct snd_ctl_elem_value *ucontrol) 306 { 307 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 308 int chip = AK_GET_CHIP(kcontrol->private_value); 309 int addr = AK_GET_ADDR(kcontrol->private_value); 310 int invert = AK_GET_INVERT(kcontrol->private_value); 311 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 312 unsigned char val = snd_akm4xxx_get(ak, chip, addr); 313 314 ucontrol->value.integer.value[0] = invert ? mask - val : val; 315 return 0; 316 } 317 318 static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol, 319 struct snd_ctl_elem_value *ucontrol) 320 { 321 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 322 int chip = AK_GET_CHIP(kcontrol->private_value); 323 int addr = AK_GET_ADDR(kcontrol->private_value); 324 int invert = AK_GET_INVERT(kcontrol->private_value); 325 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 326 unsigned char nval = ucontrol->value.integer.value[0] % (mask+1); 327 int change; 328 329 if (invert) 330 nval = mask - nval; 331 change = snd_akm4xxx_get(ak, chip, addr) != nval; 332 if (change) 333 snd_akm4xxx_write(ak, chip, addr, nval); 334 return change; 335 } 336 337 static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol *kcontrol, 338 struct snd_ctl_elem_info *uinfo) 339 { 340 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 341 342 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 343 uinfo->count = 2; 344 uinfo->value.integer.min = 0; 345 uinfo->value.integer.max = mask; 346 return 0; 347 } 348 349 static int snd_akm4xxx_stereo_volume_get(struct snd_kcontrol *kcontrol, 350 struct snd_ctl_elem_value *ucontrol) 351 { 352 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 353 int chip = AK_GET_CHIP(kcontrol->private_value); 354 int addr = AK_GET_ADDR(kcontrol->private_value); 355 int invert = AK_GET_INVERT(kcontrol->private_value); 356 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 357 unsigned char val = snd_akm4xxx_get(ak, chip, addr); 358 359 ucontrol->value.integer.value[0] = invert ? mask - val : val; 360 361 val = snd_akm4xxx_get(ak, chip, addr+1); 362 ucontrol->value.integer.value[1] = invert ? mask - val : val; 363 364 return 0; 365 } 366 367 static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol *kcontrol, 368 struct snd_ctl_elem_value *ucontrol) 369 { 370 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 371 int chip = AK_GET_CHIP(kcontrol->private_value); 372 int addr = AK_GET_ADDR(kcontrol->private_value); 373 int invert = AK_GET_INVERT(kcontrol->private_value); 374 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 375 unsigned char nval = ucontrol->value.integer.value[0] % (mask+1); 376 int change0, change1; 377 378 if (invert) 379 nval = mask - nval; 380 change0 = snd_akm4xxx_get(ak, chip, addr) != nval; 381 if (change0) 382 snd_akm4xxx_write(ak, chip, addr, nval); 383 384 nval = ucontrol->value.integer.value[1] % (mask+1); 385 if (invert) 386 nval = mask - nval; 387 change1 = snd_akm4xxx_get(ak, chip, addr+1) != nval; 388 if (change1) 389 snd_akm4xxx_write(ak, chip, addr+1, nval); 390 391 392 return change0 || change1; 393 } 394 395 static int snd_akm4xxx_ipga_gain_info(struct snd_kcontrol *kcontrol, 396 struct snd_ctl_elem_info *uinfo) 397 { 398 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 399 uinfo->count = 1; 400 uinfo->value.integer.min = 0; 401 uinfo->value.integer.max = 36; 402 return 0; 403 } 404 405 static int snd_akm4xxx_ipga_gain_get(struct snd_kcontrol *kcontrol, 406 struct snd_ctl_elem_value *ucontrol) 407 { 408 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 409 int chip = AK_GET_CHIP(kcontrol->private_value); 410 int addr = AK_GET_ADDR(kcontrol->private_value); 411 ucontrol->value.integer.value[0] = 412 snd_akm4xxx_get_ipga(ak, chip, addr) & 0x7f; 413 return 0; 414 } 415 416 static int snd_akm4xxx_ipga_gain_put(struct snd_kcontrol *kcontrol, 417 struct snd_ctl_elem_value *ucontrol) 418 { 419 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 420 int chip = AK_GET_CHIP(kcontrol->private_value); 421 int addr = AK_GET_ADDR(kcontrol->private_value); 422 unsigned char nval = (ucontrol->value.integer.value[0] % 37) | 0x80; 423 int change = snd_akm4xxx_get_ipga(ak, chip, addr) != nval; 424 if (change) 425 snd_akm4xxx_write(ak, chip, addr, nval); 426 return change; 427 } 428 429 static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol, 430 struct snd_ctl_elem_info *uinfo) 431 { 432 static char *texts[4] = { 433 "44.1kHz", "Off", "48kHz", "32kHz", 434 }; 435 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 436 uinfo->count = 1; 437 uinfo->value.enumerated.items = 4; 438 if (uinfo->value.enumerated.item >= 4) 439 uinfo->value.enumerated.item = 3; 440 strcpy(uinfo->value.enumerated.name, 441 texts[uinfo->value.enumerated.item]); 442 return 0; 443 } 444 445 static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol, 446 struct snd_ctl_elem_value *ucontrol) 447 { 448 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 449 int chip = AK_GET_CHIP(kcontrol->private_value); 450 int addr = AK_GET_ADDR(kcontrol->private_value); 451 int shift = AK_GET_SHIFT(kcontrol->private_value); 452 ucontrol->value.enumerated.item[0] = 453 (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3; 454 return 0; 455 } 456 457 static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol, 458 struct snd_ctl_elem_value *ucontrol) 459 { 460 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 461 int chip = AK_GET_CHIP(kcontrol->private_value); 462 int addr = AK_GET_ADDR(kcontrol->private_value); 463 int shift = AK_GET_SHIFT(kcontrol->private_value); 464 unsigned char nval = ucontrol->value.enumerated.item[0] & 3; 465 int change; 466 467 nval = (nval << shift) | 468 (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift)); 469 change = snd_akm4xxx_get(ak, chip, addr) != nval; 470 if (change) 471 snd_akm4xxx_write(ak, chip, addr, nval); 472 return change; 473 } 474 475 /* 476 * build AK4xxx controls 477 */ 478 479 int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) 480 { 481 unsigned int idx, num_emphs; 482 struct snd_kcontrol *ctl; 483 int err; 484 int mixer_ch = 0; 485 int num_stereo; 486 487 ctl = kmalloc(sizeof(*ctl), GFP_KERNEL); 488 if (! ctl) 489 return -ENOMEM; 490 491 for (idx = 0; idx < ak->num_dacs; ) { 492 memset(ctl, 0, sizeof(*ctl)); 493 if (ak->channel_names == NULL) { 494 strcpy(ctl->id.name, "DAC Volume"); 495 num_stereo = 1; 496 ctl->id.index = mixer_ch + ak->idx_offset * 2; 497 } else { 498 strcpy(ctl->id.name, ak->channel_names[mixer_ch]); 499 num_stereo = ak->num_stereo[mixer_ch]; 500 ctl->id.index = 0; 501 } 502 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 503 ctl->count = 1; 504 if (num_stereo == 2) { 505 ctl->info = snd_akm4xxx_stereo_volume_info; 506 ctl->get = snd_akm4xxx_stereo_volume_get; 507 ctl->put = snd_akm4xxx_stereo_volume_put; 508 } else { 509 ctl->info = snd_akm4xxx_volume_info; 510 ctl->get = snd_akm4xxx_volume_get; 511 ctl->put = snd_akm4xxx_volume_put; 512 } 513 switch (ak->type) { 514 case SND_AK4524: 515 /* register 6 & 7 */ 516 ctl->private_value = 517 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127); 518 break; 519 case SND_AK4528: 520 /* register 4 & 5 */ 521 ctl->private_value = 522 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127); 523 break; 524 case SND_AK4529: { 525 /* registers 2-7 and b,c */ 526 int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb; 527 ctl->private_value = 528 AK_COMPOSE(0, val, 0, 255) | AK_INVERT; 529 break; 530 } 531 case SND_AK4355: 532 /* register 4-9, chip #0 only */ 533 ctl->private_value = AK_COMPOSE(0, idx + 4, 0, 255); 534 break; 535 case SND_AK4358: 536 if (idx >= 6) 537 /* register 4-9, chip #0 only */ 538 ctl->private_value = 539 AK_COMPOSE(0, idx + 5, 0, 255); 540 else 541 /* register 4-9, chip #0 only */ 542 ctl->private_value = 543 AK_COMPOSE(0, idx + 4, 0, 255); 544 break; 545 case SND_AK4381: 546 /* register 3 & 4 */ 547 ctl->private_value = 548 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255); 549 break; 550 default: 551 err = -EINVAL; 552 goto __error; 553 } 554 555 ctl->private_data = ak; 556 err = snd_ctl_add(ak->card, 557 snd_ctl_new(ctl, SNDRV_CTL_ELEM_ACCESS_READ| 558 SNDRV_CTL_ELEM_ACCESS_WRITE)); 559 if (err < 0) 560 goto __error; 561 562 idx += num_stereo; 563 mixer_ch++; 564 } 565 for (idx = 0; idx < ak->num_adcs && ak->type == SND_AK4524; ++idx) { 566 memset(ctl, 0, sizeof(*ctl)); 567 strcpy(ctl->id.name, "ADC Volume"); 568 ctl->id.index = idx + ak->idx_offset * 2; 569 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 570 ctl->count = 1; 571 ctl->info = snd_akm4xxx_volume_info; 572 ctl->get = snd_akm4xxx_volume_get; 573 ctl->put = snd_akm4xxx_volume_put; 574 /* register 4 & 5 */ 575 ctl->private_value = 576 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127); 577 ctl->private_data = ak; 578 err = snd_ctl_add(ak->card, 579 snd_ctl_new(ctl, SNDRV_CTL_ELEM_ACCESS_READ| 580 SNDRV_CTL_ELEM_ACCESS_WRITE)); 581 if (err < 0) 582 goto __error; 583 584 memset(ctl, 0, sizeof(*ctl)); 585 strcpy(ctl->id.name, "IPGA Analog Capture Volume"); 586 ctl->id.index = idx + ak->idx_offset * 2; 587 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 588 ctl->count = 1; 589 ctl->info = snd_akm4xxx_ipga_gain_info; 590 ctl->get = snd_akm4xxx_ipga_gain_get; 591 ctl->put = snd_akm4xxx_ipga_gain_put; 592 /* register 4 & 5 */ 593 ctl->private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 0); 594 ctl->private_data = ak; 595 err = snd_ctl_add(ak->card, 596 snd_ctl_new(ctl, SNDRV_CTL_ELEM_ACCESS_READ| 597 SNDRV_CTL_ELEM_ACCESS_WRITE)); 598 if (err < 0) 599 goto __error; 600 } 601 if (ak->type == SND_AK4355 || ak->type == SND_AK4358) 602 num_emphs = 1; 603 else 604 num_emphs = ak->num_dacs / 2; 605 for (idx = 0; idx < num_emphs; idx++) { 606 memset(ctl, 0, sizeof(*ctl)); 607 strcpy(ctl->id.name, "Deemphasis"); 608 ctl->id.index = idx + ak->idx_offset; 609 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 610 ctl->count = 1; 611 ctl->info = snd_akm4xxx_deemphasis_info; 612 ctl->get = snd_akm4xxx_deemphasis_get; 613 ctl->put = snd_akm4xxx_deemphasis_put; 614 switch (ak->type) { 615 case SND_AK4524: 616 case SND_AK4528: 617 /* register 3 */ 618 ctl->private_value = AK_COMPOSE(idx, 3, 0, 0); 619 break; 620 case SND_AK4529: { 621 int shift = idx == 3 ? 6 : (2 - idx) * 2; 622 /* register 8 with shift */ 623 ctl->private_value = AK_COMPOSE(0, 8, shift, 0); 624 break; 625 } 626 case SND_AK4355: 627 case SND_AK4358: 628 ctl->private_value = AK_COMPOSE(idx, 3, 0, 0); 629 break; 630 case SND_AK4381: 631 ctl->private_value = AK_COMPOSE(idx, 1, 1, 0); 632 break; 633 } 634 ctl->private_data = ak; 635 err = snd_ctl_add(ak->card, 636 snd_ctl_new(ctl, SNDRV_CTL_ELEM_ACCESS_READ| 637 SNDRV_CTL_ELEM_ACCESS_WRITE)); 638 if (err < 0) 639 goto __error; 640 } 641 err = 0; 642 643 __error: 644 kfree(ctl); 645 return err; 646 } 647 648 EXPORT_SYMBOL(snd_akm4xxx_build_controls); 649 650 static int __init alsa_akm4xxx_module_init(void) 651 { 652 return 0; 653 } 654 655 static void __exit alsa_akm4xxx_module_exit(void) 656 { 657 } 658 659 module_init(alsa_akm4xxx_module_init) 660 module_exit(alsa_akm4xxx_module_exit) 661