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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 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 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 snd_akm4xxx_write(ak, chip, addr, nval); 395 return 1; 396 } 397 398 static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol, 399 struct snd_ctl_elem_value *ucontrol) 400 { 401 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 402 unsigned int val = ucontrol->value.integer.value[0]; 403 if (val > mask) 404 return -EINVAL; 405 return put_ak_reg(kcontrol, AK_GET_ADDR(kcontrol->private_value), val); 406 } 407 408 static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol *kcontrol, 409 struct snd_ctl_elem_info *uinfo) 410 { 411 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 412 413 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 414 uinfo->count = 2; 415 uinfo->value.integer.min = 0; 416 uinfo->value.integer.max = mask; 417 return 0; 418 } 419 420 static int snd_akm4xxx_stereo_volume_get(struct snd_kcontrol *kcontrol, 421 struct snd_ctl_elem_value *ucontrol) 422 { 423 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 424 int chip = AK_GET_CHIP(kcontrol->private_value); 425 int addr = AK_GET_ADDR(kcontrol->private_value); 426 427 ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr); 428 ucontrol->value.integer.value[1] = snd_akm4xxx_get_vol(ak, chip, addr+1); 429 return 0; 430 } 431 432 static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol *kcontrol, 433 struct snd_ctl_elem_value *ucontrol) 434 { 435 int addr = AK_GET_ADDR(kcontrol->private_value); 436 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 437 unsigned int val[2]; 438 int change; 439 440 val[0] = ucontrol->value.integer.value[0]; 441 val[1] = ucontrol->value.integer.value[1]; 442 if (val[0] > mask || val[1] > mask) 443 return -EINVAL; 444 change = put_ak_reg(kcontrol, addr, val[0]); 445 change |= put_ak_reg(kcontrol, addr + 1, val[1]); 446 return change; 447 } 448 449 static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol, 450 struct snd_ctl_elem_info *uinfo) 451 { 452 static const char * const texts[4] = { 453 "44.1kHz", "Off", "48kHz", "32kHz", 454 }; 455 return snd_ctl_enum_info(uinfo, 1, 4, texts); 456 } 457 458 static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol, 459 struct snd_ctl_elem_value *ucontrol) 460 { 461 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 462 int chip = AK_GET_CHIP(kcontrol->private_value); 463 int addr = AK_GET_ADDR(kcontrol->private_value); 464 int shift = AK_GET_SHIFT(kcontrol->private_value); 465 ucontrol->value.enumerated.item[0] = 466 (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3; 467 return 0; 468 } 469 470 static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol, 471 struct snd_ctl_elem_value *ucontrol) 472 { 473 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 474 int chip = AK_GET_CHIP(kcontrol->private_value); 475 int addr = AK_GET_ADDR(kcontrol->private_value); 476 int shift = AK_GET_SHIFT(kcontrol->private_value); 477 unsigned char nval = ucontrol->value.enumerated.item[0] & 3; 478 int change; 479 480 nval = (nval << shift) | 481 (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift)); 482 change = snd_akm4xxx_get(ak, chip, addr) != nval; 483 if (change) 484 snd_akm4xxx_write(ak, chip, addr, nval); 485 return change; 486 } 487 488 #define ak4xxx_switch_info snd_ctl_boolean_mono_info 489 490 static int ak4xxx_switch_get(struct snd_kcontrol *kcontrol, 491 struct snd_ctl_elem_value *ucontrol) 492 { 493 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 494 int chip = AK_GET_CHIP(kcontrol->private_value); 495 int addr = AK_GET_ADDR(kcontrol->private_value); 496 int shift = AK_GET_SHIFT(kcontrol->private_value); 497 int invert = AK_GET_INVERT(kcontrol->private_value); 498 /* we observe the (1<<shift) bit only */ 499 unsigned char val = snd_akm4xxx_get(ak, chip, addr) & (1<<shift); 500 if (invert) 501 val = ! val; 502 ucontrol->value.integer.value[0] = (val & (1<<shift)) != 0; 503 return 0; 504 } 505 506 static int ak4xxx_switch_put(struct snd_kcontrol *kcontrol, 507 struct snd_ctl_elem_value *ucontrol) 508 { 509 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 510 int chip = AK_GET_CHIP(kcontrol->private_value); 511 int addr = AK_GET_ADDR(kcontrol->private_value); 512 int shift = AK_GET_SHIFT(kcontrol->private_value); 513 int invert = AK_GET_INVERT(kcontrol->private_value); 514 long flag = ucontrol->value.integer.value[0]; 515 unsigned char val, oval; 516 int change; 517 518 if (invert) 519 flag = ! flag; 520 oval = snd_akm4xxx_get(ak, chip, addr); 521 if (flag) 522 val = oval | (1<<shift); 523 else 524 val = oval & ~(1<<shift); 525 change = (oval != val); 526 if (change) 527 snd_akm4xxx_write(ak, chip, addr, val); 528 return change; 529 } 530 531 #define AK5365_NUM_INPUTS 5 532 533 static int ak4xxx_capture_num_inputs(struct snd_akm4xxx *ak, int mixer_ch) 534 { 535 int num_names; 536 const char **input_names; 537 538 input_names = ak->adc_info[mixer_ch].input_names; 539 num_names = 0; 540 while (num_names < AK5365_NUM_INPUTS && input_names[num_names]) 541 ++num_names; 542 return num_names; 543 } 544 545 static int ak4xxx_capture_source_info(struct snd_kcontrol *kcontrol, 546 struct snd_ctl_elem_info *uinfo) 547 { 548 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 549 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value); 550 unsigned int num_names; 551 552 num_names = ak4xxx_capture_num_inputs(ak, mixer_ch); 553 if (!num_names) 554 return -EINVAL; 555 return snd_ctl_enum_info(uinfo, 1, num_names, 556 ak->adc_info[mixer_ch].input_names); 557 } 558 559 static int ak4xxx_capture_source_get(struct snd_kcontrol *kcontrol, 560 struct snd_ctl_elem_value *ucontrol) 561 { 562 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 563 int chip = AK_GET_CHIP(kcontrol->private_value); 564 int addr = AK_GET_ADDR(kcontrol->private_value); 565 int mask = AK_GET_MASK(kcontrol->private_value); 566 unsigned char val; 567 568 val = snd_akm4xxx_get(ak, chip, addr) & mask; 569 ucontrol->value.enumerated.item[0] = val; 570 return 0; 571 } 572 573 static int ak4xxx_capture_source_put(struct snd_kcontrol *kcontrol, 574 struct snd_ctl_elem_value *ucontrol) 575 { 576 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 577 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value); 578 int chip = AK_GET_CHIP(kcontrol->private_value); 579 int addr = AK_GET_ADDR(kcontrol->private_value); 580 int mask = AK_GET_MASK(kcontrol->private_value); 581 unsigned char oval, val; 582 int num_names = ak4xxx_capture_num_inputs(ak, mixer_ch); 583 584 if (ucontrol->value.enumerated.item[0] >= num_names) 585 return -EINVAL; 586 587 oval = snd_akm4xxx_get(ak, chip, addr); 588 val = oval & ~mask; 589 val |= ucontrol->value.enumerated.item[0] & mask; 590 if (val != oval) { 591 snd_akm4xxx_write(ak, chip, addr, val); 592 return 1; 593 } 594 return 0; 595 } 596 597 /* 598 * build AK4xxx controls 599 */ 600 601 static int build_dac_controls(struct snd_akm4xxx *ak) 602 { 603 int idx, err, mixer_ch, num_stereo; 604 struct snd_kcontrol_new knew; 605 606 mixer_ch = 0; 607 for (idx = 0; idx < ak->num_dacs; ) { 608 /* mute control for Revolution 7.1 - AK4381 */ 609 if (ak->type == SND_AK4381 610 && ak->dac_info[mixer_ch].switch_name) { 611 memset(&knew, 0, sizeof(knew)); 612 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 613 knew.count = 1; 614 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE; 615 knew.name = ak->dac_info[mixer_ch].switch_name; 616 knew.info = ak4xxx_switch_info; 617 knew.get = ak4xxx_switch_get; 618 knew.put = ak4xxx_switch_put; 619 knew.access = 0; 620 /* register 1, bit 0 (SMUTE): 0 = normal operation, 621 1 = mute */ 622 knew.private_value = 623 AK_COMPOSE(idx/2, 1, 0, 0) | AK_INVERT; 624 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 625 if (err < 0) 626 return err; 627 } 628 memset(&knew, 0, sizeof(knew)); 629 if (! ak->dac_info || ! ak->dac_info[mixer_ch].name) { 630 knew.name = "DAC Volume"; 631 knew.index = mixer_ch + ak->idx_offset * 2; 632 num_stereo = 1; 633 } else { 634 knew.name = ak->dac_info[mixer_ch].name; 635 num_stereo = ak->dac_info[mixer_ch].num_channels; 636 } 637 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 638 knew.count = 1; 639 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 640 SNDRV_CTL_ELEM_ACCESS_TLV_READ; 641 if (num_stereo == 2) { 642 knew.info = snd_akm4xxx_stereo_volume_info; 643 knew.get = snd_akm4xxx_stereo_volume_get; 644 knew.put = snd_akm4xxx_stereo_volume_put; 645 } else { 646 knew.info = snd_akm4xxx_volume_info; 647 knew.get = snd_akm4xxx_volume_get; 648 knew.put = snd_akm4xxx_volume_put; 649 } 650 switch (ak->type) { 651 case SND_AK4524: 652 /* register 6 & 7 */ 653 knew.private_value = 654 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127) | 655 AK_VOL_CVT; 656 knew.tlv.p = db_scale_vol_datt; 657 break; 658 case SND_AK4528: 659 /* register 4 & 5 */ 660 knew.private_value = 661 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127) | 662 AK_VOL_CVT; 663 knew.tlv.p = db_scale_vol_datt; 664 break; 665 case SND_AK4529: { 666 /* registers 2-7 and b,c */ 667 int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb; 668 knew.private_value = 669 AK_COMPOSE(0, val, 0, 255) | AK_INVERT; 670 knew.tlv.p = db_scale_8bit; 671 break; 672 } 673 case SND_AK4355: 674 /* register 4-9, chip #0 only */ 675 knew.private_value = AK_COMPOSE(0, idx + 4, 0, 255); 676 knew.tlv.p = db_scale_8bit; 677 break; 678 case SND_AK4358: { 679 /* register 4-9 and 11-12, chip #0 only */ 680 int addr = idx < 6 ? idx + 4 : idx + 5; 681 knew.private_value = 682 AK_COMPOSE(0, addr, 0, 127) | AK_NEEDSMSB; 683 knew.tlv.p = db_scale_7bit; 684 break; 685 } 686 case SND_AK4381: 687 /* register 3 & 4 */ 688 knew.private_value = 689 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255); 690 knew.tlv.p = db_scale_linear; 691 break; 692 case SND_AK4620: 693 /* register 6 & 7 */ 694 knew.private_value = 695 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255); 696 knew.tlv.p = db_scale_linear; 697 break; 698 default: 699 return -EINVAL; 700 } 701 702 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 703 if (err < 0) 704 return err; 705 706 idx += num_stereo; 707 mixer_ch++; 708 } 709 return 0; 710 } 711 712 static int build_adc_controls(struct snd_akm4xxx *ak) 713 { 714 int idx, err, mixer_ch, num_stereo, max_steps; 715 struct snd_kcontrol_new knew; 716 717 mixer_ch = 0; 718 if (ak->type == SND_AK4528) 719 return 0; /* no controls */ 720 for (idx = 0; idx < ak->num_adcs;) { 721 memset(&knew, 0, sizeof(knew)); 722 if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) { 723 knew.name = "ADC Volume"; 724 knew.index = mixer_ch + ak->idx_offset * 2; 725 num_stereo = 1; 726 } else { 727 knew.name = ak->adc_info[mixer_ch].name; 728 num_stereo = ak->adc_info[mixer_ch].num_channels; 729 } 730 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 731 knew.count = 1; 732 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 733 SNDRV_CTL_ELEM_ACCESS_TLV_READ; 734 if (num_stereo == 2) { 735 knew.info = snd_akm4xxx_stereo_volume_info; 736 knew.get = snd_akm4xxx_stereo_volume_get; 737 knew.put = snd_akm4xxx_stereo_volume_put; 738 } else { 739 knew.info = snd_akm4xxx_volume_info; 740 knew.get = snd_akm4xxx_volume_get; 741 knew.put = snd_akm4xxx_volume_put; 742 } 743 /* register 4 & 5 */ 744 if (ak->type == SND_AK5365) 745 max_steps = 152; 746 else 747 max_steps = 164; 748 knew.private_value = 749 AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) | 750 AK_VOL_CVT | AK_IPGA; 751 knew.tlv.p = db_scale_vol_datt; 752 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 753 if (err < 0) 754 return err; 755 756 if (ak->type == SND_AK5365 && (idx % 2) == 0) { 757 if (! ak->adc_info || 758 ! ak->adc_info[mixer_ch].switch_name) { 759 knew.name = "Capture Switch"; 760 knew.index = mixer_ch + ak->idx_offset * 2; 761 } else 762 knew.name = ak->adc_info[mixer_ch].switch_name; 763 knew.info = ak4xxx_switch_info; 764 knew.get = ak4xxx_switch_get; 765 knew.put = ak4xxx_switch_put; 766 knew.access = 0; 767 /* register 2, bit 0 (SMUTE): 0 = normal operation, 768 1 = mute */ 769 knew.private_value = 770 AK_COMPOSE(idx/2, 2, 0, 0) | AK_INVERT; 771 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 772 if (err < 0) 773 return err; 774 775 memset(&knew, 0, sizeof(knew)); 776 if (!ak->adc_info || 777 !ak->adc_info[mixer_ch].selector_name) { 778 knew.name = "Capture Channel"; 779 knew.index = mixer_ch + ak->idx_offset * 2; 780 } else 781 knew.name = ak->adc_info[mixer_ch].selector_name; 782 783 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 784 knew.info = ak4xxx_capture_source_info; 785 knew.get = ak4xxx_capture_source_get; 786 knew.put = ak4xxx_capture_source_put; 787 knew.access = 0; 788 /* input selector control: reg. 1, bits 0-2. 789 * mis-use 'shift' to pass mixer_ch */ 790 knew.private_value 791 = AK_COMPOSE(idx/2, 1, mixer_ch, 0x07); 792 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 793 if (err < 0) 794 return err; 795 } 796 797 idx += num_stereo; 798 mixer_ch++; 799 } 800 return 0; 801 } 802 803 static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs) 804 { 805 int idx, err; 806 struct snd_kcontrol_new knew; 807 808 for (idx = 0; idx < num_emphs; idx++) { 809 memset(&knew, 0, sizeof(knew)); 810 knew.name = "Deemphasis"; 811 knew.index = idx + ak->idx_offset; 812 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 813 knew.count = 1; 814 knew.info = snd_akm4xxx_deemphasis_info; 815 knew.get = snd_akm4xxx_deemphasis_get; 816 knew.put = snd_akm4xxx_deemphasis_put; 817 switch (ak->type) { 818 case SND_AK4524: 819 case SND_AK4528: 820 case SND_AK4620: 821 /* register 3 */ 822 knew.private_value = AK_COMPOSE(idx, 3, 0, 0); 823 break; 824 case SND_AK4529: { 825 int shift = idx == 3 ? 6 : (2 - idx) * 2; 826 /* register 8 with shift */ 827 knew.private_value = AK_COMPOSE(0, 8, shift, 0); 828 break; 829 } 830 case SND_AK4355: 831 case SND_AK4358: 832 knew.private_value = AK_COMPOSE(idx, 3, 0, 0); 833 break; 834 case SND_AK4381: 835 knew.private_value = AK_COMPOSE(idx, 1, 1, 0); 836 break; 837 default: 838 return -EINVAL; 839 } 840 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 841 if (err < 0) 842 return err; 843 } 844 return 0; 845 } 846 847 static void proc_regs_read(struct snd_info_entry *entry, 848 struct snd_info_buffer *buffer) 849 { 850 struct snd_akm4xxx *ak = entry->private_data; 851 int reg, val, chip; 852 for (chip = 0; chip < ak->num_chips; chip++) { 853 for (reg = 0; reg < ak->total_regs; reg++) { 854 val = snd_akm4xxx_get(ak, chip, reg); 855 snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip, 856 reg, val); 857 } 858 } 859 } 860 861 static int proc_init(struct snd_akm4xxx *ak) 862 { 863 return snd_card_ro_proc_new(ak->card, ak->name, ak, proc_regs_read); 864 } 865 866 int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) 867 { 868 int err, num_emphs; 869 870 err = build_dac_controls(ak); 871 if (err < 0) 872 return err; 873 874 err = build_adc_controls(ak); 875 if (err < 0) 876 return err; 877 if (ak->type == SND_AK4355 || ak->type == SND_AK4358) 878 num_emphs = 1; 879 else if (ak->type == SND_AK4620) 880 num_emphs = 0; 881 else 882 num_emphs = ak->num_dacs / 2; 883 err = build_deemphasis(ak, num_emphs); 884 if (err < 0) 885 return err; 886 err = proc_init(ak); 887 if (err < 0) 888 return err; 889 890 return 0; 891 } 892 EXPORT_SYMBOL(snd_akm4xxx_build_controls); 893