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@perex.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 <linux/io.h> 25 #include <linux/delay.h> 26 #include <linux/interrupt.h> 27 #include <linux/init.h> 28 #include <linux/module.h> 29 #include <sound/core.h> 30 #include <sound/control.h> 31 #include <sound/tlv.h> 32 #include <sound/ak4xxx-adda.h> 33 #include <sound/info.h> 34 35 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>"); 36 MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters"); 37 MODULE_LICENSE("GPL"); 38 39 /* write the given register and save the data to the cache */ 40 void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg, 41 unsigned char val) 42 { 43 ak->ops.lock(ak, chip); 44 ak->ops.write(ak, chip, reg, val); 45 46 /* save the data */ 47 snd_akm4xxx_set(ak, chip, reg, val); 48 ak->ops.unlock(ak, chip); 49 } 50 51 EXPORT_SYMBOL(snd_akm4xxx_write); 52 53 /* reset procedure for AK4524 and AK4528 */ 54 static void ak4524_reset(struct snd_akm4xxx *ak, int state) 55 { 56 unsigned int chip; 57 unsigned char reg; 58 59 for (chip = 0; chip < ak->num_dacs/2; chip++) { 60 snd_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03); 61 if (state) 62 continue; 63 /* DAC volumes */ 64 for (reg = 0x04; reg < ak->total_regs; reg++) 65 snd_akm4xxx_write(ak, chip, reg, 66 snd_akm4xxx_get(ak, chip, reg)); 67 } 68 } 69 70 /* reset procedure for AK4355 and AK4358 */ 71 static void ak435X_reset(struct snd_akm4xxx *ak, int state) 72 { 73 unsigned char reg; 74 75 if (state) { 76 snd_akm4xxx_write(ak, 0, 0x01, 0x02); /* reset and soft-mute */ 77 return; 78 } 79 for (reg = 0x00; reg < ak->total_regs; reg++) 80 if (reg != 0x01) 81 snd_akm4xxx_write(ak, 0, reg, 82 snd_akm4xxx_get(ak, 0, reg)); 83 snd_akm4xxx_write(ak, 0, 0x01, 0x01); /* un-reset, unmute */ 84 } 85 86 /* reset procedure for AK4381 */ 87 static void ak4381_reset(struct snd_akm4xxx *ak, int state) 88 { 89 unsigned int chip; 90 unsigned char reg; 91 for (chip = 0; chip < ak->num_dacs/2; chip++) { 92 snd_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f); 93 if (state) 94 continue; 95 for (reg = 0x01; reg < ak->total_regs; reg++) 96 snd_akm4xxx_write(ak, chip, reg, 97 snd_akm4xxx_get(ak, chip, reg)); 98 } 99 } 100 101 /* 102 * reset the AKM codecs 103 * @state: 1 = reset codec, 0 = restore the registers 104 * 105 * assert the reset operation and restores the register values to the chips. 106 */ 107 void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state) 108 { 109 switch (ak->type) { 110 case SND_AK4524: 111 case SND_AK4528: 112 case SND_AK4620: 113 ak4524_reset(ak, state); 114 break; 115 case SND_AK4529: 116 /* FIXME: needed for ak4529? */ 117 break; 118 case SND_AK4355: 119 ak435X_reset(ak, state); 120 break; 121 case SND_AK4358: 122 ak435X_reset(ak, state); 123 break; 124 case SND_AK4381: 125 ak4381_reset(ak, state); 126 break; 127 default: 128 break; 129 } 130 } 131 132 EXPORT_SYMBOL(snd_akm4xxx_reset); 133 134 135 /* 136 * Volume conversion table for non-linear volumes 137 * from -63.5dB (mute) to 0dB step 0.5dB 138 * 139 * Used for AK4524/AK4620 input/ouput attenuation, AK4528, and 140 * AK5365 input attenuation 141 */ 142 static const unsigned char vol_cvt_datt[128] = { 143 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 144 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 145 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x0a, 146 0x0a, 0x0b, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0f, 147 0x10, 0x10, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14, 148 0x15, 0x16, 0x17, 0x17, 0x18, 0x19, 0x1a, 0x1c, 149 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x23, 150 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 0x2b, 0x2d, 151 0x2e, 0x30, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 152 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3e, 0x3f, 0x40, 153 0x41, 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x4a, 154 0x4b, 0x4d, 0x4e, 0x50, 0x51, 0x52, 0x53, 0x54, 155 0x55, 0x56, 0x58, 0x59, 0x5b, 0x5c, 0x5e, 0x5f, 156 0x60, 0x61, 0x62, 0x64, 0x65, 0x66, 0x67, 0x69, 157 0x6a, 0x6c, 0x6d, 0x6f, 0x70, 0x71, 0x72, 0x73, 158 0x75, 0x76, 0x77, 0x79, 0x7a, 0x7c, 0x7d, 0x7f, 159 }; 160 161 /* 162 * dB tables 163 */ 164 static const DECLARE_TLV_DB_SCALE(db_scale_vol_datt, -6350, 50, 1); 165 static const DECLARE_TLV_DB_SCALE(db_scale_8bit, -12750, 50, 1); 166 static const DECLARE_TLV_DB_SCALE(db_scale_7bit, -6350, 50, 1); 167 static const DECLARE_TLV_DB_LINEAR(db_scale_linear, TLV_DB_GAIN_MUTE, 0); 168 169 /* 170 * initialize all the ak4xxx chips 171 */ 172 void snd_akm4xxx_init(struct snd_akm4xxx *ak) 173 { 174 static const unsigned char inits_ak4524[] = { 175 0x00, 0x07, /* 0: all power up */ 176 0x01, 0x00, /* 1: ADC/DAC reset */ 177 0x02, 0x60, /* 2: 24bit I2S */ 178 0x03, 0x19, /* 3: deemphasis off */ 179 0x01, 0x03, /* 1: ADC/DAC enable */ 180 0x04, 0x00, /* 4: ADC left muted */ 181 0x05, 0x00, /* 5: ADC right muted */ 182 0x06, 0x00, /* 6: DAC left muted */ 183 0x07, 0x00, /* 7: DAC right muted */ 184 0xff, 0xff 185 }; 186 static const unsigned char inits_ak4528[] = { 187 0x00, 0x07, /* 0: all power up */ 188 0x01, 0x00, /* 1: ADC/DAC reset */ 189 0x02, 0x60, /* 2: 24bit I2S */ 190 0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */ 191 0x01, 0x03, /* 1: ADC/DAC enable */ 192 0x04, 0x00, /* 4: ADC left muted */ 193 0x05, 0x00, /* 5: ADC right muted */ 194 0xff, 0xff 195 }; 196 static const unsigned char inits_ak4529[] = { 197 0x09, 0x01, /* 9: ATS=0, RSTN=1 */ 198 0x0a, 0x3f, /* A: all power up, no zero/overflow detection */ 199 0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */ 200 0x01, 0x00, /* 1: ACKS=0, ADC, loop off */ 201 0x02, 0xff, /* 2: LOUT1 muted */ 202 0x03, 0xff, /* 3: ROUT1 muted */ 203 0x04, 0xff, /* 4: LOUT2 muted */ 204 0x05, 0xff, /* 5: ROUT2 muted */ 205 0x06, 0xff, /* 6: LOUT3 muted */ 206 0x07, 0xff, /* 7: ROUT3 muted */ 207 0x0b, 0xff, /* B: LOUT4 muted */ 208 0x0c, 0xff, /* C: ROUT4 muted */ 209 0x08, 0x55, /* 8: deemphasis all off */ 210 0xff, 0xff 211 }; 212 static const unsigned char inits_ak4355[] = { 213 0x01, 0x02, /* 1: reset and soft-mute */ 214 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect, 215 * disable DZF, sharp roll-off, RSTN#=0 */ 216 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */ 217 // 0x02, 0x2e, /* quad speed */ 218 0x03, 0x01, /* 3: de-emphasis off */ 219 0x04, 0x00, /* 4: LOUT1 volume muted */ 220 0x05, 0x00, /* 5: ROUT1 volume muted */ 221 0x06, 0x00, /* 6: LOUT2 volume muted */ 222 0x07, 0x00, /* 7: ROUT2 volume muted */ 223 0x08, 0x00, /* 8: LOUT3 volume muted */ 224 0x09, 0x00, /* 9: ROUT3 volume muted */ 225 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */ 226 0x01, 0x01, /* 1: un-reset, unmute */ 227 0xff, 0xff 228 }; 229 static const unsigned char inits_ak4358[] = { 230 0x01, 0x02, /* 1: reset and soft-mute */ 231 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect, 232 * disable DZF, sharp roll-off, RSTN#=0 */ 233 0x02, 0x4e, /* 2: DA's power up, normal speed, RSTN#=0 */ 234 /* 0x02, 0x6e,*/ /* quad speed */ 235 0x03, 0x01, /* 3: de-emphasis off */ 236 0x04, 0x00, /* 4: LOUT1 volume muted */ 237 0x05, 0x00, /* 5: ROUT1 volume muted */ 238 0x06, 0x00, /* 6: LOUT2 volume muted */ 239 0x07, 0x00, /* 7: ROUT2 volume muted */ 240 0x08, 0x00, /* 8: LOUT3 volume muted */ 241 0x09, 0x00, /* 9: ROUT3 volume muted */ 242 0x0b, 0x00, /* b: LOUT4 volume muted */ 243 0x0c, 0x00, /* c: ROUT4 volume muted */ 244 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */ 245 0x01, 0x01, /* 1: un-reset, unmute */ 246 0xff, 0xff 247 }; 248 static const unsigned char inits_ak4381[] = { 249 0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */ 250 0x01, 0x02, /* 1: de-emphasis off, normal speed, 251 * sharp roll-off, DZF off */ 252 // 0x01, 0x12, /* quad speed */ 253 0x02, 0x00, /* 2: DZF disabled */ 254 0x03, 0x00, /* 3: LATT 0 */ 255 0x04, 0x00, /* 4: RATT 0 */ 256 0x00, 0x0f, /* 0: power-up, un-reset */ 257 0xff, 0xff 258 }; 259 static const unsigned char inits_ak4620[] = { 260 0x00, 0x07, /* 0: normal */ 261 0x01, 0x00, /* 0: reset */ 262 0x01, 0x02, /* 1: RSTAD */ 263 0x01, 0x03, /* 1: RSTDA */ 264 0x01, 0x0f, /* 1: normal */ 265 0x02, 0x60, /* 2: 24bit I2S */ 266 0x03, 0x01, /* 3: deemphasis off */ 267 0x04, 0x00, /* 4: LIN muted */ 268 0x05, 0x00, /* 5: RIN muted */ 269 0x06, 0x00, /* 6: LOUT muted */ 270 0x07, 0x00, /* 7: ROUT muted */ 271 0xff, 0xff 272 }; 273 274 int chip; 275 const unsigned char *ptr, *inits; 276 unsigned char reg, data; 277 278 memset(ak->images, 0, sizeof(ak->images)); 279 memset(ak->volumes, 0, sizeof(ak->volumes)); 280 281 switch (ak->type) { 282 case SND_AK4524: 283 inits = inits_ak4524; 284 ak->num_chips = ak->num_dacs / 2; 285 ak->name = "ak4524"; 286 ak->total_regs = 0x08; 287 break; 288 case SND_AK4528: 289 inits = inits_ak4528; 290 ak->num_chips = ak->num_dacs / 2; 291 ak->name = "ak4528"; 292 ak->total_regs = 0x06; 293 break; 294 case SND_AK4529: 295 inits = inits_ak4529; 296 ak->num_chips = 1; 297 ak->name = "ak4529"; 298 ak->total_regs = 0x0d; 299 break; 300 case SND_AK4355: 301 inits = inits_ak4355; 302 ak->num_chips = 1; 303 ak->name = "ak4355"; 304 ak->total_regs = 0x0b; 305 break; 306 case SND_AK4358: 307 inits = inits_ak4358; 308 ak->num_chips = 1; 309 ak->name = "ak4358"; 310 ak->total_regs = 0x10; 311 break; 312 case SND_AK4381: 313 inits = inits_ak4381; 314 ak->num_chips = ak->num_dacs / 2; 315 ak->name = "ak4381"; 316 ak->total_regs = 0x05; 317 break; 318 case SND_AK5365: 319 /* FIXME: any init sequence? */ 320 ak->num_chips = 1; 321 ak->name = "ak5365"; 322 ak->total_regs = 0x08; 323 return; 324 case SND_AK4620: 325 inits = inits_ak4620; 326 ak->num_chips = ak->num_dacs / 2; 327 ak->name = "ak4620"; 328 ak->total_regs = 0x08; 329 break; 330 default: 331 snd_BUG(); 332 return; 333 } 334 335 for (chip = 0; chip < ak->num_chips; chip++) { 336 ptr = inits; 337 while (*ptr != 0xff) { 338 reg = *ptr++; 339 data = *ptr++; 340 snd_akm4xxx_write(ak, chip, reg, data); 341 udelay(10); 342 } 343 } 344 } 345 346 EXPORT_SYMBOL(snd_akm4xxx_init); 347 348 /* 349 * Mixer callbacks 350 */ 351 #define AK_IPGA (1<<20) /* including IPGA */ 352 #define AK_VOL_CVT (1<<21) /* need dB conversion */ 353 #define AK_NEEDSMSB (1<<22) /* need MSB update bit */ 354 #define AK_INVERT (1<<23) /* data is inverted */ 355 #define AK_GET_CHIP(val) (((val) >> 8) & 0xff) 356 #define AK_GET_ADDR(val) ((val) & 0xff) 357 #define AK_GET_SHIFT(val) (((val) >> 16) & 0x0f) 358 #define AK_GET_VOL_CVT(val) (((val) >> 21) & 1) 359 #define AK_GET_IPGA(val) (((val) >> 20) & 1) 360 #define AK_GET_NEEDSMSB(val) (((val) >> 22) & 1) 361 #define AK_GET_INVERT(val) (((val) >> 23) & 1) 362 #define AK_GET_MASK(val) (((val) >> 24) & 0xff) 363 #define AK_COMPOSE(chip,addr,shift,mask) \ 364 (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24)) 365 366 static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol, 367 struct snd_ctl_elem_info *uinfo) 368 { 369 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 370 371 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 372 uinfo->count = 1; 373 uinfo->value.integer.min = 0; 374 uinfo->value.integer.max = mask; 375 return 0; 376 } 377 378 static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol, 379 struct snd_ctl_elem_value *ucontrol) 380 { 381 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 382 int chip = AK_GET_CHIP(kcontrol->private_value); 383 int addr = AK_GET_ADDR(kcontrol->private_value); 384 385 ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr); 386 return 0; 387 } 388 389 static int put_ak_reg(struct snd_kcontrol *kcontrol, int addr, 390 unsigned char nval) 391 { 392 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 393 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 394 int chip = AK_GET_CHIP(kcontrol->private_value); 395 396 if (snd_akm4xxx_get_vol(ak, chip, addr) == nval) 397 return 0; 398 399 snd_akm4xxx_set_vol(ak, chip, addr, nval); 400 if (AK_GET_VOL_CVT(kcontrol->private_value) && nval < 128) 401 nval = vol_cvt_datt[nval]; 402 if (AK_GET_IPGA(kcontrol->private_value) && nval >= 128) 403 nval++; /* need to correct + 1 since both 127 and 128 are 0dB */ 404 if (AK_GET_INVERT(kcontrol->private_value)) 405 nval = mask - nval; 406 if (AK_GET_NEEDSMSB(kcontrol->private_value)) 407 nval |= 0x80; 408 /* printk(KERN_DEBUG "DEBUG - AK writing reg: chip %x addr %x, 409 nval %x\n", chip, addr, nval); */ 410 snd_akm4xxx_write(ak, chip, addr, nval); 411 return 1; 412 } 413 414 static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol, 415 struct snd_ctl_elem_value *ucontrol) 416 { 417 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 418 unsigned int val = ucontrol->value.integer.value[0]; 419 if (val > mask) 420 return -EINVAL; 421 return put_ak_reg(kcontrol, AK_GET_ADDR(kcontrol->private_value), val); 422 } 423 424 static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol *kcontrol, 425 struct snd_ctl_elem_info *uinfo) 426 { 427 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 428 429 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 430 uinfo->count = 2; 431 uinfo->value.integer.min = 0; 432 uinfo->value.integer.max = mask; 433 return 0; 434 } 435 436 static int snd_akm4xxx_stereo_volume_get(struct snd_kcontrol *kcontrol, 437 struct snd_ctl_elem_value *ucontrol) 438 { 439 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 440 int chip = AK_GET_CHIP(kcontrol->private_value); 441 int addr = AK_GET_ADDR(kcontrol->private_value); 442 443 ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr); 444 ucontrol->value.integer.value[1] = snd_akm4xxx_get_vol(ak, chip, addr+1); 445 return 0; 446 } 447 448 static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol *kcontrol, 449 struct snd_ctl_elem_value *ucontrol) 450 { 451 int addr = AK_GET_ADDR(kcontrol->private_value); 452 unsigned int mask = AK_GET_MASK(kcontrol->private_value); 453 unsigned int val[2]; 454 int change; 455 456 val[0] = ucontrol->value.integer.value[0]; 457 val[1] = ucontrol->value.integer.value[1]; 458 if (val[0] > mask || val[1] > mask) 459 return -EINVAL; 460 change = put_ak_reg(kcontrol, addr, val[0]); 461 change |= put_ak_reg(kcontrol, addr + 1, val[1]); 462 return change; 463 } 464 465 static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol, 466 struct snd_ctl_elem_info *uinfo) 467 { 468 static const char * const texts[4] = { 469 "44.1kHz", "Off", "48kHz", "32kHz", 470 }; 471 return snd_ctl_enum_info(uinfo, 1, 4, texts); 472 } 473 474 static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol, 475 struct snd_ctl_elem_value *ucontrol) 476 { 477 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 478 int chip = AK_GET_CHIP(kcontrol->private_value); 479 int addr = AK_GET_ADDR(kcontrol->private_value); 480 int shift = AK_GET_SHIFT(kcontrol->private_value); 481 ucontrol->value.enumerated.item[0] = 482 (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3; 483 return 0; 484 } 485 486 static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol, 487 struct snd_ctl_elem_value *ucontrol) 488 { 489 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 490 int chip = AK_GET_CHIP(kcontrol->private_value); 491 int addr = AK_GET_ADDR(kcontrol->private_value); 492 int shift = AK_GET_SHIFT(kcontrol->private_value); 493 unsigned char nval = ucontrol->value.enumerated.item[0] & 3; 494 int change; 495 496 nval = (nval << shift) | 497 (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift)); 498 change = snd_akm4xxx_get(ak, chip, addr) != nval; 499 if (change) 500 snd_akm4xxx_write(ak, chip, addr, nval); 501 return change; 502 } 503 504 #define ak4xxx_switch_info snd_ctl_boolean_mono_info 505 506 static int ak4xxx_switch_get(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 /* we observe the (1<<shift) bit only */ 515 unsigned char val = snd_akm4xxx_get(ak, chip, addr) & (1<<shift); 516 if (invert) 517 val = ! val; 518 ucontrol->value.integer.value[0] = (val & (1<<shift)) != 0; 519 return 0; 520 } 521 522 static int ak4xxx_switch_put(struct snd_kcontrol *kcontrol, 523 struct snd_ctl_elem_value *ucontrol) 524 { 525 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 526 int chip = AK_GET_CHIP(kcontrol->private_value); 527 int addr = AK_GET_ADDR(kcontrol->private_value); 528 int shift = AK_GET_SHIFT(kcontrol->private_value); 529 int invert = AK_GET_INVERT(kcontrol->private_value); 530 long flag = ucontrol->value.integer.value[0]; 531 unsigned char val, oval; 532 int change; 533 534 if (invert) 535 flag = ! flag; 536 oval = snd_akm4xxx_get(ak, chip, addr); 537 if (flag) 538 val = oval | (1<<shift); 539 else 540 val = oval & ~(1<<shift); 541 change = (oval != val); 542 if (change) 543 snd_akm4xxx_write(ak, chip, addr, val); 544 return change; 545 } 546 547 #define AK5365_NUM_INPUTS 5 548 549 static int ak4xxx_capture_num_inputs(struct snd_akm4xxx *ak, int mixer_ch) 550 { 551 int num_names; 552 const char **input_names; 553 554 input_names = ak->adc_info[mixer_ch].input_names; 555 num_names = 0; 556 while (num_names < AK5365_NUM_INPUTS && input_names[num_names]) 557 ++num_names; 558 return num_names; 559 } 560 561 static int ak4xxx_capture_source_info(struct snd_kcontrol *kcontrol, 562 struct snd_ctl_elem_info *uinfo) 563 { 564 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 565 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value); 566 unsigned int num_names; 567 568 num_names = ak4xxx_capture_num_inputs(ak, mixer_ch); 569 if (!num_names) 570 return -EINVAL; 571 return snd_ctl_enum_info(uinfo, 1, num_names, 572 ak->adc_info[mixer_ch].input_names); 573 } 574 575 static int ak4xxx_capture_source_get(struct snd_kcontrol *kcontrol, 576 struct snd_ctl_elem_value *ucontrol) 577 { 578 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 579 int chip = AK_GET_CHIP(kcontrol->private_value); 580 int addr = AK_GET_ADDR(kcontrol->private_value); 581 int mask = AK_GET_MASK(kcontrol->private_value); 582 unsigned char val; 583 584 val = snd_akm4xxx_get(ak, chip, addr) & mask; 585 ucontrol->value.enumerated.item[0] = val; 586 return 0; 587 } 588 589 static int ak4xxx_capture_source_put(struct snd_kcontrol *kcontrol, 590 struct snd_ctl_elem_value *ucontrol) 591 { 592 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); 593 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value); 594 int chip = AK_GET_CHIP(kcontrol->private_value); 595 int addr = AK_GET_ADDR(kcontrol->private_value); 596 int mask = AK_GET_MASK(kcontrol->private_value); 597 unsigned char oval, val; 598 int num_names = ak4xxx_capture_num_inputs(ak, mixer_ch); 599 600 if (ucontrol->value.enumerated.item[0] >= num_names) 601 return -EINVAL; 602 603 oval = snd_akm4xxx_get(ak, chip, addr); 604 val = oval & ~mask; 605 val |= ucontrol->value.enumerated.item[0] & mask; 606 if (val != oval) { 607 snd_akm4xxx_write(ak, chip, addr, val); 608 return 1; 609 } 610 return 0; 611 } 612 613 /* 614 * build AK4xxx controls 615 */ 616 617 static int build_dac_controls(struct snd_akm4xxx *ak) 618 { 619 int idx, err, mixer_ch, num_stereo; 620 struct snd_kcontrol_new knew; 621 622 mixer_ch = 0; 623 for (idx = 0; idx < ak->num_dacs; ) { 624 /* mute control for Revolution 7.1 - AK4381 */ 625 if (ak->type == SND_AK4381 626 && ak->dac_info[mixer_ch].switch_name) { 627 memset(&knew, 0, sizeof(knew)); 628 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 629 knew.count = 1; 630 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE; 631 knew.name = ak->dac_info[mixer_ch].switch_name; 632 knew.info = ak4xxx_switch_info; 633 knew.get = ak4xxx_switch_get; 634 knew.put = ak4xxx_switch_put; 635 knew.access = 0; 636 /* register 1, bit 0 (SMUTE): 0 = normal operation, 637 1 = mute */ 638 knew.private_value = 639 AK_COMPOSE(idx/2, 1, 0, 0) | AK_INVERT; 640 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 641 if (err < 0) 642 return err; 643 } 644 memset(&knew, 0, sizeof(knew)); 645 if (! ak->dac_info || ! ak->dac_info[mixer_ch].name) { 646 knew.name = "DAC Volume"; 647 knew.index = mixer_ch + ak->idx_offset * 2; 648 num_stereo = 1; 649 } else { 650 knew.name = ak->dac_info[mixer_ch].name; 651 num_stereo = ak->dac_info[mixer_ch].num_channels; 652 } 653 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 654 knew.count = 1; 655 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 656 SNDRV_CTL_ELEM_ACCESS_TLV_READ; 657 if (num_stereo == 2) { 658 knew.info = snd_akm4xxx_stereo_volume_info; 659 knew.get = snd_akm4xxx_stereo_volume_get; 660 knew.put = snd_akm4xxx_stereo_volume_put; 661 } else { 662 knew.info = snd_akm4xxx_volume_info; 663 knew.get = snd_akm4xxx_volume_get; 664 knew.put = snd_akm4xxx_volume_put; 665 } 666 switch (ak->type) { 667 case SND_AK4524: 668 /* register 6 & 7 */ 669 knew.private_value = 670 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127) | 671 AK_VOL_CVT; 672 knew.tlv.p = db_scale_vol_datt; 673 break; 674 case SND_AK4528: 675 /* register 4 & 5 */ 676 knew.private_value = 677 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127) | 678 AK_VOL_CVT; 679 knew.tlv.p = db_scale_vol_datt; 680 break; 681 case SND_AK4529: { 682 /* registers 2-7 and b,c */ 683 int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb; 684 knew.private_value = 685 AK_COMPOSE(0, val, 0, 255) | AK_INVERT; 686 knew.tlv.p = db_scale_8bit; 687 break; 688 } 689 case SND_AK4355: 690 /* register 4-9, chip #0 only */ 691 knew.private_value = AK_COMPOSE(0, idx + 4, 0, 255); 692 knew.tlv.p = db_scale_8bit; 693 break; 694 case SND_AK4358: { 695 /* register 4-9 and 11-12, chip #0 only */ 696 int addr = idx < 6 ? idx + 4 : idx + 5; 697 knew.private_value = 698 AK_COMPOSE(0, addr, 0, 127) | AK_NEEDSMSB; 699 knew.tlv.p = db_scale_7bit; 700 break; 701 } 702 case SND_AK4381: 703 /* register 3 & 4 */ 704 knew.private_value = 705 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255); 706 knew.tlv.p = db_scale_linear; 707 break; 708 case SND_AK4620: 709 /* register 6 & 7 */ 710 knew.private_value = 711 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255); 712 knew.tlv.p = db_scale_linear; 713 break; 714 default: 715 return -EINVAL; 716 } 717 718 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 719 if (err < 0) 720 return err; 721 722 idx += num_stereo; 723 mixer_ch++; 724 } 725 return 0; 726 } 727 728 static int build_adc_controls(struct snd_akm4xxx *ak) 729 { 730 int idx, err, mixer_ch, num_stereo, max_steps; 731 struct snd_kcontrol_new knew; 732 733 mixer_ch = 0; 734 if (ak->type == SND_AK4528) 735 return 0; /* no controls */ 736 for (idx = 0; idx < ak->num_adcs;) { 737 memset(&knew, 0, sizeof(knew)); 738 if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) { 739 knew.name = "ADC Volume"; 740 knew.index = mixer_ch + ak->idx_offset * 2; 741 num_stereo = 1; 742 } else { 743 knew.name = ak->adc_info[mixer_ch].name; 744 num_stereo = ak->adc_info[mixer_ch].num_channels; 745 } 746 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 747 knew.count = 1; 748 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 749 SNDRV_CTL_ELEM_ACCESS_TLV_READ; 750 if (num_stereo == 2) { 751 knew.info = snd_akm4xxx_stereo_volume_info; 752 knew.get = snd_akm4xxx_stereo_volume_get; 753 knew.put = snd_akm4xxx_stereo_volume_put; 754 } else { 755 knew.info = snd_akm4xxx_volume_info; 756 knew.get = snd_akm4xxx_volume_get; 757 knew.put = snd_akm4xxx_volume_put; 758 } 759 /* register 4 & 5 */ 760 if (ak->type == SND_AK5365) 761 max_steps = 152; 762 else 763 max_steps = 164; 764 knew.private_value = 765 AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) | 766 AK_VOL_CVT | AK_IPGA; 767 knew.tlv.p = db_scale_vol_datt; 768 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 769 if (err < 0) 770 return err; 771 772 if (ak->type == SND_AK5365 && (idx % 2) == 0) { 773 if (! ak->adc_info || 774 ! ak->adc_info[mixer_ch].switch_name) { 775 knew.name = "Capture Switch"; 776 knew.index = mixer_ch + ak->idx_offset * 2; 777 } else 778 knew.name = ak->adc_info[mixer_ch].switch_name; 779 knew.info = ak4xxx_switch_info; 780 knew.get = ak4xxx_switch_get; 781 knew.put = ak4xxx_switch_put; 782 knew.access = 0; 783 /* register 2, bit 0 (SMUTE): 0 = normal operation, 784 1 = mute */ 785 knew.private_value = 786 AK_COMPOSE(idx/2, 2, 0, 0) | AK_INVERT; 787 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 788 if (err < 0) 789 return err; 790 791 memset(&knew, 0, sizeof(knew)); 792 knew.name = ak->adc_info[mixer_ch].selector_name; 793 if (!knew.name) { 794 knew.name = "Capture Channel"; 795 knew.index = mixer_ch + ak->idx_offset * 2; 796 } 797 798 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 799 knew.info = ak4xxx_capture_source_info; 800 knew.get = ak4xxx_capture_source_get; 801 knew.put = ak4xxx_capture_source_put; 802 knew.access = 0; 803 /* input selector control: reg. 1, bits 0-2. 804 * mis-use 'shift' to pass mixer_ch */ 805 knew.private_value 806 = AK_COMPOSE(idx/2, 1, mixer_ch, 0x07); 807 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 808 if (err < 0) 809 return err; 810 } 811 812 idx += num_stereo; 813 mixer_ch++; 814 } 815 return 0; 816 } 817 818 static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs) 819 { 820 int idx, err; 821 struct snd_kcontrol_new knew; 822 823 for (idx = 0; idx < num_emphs; idx++) { 824 memset(&knew, 0, sizeof(knew)); 825 knew.name = "Deemphasis"; 826 knew.index = idx + ak->idx_offset; 827 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 828 knew.count = 1; 829 knew.info = snd_akm4xxx_deemphasis_info; 830 knew.get = snd_akm4xxx_deemphasis_get; 831 knew.put = snd_akm4xxx_deemphasis_put; 832 switch (ak->type) { 833 case SND_AK4524: 834 case SND_AK4528: 835 case SND_AK4620: 836 /* register 3 */ 837 knew.private_value = AK_COMPOSE(idx, 3, 0, 0); 838 break; 839 case SND_AK4529: { 840 int shift = idx == 3 ? 6 : (2 - idx) * 2; 841 /* register 8 with shift */ 842 knew.private_value = AK_COMPOSE(0, 8, shift, 0); 843 break; 844 } 845 case SND_AK4355: 846 case SND_AK4358: 847 knew.private_value = AK_COMPOSE(idx, 3, 0, 0); 848 break; 849 case SND_AK4381: 850 knew.private_value = AK_COMPOSE(idx, 1, 1, 0); 851 break; 852 default: 853 return -EINVAL; 854 } 855 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); 856 if (err < 0) 857 return err; 858 } 859 return 0; 860 } 861 862 static void proc_regs_read(struct snd_info_entry *entry, 863 struct snd_info_buffer *buffer) 864 { 865 struct snd_akm4xxx *ak = entry->private_data; 866 int reg, val, chip; 867 for (chip = 0; chip < ak->num_chips; chip++) { 868 for (reg = 0; reg < ak->total_regs; reg++) { 869 val = snd_akm4xxx_get(ak, chip, reg); 870 snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip, 871 reg, val); 872 } 873 } 874 } 875 876 static int proc_init(struct snd_akm4xxx *ak) 877 { 878 struct snd_info_entry *entry; 879 int err; 880 err = snd_card_proc_new(ak->card, ak->name, &entry); 881 if (err < 0) 882 return err; 883 snd_info_set_text_ops(entry, ak, proc_regs_read); 884 return 0; 885 } 886 887 int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) 888 { 889 int err, num_emphs; 890 891 err = build_dac_controls(ak); 892 if (err < 0) 893 return err; 894 895 err = build_adc_controls(ak); 896 if (err < 0) 897 return err; 898 if (ak->type == SND_AK4355 || ak->type == SND_AK4358) 899 num_emphs = 1; 900 else if (ak->type == SND_AK4620) 901 num_emphs = 0; 902 else 903 num_emphs = ak->num_dacs / 2; 904 err = build_deemphasis(ak, num_emphs); 905 if (err < 0) 906 return err; 907 err = proc_init(ak); 908 if (err < 0) 909 return err; 910 911 return 0; 912 } 913 EXPORT_SYMBOL(snd_akm4xxx_build_controls); 914