1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>, 4 * Takashi Iwai <tiwai@suse.de> 5 * Creative Labs, Inc. 6 * Routines for control of EMU10K1 chips / mixer routines 7 * Multichannel PCM support Copyright (c) Lee Revell <rlrevell@joe-job.com> 8 * 9 * Copyright (c) by James Courtier-Dutton <James@superbug.co.uk> 10 * Added EMU 1010 support. 11 * 12 * BUGS: 13 * -- 14 * 15 * TODO: 16 * -- 17 */ 18 19 #include <linux/time.h> 20 #include <linux/init.h> 21 #include <sound/core.h> 22 #include <sound/emu10k1.h> 23 #include <linux/delay.h> 24 #include <sound/tlv.h> 25 26 #include "p17v.h" 27 28 #define AC97_ID_STAC9758 0x83847658 29 30 static const DECLARE_TLV_DB_SCALE(snd_audigy_db_scale2, -10350, 50, 1); /* WM8775 gain scale */ 31 32 33 static int add_ctls(struct snd_emu10k1 *emu, const struct snd_kcontrol_new *tpl, 34 const char * const *ctls, unsigned nctls) 35 { 36 struct snd_kcontrol_new kctl = *tpl; 37 int err; 38 39 for (unsigned i = 0; i < nctls; i++) { 40 kctl.name = ctls[i]; 41 kctl.private_value = i; 42 err = snd_ctl_add(emu->card, snd_ctl_new1(&kctl, emu)); 43 if (err < 0) 44 return err; 45 } 46 return 0; 47 } 48 49 50 static int snd_emu10k1_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 51 { 52 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 53 uinfo->count = 1; 54 return 0; 55 } 56 57 static int snd_emu10k1_spdif_get(struct snd_kcontrol *kcontrol, 58 struct snd_ctl_elem_value *ucontrol) 59 { 60 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 61 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 62 63 /* Limit: emu->spdif_bits */ 64 if (idx >= 3) 65 return -EINVAL; 66 ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff; 67 ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff; 68 ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff; 69 ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff; 70 return 0; 71 } 72 73 static int snd_emu10k1_spdif_get_mask(struct snd_kcontrol *kcontrol, 74 struct snd_ctl_elem_value *ucontrol) 75 { 76 ucontrol->value.iec958.status[0] = 0xff; 77 ucontrol->value.iec958.status[1] = 0xff; 78 ucontrol->value.iec958.status[2] = 0xff; 79 ucontrol->value.iec958.status[3] = 0xff; 80 return 0; 81 } 82 83 #define PAIR_PS(base, one, two, sfx) base " " one sfx, base " " two sfx 84 #define LR_PS(base, sfx) PAIR_PS(base, "Left", "Right", sfx) 85 86 #define ADAT_PS(pfx, sfx) \ 87 pfx "ADAT 0" sfx, pfx "ADAT 1" sfx, pfx "ADAT 2" sfx, pfx "ADAT 3" sfx, \ 88 pfx "ADAT 4" sfx, pfx "ADAT 5" sfx, pfx "ADAT 6" sfx, pfx "ADAT 7" sfx 89 90 #define PAIR_REGS(base, one, two) \ 91 base ## one ## 1, \ 92 base ## two ## 1 93 94 #define LR_REGS(base) PAIR_REGS(base, _LEFT, _RIGHT) 95 96 #define ADAT_REGS(base) \ 97 base+0, base+1, base+2, base+3, base+4, base+5, base+6, base+7 98 99 /* 100 * List of data sources available for each destination 101 */ 102 103 #define DSP_TEXTS \ 104 "DSP 0", "DSP 1", "DSP 2", "DSP 3", "DSP 4", "DSP 5", "DSP 6", "DSP 7", \ 105 "DSP 8", "DSP 9", "DSP 10", "DSP 11", "DSP 12", "DSP 13", "DSP 14", "DSP 15", \ 106 "DSP 16", "DSP 17", "DSP 18", "DSP 19", "DSP 20", "DSP 21", "DSP 22", "DSP 23", \ 107 "DSP 24", "DSP 25", "DSP 26", "DSP 27", "DSP 28", "DSP 29", "DSP 30", "DSP 31" 108 109 #define PAIR_TEXTS(base, one, two) PAIR_PS(base, one, two, "") 110 #define LR_TEXTS(base) LR_PS(base, "") 111 #define ADAT_TEXTS(pfx) ADAT_PS(pfx, "") 112 113 #define EMU32_SRC_REGS \ 114 EMU_SRC_ALICE_EMU32A, \ 115 EMU_SRC_ALICE_EMU32A+1, \ 116 EMU_SRC_ALICE_EMU32A+2, \ 117 EMU_SRC_ALICE_EMU32A+3, \ 118 EMU_SRC_ALICE_EMU32A+4, \ 119 EMU_SRC_ALICE_EMU32A+5, \ 120 EMU_SRC_ALICE_EMU32A+6, \ 121 EMU_SRC_ALICE_EMU32A+7, \ 122 EMU_SRC_ALICE_EMU32A+8, \ 123 EMU_SRC_ALICE_EMU32A+9, \ 124 EMU_SRC_ALICE_EMU32A+0xa, \ 125 EMU_SRC_ALICE_EMU32A+0xb, \ 126 EMU_SRC_ALICE_EMU32A+0xc, \ 127 EMU_SRC_ALICE_EMU32A+0xd, \ 128 EMU_SRC_ALICE_EMU32A+0xe, \ 129 EMU_SRC_ALICE_EMU32A+0xf, \ 130 EMU_SRC_ALICE_EMU32B, \ 131 EMU_SRC_ALICE_EMU32B+1, \ 132 EMU_SRC_ALICE_EMU32B+2, \ 133 EMU_SRC_ALICE_EMU32B+3, \ 134 EMU_SRC_ALICE_EMU32B+4, \ 135 EMU_SRC_ALICE_EMU32B+5, \ 136 EMU_SRC_ALICE_EMU32B+6, \ 137 EMU_SRC_ALICE_EMU32B+7, \ 138 EMU_SRC_ALICE_EMU32B+8, \ 139 EMU_SRC_ALICE_EMU32B+9, \ 140 EMU_SRC_ALICE_EMU32B+0xa, \ 141 EMU_SRC_ALICE_EMU32B+0xb, \ 142 EMU_SRC_ALICE_EMU32B+0xc, \ 143 EMU_SRC_ALICE_EMU32B+0xd, \ 144 EMU_SRC_ALICE_EMU32B+0xe, \ 145 EMU_SRC_ALICE_EMU32B+0xf 146 147 /* 1010 rev1 */ 148 149 #define EMU1010_COMMON_TEXTS \ 150 "Silence", \ 151 PAIR_TEXTS("Dock Mic", "A", "B"), \ 152 LR_TEXTS("Dock ADC1"), \ 153 LR_TEXTS("Dock ADC2"), \ 154 LR_TEXTS("Dock ADC3"), \ 155 LR_TEXTS("0202 ADC"), \ 156 LR_TEXTS("1010 SPDIF"), \ 157 ADAT_TEXTS("1010 ") 158 159 static const char * const emu1010_src_texts[] = { 160 EMU1010_COMMON_TEXTS, 161 DSP_TEXTS, 162 }; 163 164 static const unsigned short emu1010_src_regs[] = { 165 EMU_SRC_SILENCE, 166 PAIR_REGS(EMU_SRC_DOCK_MIC, _A, _B), 167 LR_REGS(EMU_SRC_DOCK_ADC1), 168 LR_REGS(EMU_SRC_DOCK_ADC2), 169 LR_REGS(EMU_SRC_DOCK_ADC3), 170 LR_REGS(EMU_SRC_HAMOA_ADC), 171 LR_REGS(EMU_SRC_HANA_SPDIF), 172 ADAT_REGS(EMU_SRC_HANA_ADAT), 173 EMU32_SRC_REGS, 174 }; 175 static_assert(ARRAY_SIZE(emu1010_src_regs) == ARRAY_SIZE(emu1010_src_texts)); 176 177 /* 1010 rev2 */ 178 179 #define EMU1010b_COMMON_TEXTS \ 180 "Silence", \ 181 PAIR_TEXTS("Dock Mic", "A", "B"), \ 182 LR_TEXTS("Dock ADC1"), \ 183 LR_TEXTS("Dock ADC2"), \ 184 LR_TEXTS("0202 ADC"), \ 185 LR_TEXTS("Dock SPDIF"), \ 186 LR_TEXTS("1010 SPDIF"), \ 187 ADAT_TEXTS("Dock "), \ 188 ADAT_TEXTS("1010 ") 189 190 static const char * const emu1010b_src_texts[] = { 191 EMU1010b_COMMON_TEXTS, 192 DSP_TEXTS, 193 }; 194 195 static const unsigned short emu1010b_src_regs[] = { 196 EMU_SRC_SILENCE, 197 PAIR_REGS(EMU_SRC_DOCK_MIC, _A, _B), 198 LR_REGS(EMU_SRC_DOCK_ADC1), 199 LR_REGS(EMU_SRC_DOCK_ADC2), 200 LR_REGS(EMU_SRC_HAMOA_ADC), 201 LR_REGS(EMU_SRC_MDOCK_SPDIF), 202 LR_REGS(EMU_SRC_HANA_SPDIF), 203 ADAT_REGS(EMU_SRC_MDOCK_ADAT), 204 ADAT_REGS(EMU_SRC_HANA_ADAT), 205 EMU32_SRC_REGS, 206 }; 207 static_assert(ARRAY_SIZE(emu1010b_src_regs) == ARRAY_SIZE(emu1010b_src_texts)); 208 209 /* 1616(m) cardbus */ 210 211 #define EMU1616_COMMON_TEXTS \ 212 "Silence", \ 213 PAIR_TEXTS("Mic", "A", "B"), \ 214 LR_TEXTS("ADC1"), \ 215 LR_TEXTS("ADC2"), \ 216 LR_TEXTS("SPDIF"), \ 217 ADAT_TEXTS("") 218 219 static const char * const emu1616_src_texts[] = { 220 EMU1616_COMMON_TEXTS, 221 DSP_TEXTS, 222 }; 223 224 static const unsigned short emu1616_src_regs[] = { 225 EMU_SRC_SILENCE, 226 PAIR_REGS(EMU_SRC_DOCK_MIC, _A, _B), 227 LR_REGS(EMU_SRC_DOCK_ADC1), 228 LR_REGS(EMU_SRC_DOCK_ADC2), 229 LR_REGS(EMU_SRC_MDOCK_SPDIF), 230 ADAT_REGS(EMU_SRC_MDOCK_ADAT), 231 EMU32_SRC_REGS, 232 }; 233 static_assert(ARRAY_SIZE(emu1616_src_regs) == ARRAY_SIZE(emu1616_src_texts)); 234 235 /* 0404 rev1 & rev2 */ 236 237 #define EMU0404_COMMON_TEXTS \ 238 "Silence", \ 239 LR_TEXTS("ADC"), \ 240 LR_TEXTS("SPDIF") 241 242 static const char * const emu0404_src_texts[] = { 243 EMU0404_COMMON_TEXTS, 244 DSP_TEXTS, 245 }; 246 247 static const unsigned short emu0404_src_regs[] = { 248 EMU_SRC_SILENCE, 249 LR_REGS(EMU_SRC_HAMOA_ADC), 250 LR_REGS(EMU_SRC_HANA_SPDIF), 251 EMU32_SRC_REGS, 252 }; 253 static_assert(ARRAY_SIZE(emu0404_src_regs) == ARRAY_SIZE(emu0404_src_texts)); 254 255 /* 256 * Data destinations - physical EMU outputs. 257 * Each destination has an enum mixer control to choose a data source 258 */ 259 260 #define LR_CTLS(base) LR_PS(base, " Playback Enum") 261 #define ADAT_CTLS(pfx) ADAT_PS(pfx, " Playback Enum") 262 263 /* 1010 rev1 */ 264 265 static const char * const emu1010_output_texts[] = { 266 LR_CTLS("Dock DAC1"), 267 LR_CTLS("Dock DAC2"), 268 LR_CTLS("Dock DAC3"), 269 LR_CTLS("Dock DAC4"), 270 LR_CTLS("Dock Phones"), 271 LR_CTLS("Dock SPDIF"), 272 LR_CTLS("0202 DAC"), 273 LR_CTLS("1010 SPDIF"), 274 ADAT_CTLS("1010 "), 275 }; 276 static_assert(ARRAY_SIZE(emu1010_output_texts) <= NUM_OUTPUT_DESTS); 277 278 static const unsigned short emu1010_output_dst[] = { 279 LR_REGS(EMU_DST_DOCK_DAC1), 280 LR_REGS(EMU_DST_DOCK_DAC2), 281 LR_REGS(EMU_DST_DOCK_DAC3), 282 LR_REGS(EMU_DST_DOCK_DAC4), 283 LR_REGS(EMU_DST_DOCK_PHONES), 284 LR_REGS(EMU_DST_DOCK_SPDIF), 285 LR_REGS(EMU_DST_HAMOA_DAC), 286 LR_REGS(EMU_DST_HANA_SPDIF), 287 ADAT_REGS(EMU_DST_HANA_ADAT), 288 }; 289 static_assert(ARRAY_SIZE(emu1010_output_dst) == ARRAY_SIZE(emu1010_output_texts)); 290 291 static const unsigned short emu1010_output_dflt[] = { 292 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 293 EMU_SRC_ALICE_EMU32A+2, EMU_SRC_ALICE_EMU32A+3, 294 EMU_SRC_ALICE_EMU32A+4, EMU_SRC_ALICE_EMU32A+5, 295 EMU_SRC_ALICE_EMU32A+6, EMU_SRC_ALICE_EMU32A+7, 296 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 297 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 298 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 299 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 300 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, EMU_SRC_ALICE_EMU32A+2, EMU_SRC_ALICE_EMU32A+3, 301 EMU_SRC_ALICE_EMU32A+4, EMU_SRC_ALICE_EMU32A+5, EMU_SRC_ALICE_EMU32A+6, EMU_SRC_ALICE_EMU32A+7, 302 }; 303 static_assert(ARRAY_SIZE(emu1010_output_dflt) == ARRAY_SIZE(emu1010_output_dst)); 304 305 /* 1010 rev2 */ 306 307 static const char * const snd_emu1010b_output_texts[] = { 308 LR_CTLS("Dock DAC1"), 309 LR_CTLS("Dock DAC2"), 310 LR_CTLS("Dock DAC3"), 311 LR_CTLS("Dock SPDIF"), 312 ADAT_CTLS("Dock "), 313 LR_CTLS("0202 DAC"), 314 LR_CTLS("1010 SPDIF"), 315 ADAT_CTLS("1010 "), 316 }; 317 static_assert(ARRAY_SIZE(snd_emu1010b_output_texts) <= NUM_OUTPUT_DESTS); 318 319 static const unsigned short emu1010b_output_dst[] = { 320 LR_REGS(EMU_DST_DOCK_DAC1), 321 LR_REGS(EMU_DST_DOCK_DAC2), 322 LR_REGS(EMU_DST_DOCK_DAC3), 323 LR_REGS(EMU_DST_MDOCK_SPDIF), 324 ADAT_REGS(EMU_DST_MDOCK_ADAT), 325 LR_REGS(EMU_DST_HAMOA_DAC), 326 LR_REGS(EMU_DST_HANA_SPDIF), 327 ADAT_REGS(EMU_DST_HANA_ADAT), 328 }; 329 static_assert(ARRAY_SIZE(emu1010b_output_dst) == ARRAY_SIZE(snd_emu1010b_output_texts)); 330 331 static const unsigned short emu1010b_output_dflt[] = { 332 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 333 EMU_SRC_ALICE_EMU32A+2, EMU_SRC_ALICE_EMU32A+3, 334 EMU_SRC_ALICE_EMU32A+4, EMU_SRC_ALICE_EMU32A+5, 335 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 336 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, EMU_SRC_ALICE_EMU32A+2, EMU_SRC_ALICE_EMU32A+3, 337 EMU_SRC_ALICE_EMU32A+4, EMU_SRC_ALICE_EMU32A+5, EMU_SRC_ALICE_EMU32A+6, EMU_SRC_ALICE_EMU32A+7, 338 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 339 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 340 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, EMU_SRC_ALICE_EMU32A+2, EMU_SRC_ALICE_EMU32A+3, 341 EMU_SRC_ALICE_EMU32A+4, EMU_SRC_ALICE_EMU32A+5, EMU_SRC_ALICE_EMU32A+6, EMU_SRC_ALICE_EMU32A+7, 342 }; 343 344 /* 1616(m) cardbus */ 345 346 static const char * const snd_emu1616_output_texts[] = { 347 LR_CTLS("Dock DAC1"), 348 LR_CTLS("Dock DAC2"), 349 LR_CTLS("Dock DAC3"), 350 LR_CTLS("Dock SPDIF"), 351 ADAT_CTLS("Dock "), 352 LR_CTLS("Mana DAC"), 353 }; 354 static_assert(ARRAY_SIZE(snd_emu1616_output_texts) <= NUM_OUTPUT_DESTS); 355 356 static const unsigned short emu1616_output_dst[] = { 357 LR_REGS(EMU_DST_DOCK_DAC1), 358 LR_REGS(EMU_DST_DOCK_DAC2), 359 LR_REGS(EMU_DST_DOCK_DAC3), 360 LR_REGS(EMU_DST_MDOCK_SPDIF), 361 ADAT_REGS(EMU_DST_MDOCK_ADAT), 362 EMU_DST_MANA_DAC_LEFT, EMU_DST_MANA_DAC_RIGHT, 363 }; 364 static_assert(ARRAY_SIZE(emu1616_output_dst) == ARRAY_SIZE(snd_emu1616_output_texts)); 365 366 static const unsigned short emu1616_output_dflt[] = { 367 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 368 EMU_SRC_ALICE_EMU32A+2, EMU_SRC_ALICE_EMU32A+3, 369 EMU_SRC_ALICE_EMU32A+4, EMU_SRC_ALICE_EMU32A+5, 370 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 371 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, EMU_SRC_ALICE_EMU32A+2, EMU_SRC_ALICE_EMU32A+3, 372 EMU_SRC_ALICE_EMU32A+4, EMU_SRC_ALICE_EMU32A+5, EMU_SRC_ALICE_EMU32A+6, EMU_SRC_ALICE_EMU32A+7, 373 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 374 }; 375 static_assert(ARRAY_SIZE(emu1616_output_dflt) == ARRAY_SIZE(emu1616_output_dst)); 376 377 /* 0404 rev1 & rev2 */ 378 379 static const char * const snd_emu0404_output_texts[] = { 380 LR_CTLS("DAC"), 381 LR_CTLS("SPDIF"), 382 }; 383 static_assert(ARRAY_SIZE(snd_emu0404_output_texts) <= NUM_OUTPUT_DESTS); 384 385 static const unsigned short emu0404_output_dst[] = { 386 LR_REGS(EMU_DST_HAMOA_DAC), 387 LR_REGS(EMU_DST_HANA_SPDIF), 388 }; 389 static_assert(ARRAY_SIZE(emu0404_output_dst) == ARRAY_SIZE(snd_emu0404_output_texts)); 390 391 static const unsigned short emu0404_output_dflt[] = { 392 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 393 EMU_SRC_ALICE_EMU32A+0, EMU_SRC_ALICE_EMU32A+1, 394 }; 395 static_assert(ARRAY_SIZE(emu0404_output_dflt) == ARRAY_SIZE(emu0404_output_dst)); 396 397 /* 398 * Data destinations - FPGA outputs going to Alice2 (Audigy) for 399 * capture (EMU32 + I2S links) 400 * Each destination has an enum mixer control to choose a data source 401 */ 402 403 static const char * const emu1010_input_texts[] = { 404 "DSP 0 Capture Enum", 405 "DSP 1 Capture Enum", 406 "DSP 2 Capture Enum", 407 "DSP 3 Capture Enum", 408 "DSP 4 Capture Enum", 409 "DSP 5 Capture Enum", 410 "DSP 6 Capture Enum", 411 "DSP 7 Capture Enum", 412 "DSP 8 Capture Enum", 413 "DSP 9 Capture Enum", 414 "DSP A Capture Enum", 415 "DSP B Capture Enum", 416 "DSP C Capture Enum", 417 "DSP D Capture Enum", 418 "DSP E Capture Enum", 419 "DSP F Capture Enum", 420 /* These exist only on rev1 EMU1010 cards. */ 421 "DSP 10 Capture Enum", 422 "DSP 11 Capture Enum", 423 "DSP 12 Capture Enum", 424 "DSP 13 Capture Enum", 425 "DSP 14 Capture Enum", 426 "DSP 15 Capture Enum", 427 }; 428 static_assert(ARRAY_SIZE(emu1010_input_texts) <= NUM_INPUT_DESTS); 429 430 static const unsigned short emu1010_input_dst[] = { 431 EMU_DST_ALICE2_EMU32_0, 432 EMU_DST_ALICE2_EMU32_1, 433 EMU_DST_ALICE2_EMU32_2, 434 EMU_DST_ALICE2_EMU32_3, 435 EMU_DST_ALICE2_EMU32_4, 436 EMU_DST_ALICE2_EMU32_5, 437 EMU_DST_ALICE2_EMU32_6, 438 EMU_DST_ALICE2_EMU32_7, 439 EMU_DST_ALICE2_EMU32_8, 440 EMU_DST_ALICE2_EMU32_9, 441 EMU_DST_ALICE2_EMU32_A, 442 EMU_DST_ALICE2_EMU32_B, 443 EMU_DST_ALICE2_EMU32_C, 444 EMU_DST_ALICE2_EMU32_D, 445 EMU_DST_ALICE2_EMU32_E, 446 EMU_DST_ALICE2_EMU32_F, 447 /* These exist only on rev1 EMU1010 cards. */ 448 EMU_DST_ALICE_I2S0_LEFT, 449 EMU_DST_ALICE_I2S0_RIGHT, 450 EMU_DST_ALICE_I2S1_LEFT, 451 EMU_DST_ALICE_I2S1_RIGHT, 452 EMU_DST_ALICE_I2S2_LEFT, 453 EMU_DST_ALICE_I2S2_RIGHT, 454 }; 455 static_assert(ARRAY_SIZE(emu1010_input_dst) == ARRAY_SIZE(emu1010_input_texts)); 456 457 static const unsigned short emu1010_input_dflt[] = { 458 EMU_SRC_DOCK_MIC_A1, 459 EMU_SRC_DOCK_MIC_B1, 460 EMU_SRC_HAMOA_ADC_LEFT1, 461 EMU_SRC_HAMOA_ADC_RIGHT1, 462 EMU_SRC_DOCK_ADC1_LEFT1, 463 EMU_SRC_DOCK_ADC1_RIGHT1, 464 EMU_SRC_DOCK_ADC2_LEFT1, 465 EMU_SRC_DOCK_ADC2_RIGHT1, 466 /* Pavel Hofman - setting defaults for all capture channels. 467 * Defaults only, users will set their own values anyways, let's 468 * just copy/paste. */ 469 EMU_SRC_DOCK_MIC_A1, 470 EMU_SRC_DOCK_MIC_B1, 471 EMU_SRC_HAMOA_ADC_LEFT1, 472 EMU_SRC_HAMOA_ADC_RIGHT1, 473 EMU_SRC_DOCK_ADC1_LEFT1, 474 EMU_SRC_DOCK_ADC1_RIGHT1, 475 EMU_SRC_DOCK_ADC2_LEFT1, 476 EMU_SRC_DOCK_ADC2_RIGHT1, 477 478 EMU_SRC_DOCK_ADC1_LEFT1, 479 EMU_SRC_DOCK_ADC1_RIGHT1, 480 EMU_SRC_DOCK_ADC2_LEFT1, 481 EMU_SRC_DOCK_ADC2_RIGHT1, 482 EMU_SRC_DOCK_ADC3_LEFT1, 483 EMU_SRC_DOCK_ADC3_RIGHT1, 484 }; 485 static_assert(ARRAY_SIZE(emu1010_input_dflt) == ARRAY_SIZE(emu1010_input_dst)); 486 487 static const unsigned short emu0404_input_dflt[] = { 488 EMU_SRC_HAMOA_ADC_LEFT1, 489 EMU_SRC_HAMOA_ADC_RIGHT1, 490 EMU_SRC_SILENCE, 491 EMU_SRC_SILENCE, 492 EMU_SRC_SILENCE, 493 EMU_SRC_SILENCE, 494 EMU_SRC_SILENCE, 495 EMU_SRC_SILENCE, 496 EMU_SRC_HANA_SPDIF_LEFT1, 497 EMU_SRC_HANA_SPDIF_RIGHT1, 498 EMU_SRC_SILENCE, 499 EMU_SRC_SILENCE, 500 EMU_SRC_SILENCE, 501 EMU_SRC_SILENCE, 502 EMU_SRC_SILENCE, 503 EMU_SRC_SILENCE, 504 }; 505 506 struct snd_emu1010_routing_info { 507 const char * const *src_texts; 508 const char * const *out_texts; 509 const unsigned short *src_regs; 510 const unsigned short *out_regs; 511 const unsigned short *in_regs; 512 const unsigned short *out_dflts; 513 const unsigned short *in_dflts; 514 unsigned n_srcs; 515 unsigned n_outs; 516 unsigned n_ins; 517 }; 518 519 static const struct snd_emu1010_routing_info emu1010_routing_info[] = { 520 { 521 /* rev1 1010 */ 522 .src_regs = emu1010_src_regs, 523 .src_texts = emu1010_src_texts, 524 .n_srcs = ARRAY_SIZE(emu1010_src_texts), 525 526 .out_dflts = emu1010_output_dflt, 527 .out_regs = emu1010_output_dst, 528 .out_texts = emu1010_output_texts, 529 .n_outs = ARRAY_SIZE(emu1010_output_dst), 530 531 .in_dflts = emu1010_input_dflt, 532 .in_regs = emu1010_input_dst, 533 .n_ins = ARRAY_SIZE(emu1010_input_dst), 534 }, 535 { 536 /* rev2 1010 */ 537 .src_regs = emu1010b_src_regs, 538 .src_texts = emu1010b_src_texts, 539 .n_srcs = ARRAY_SIZE(emu1010b_src_texts), 540 541 .out_dflts = emu1010b_output_dflt, 542 .out_regs = emu1010b_output_dst, 543 .out_texts = snd_emu1010b_output_texts, 544 .n_outs = ARRAY_SIZE(emu1010b_output_dst), 545 546 .in_dflts = emu1010_input_dflt, 547 .in_regs = emu1010_input_dst, 548 .n_ins = ARRAY_SIZE(emu1010_input_dst) - 6, 549 }, 550 { 551 /* 1616(m) cardbus */ 552 .src_regs = emu1616_src_regs, 553 .src_texts = emu1616_src_texts, 554 .n_srcs = ARRAY_SIZE(emu1616_src_texts), 555 556 .out_dflts = emu1616_output_dflt, 557 .out_regs = emu1616_output_dst, 558 .out_texts = snd_emu1616_output_texts, 559 .n_outs = ARRAY_SIZE(emu1616_output_dst), 560 561 .in_dflts = emu1010_input_dflt, 562 .in_regs = emu1010_input_dst, 563 .n_ins = ARRAY_SIZE(emu1010_input_dst) - 6, 564 }, 565 { 566 /* 0404 */ 567 .src_regs = emu0404_src_regs, 568 .src_texts = emu0404_src_texts, 569 .n_srcs = ARRAY_SIZE(emu0404_src_texts), 570 571 .out_dflts = emu0404_output_dflt, 572 .out_regs = emu0404_output_dst, 573 .out_texts = snd_emu0404_output_texts, 574 .n_outs = ARRAY_SIZE(emu0404_output_dflt), 575 576 .in_dflts = emu0404_input_dflt, 577 .in_regs = emu1010_input_dst, 578 .n_ins = ARRAY_SIZE(emu1010_input_dst) - 6, 579 }, 580 }; 581 582 static unsigned emu1010_idx(struct snd_emu10k1 *emu) 583 { 584 return emu->card_capabilities->emu_model - 1; 585 } 586 587 static void snd_emu1010_output_source_apply(struct snd_emu10k1 *emu, 588 int channel, int src) 589 { 590 const struct snd_emu1010_routing_info *emu_ri = 591 &emu1010_routing_info[emu1010_idx(emu)]; 592 593 snd_emu1010_fpga_link_dst_src_write(emu, 594 emu_ri->out_regs[channel], emu_ri->src_regs[src]); 595 } 596 597 static void snd_emu1010_input_source_apply(struct snd_emu10k1 *emu, 598 int channel, int src) 599 { 600 const struct snd_emu1010_routing_info *emu_ri = 601 &emu1010_routing_info[emu1010_idx(emu)]; 602 603 snd_emu1010_fpga_link_dst_src_write(emu, 604 emu_ri->in_regs[channel], emu_ri->src_regs[src]); 605 } 606 607 static void snd_emu1010_apply_sources(struct snd_emu10k1 *emu) 608 { 609 const struct snd_emu1010_routing_info *emu_ri = 610 &emu1010_routing_info[emu1010_idx(emu)]; 611 612 for (unsigned i = 0; i < emu_ri->n_outs; i++) 613 snd_emu1010_output_source_apply( 614 emu, i, emu->emu1010.output_source[i]); 615 for (unsigned i = 0; i < emu_ri->n_ins; i++) 616 snd_emu1010_input_source_apply( 617 emu, i, emu->emu1010.input_source[i]); 618 } 619 620 static u8 emu1010_map_source(const struct snd_emu1010_routing_info *emu_ri, 621 unsigned val) 622 { 623 for (unsigned i = 0; i < emu_ri->n_srcs; i++) 624 if (val == emu_ri->src_regs[i]) 625 return i; 626 return 0; 627 } 628 629 static int snd_emu1010_input_output_source_info(struct snd_kcontrol *kcontrol, 630 struct snd_ctl_elem_info *uinfo) 631 { 632 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 633 const struct snd_emu1010_routing_info *emu_ri = 634 &emu1010_routing_info[emu1010_idx(emu)]; 635 636 return snd_ctl_enum_info(uinfo, 1, emu_ri->n_srcs, emu_ri->src_texts); 637 } 638 639 static int snd_emu1010_output_source_get(struct snd_kcontrol *kcontrol, 640 struct snd_ctl_elem_value *ucontrol) 641 { 642 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 643 const struct snd_emu1010_routing_info *emu_ri = 644 &emu1010_routing_info[emu1010_idx(emu)]; 645 unsigned channel = kcontrol->private_value; 646 647 if (channel >= emu_ri->n_outs) 648 return -EINVAL; 649 ucontrol->value.enumerated.item[0] = emu->emu1010.output_source[channel]; 650 return 0; 651 } 652 653 static int snd_emu1010_output_source_put(struct snd_kcontrol *kcontrol, 654 struct snd_ctl_elem_value *ucontrol) 655 { 656 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 657 const struct snd_emu1010_routing_info *emu_ri = 658 &emu1010_routing_info[emu1010_idx(emu)]; 659 unsigned val = ucontrol->value.enumerated.item[0]; 660 unsigned channel = kcontrol->private_value; 661 int change; 662 663 if (val >= emu_ri->n_srcs) 664 return -EINVAL; 665 if (channel >= emu_ri->n_outs) 666 return -EINVAL; 667 change = (emu->emu1010.output_source[channel] != val); 668 if (change) { 669 emu->emu1010.output_source[channel] = val; 670 snd_emu1010_output_source_apply(emu, channel, val); 671 } 672 return change; 673 } 674 675 static const struct snd_kcontrol_new emu1010_output_source_ctl = { 676 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 677 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 678 .info = snd_emu1010_input_output_source_info, 679 .get = snd_emu1010_output_source_get, 680 .put = snd_emu1010_output_source_put 681 }; 682 683 static int snd_emu1010_input_source_get(struct snd_kcontrol *kcontrol, 684 struct snd_ctl_elem_value *ucontrol) 685 { 686 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 687 const struct snd_emu1010_routing_info *emu_ri = 688 &emu1010_routing_info[emu1010_idx(emu)]; 689 unsigned channel = kcontrol->private_value; 690 691 if (channel >= emu_ri->n_ins) 692 return -EINVAL; 693 ucontrol->value.enumerated.item[0] = emu->emu1010.input_source[channel]; 694 return 0; 695 } 696 697 static int snd_emu1010_input_source_put(struct snd_kcontrol *kcontrol, 698 struct snd_ctl_elem_value *ucontrol) 699 { 700 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 701 const struct snd_emu1010_routing_info *emu_ri = 702 &emu1010_routing_info[emu1010_idx(emu)]; 703 unsigned val = ucontrol->value.enumerated.item[0]; 704 unsigned channel = kcontrol->private_value; 705 int change; 706 707 if (val >= emu_ri->n_srcs) 708 return -EINVAL; 709 if (channel >= emu_ri->n_ins) 710 return -EINVAL; 711 change = (emu->emu1010.input_source[channel] != val); 712 if (change) { 713 emu->emu1010.input_source[channel] = val; 714 snd_emu1010_input_source_apply(emu, channel, val); 715 } 716 return change; 717 } 718 719 static const struct snd_kcontrol_new emu1010_input_source_ctl = { 720 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 721 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 722 .info = snd_emu1010_input_output_source_info, 723 .get = snd_emu1010_input_source_get, 724 .put = snd_emu1010_input_source_put 725 }; 726 727 static int add_emu1010_source_mixers(struct snd_emu10k1 *emu) 728 { 729 const struct snd_emu1010_routing_info *emu_ri = 730 &emu1010_routing_info[emu1010_idx(emu)]; 731 int err; 732 733 err = add_ctls(emu, &emu1010_output_source_ctl, 734 emu_ri->out_texts, emu_ri->n_outs); 735 if (err < 0) 736 return err; 737 err = add_ctls(emu, &emu1010_input_source_ctl, 738 emu1010_input_texts, emu_ri->n_ins); 739 return err; 740 } 741 742 743 static const char * const snd_emu1010_adc_pads[] = { 744 "ADC1 14dB PAD 0202 Capture Switch", 745 "ADC1 14dB PAD Audio Dock Capture Switch", 746 "ADC2 14dB PAD Audio Dock Capture Switch", 747 "ADC3 14dB PAD Audio Dock Capture Switch", 748 }; 749 750 static const unsigned short snd_emu1010_adc_pad_regs[] = { 751 EMU_HANA_0202_ADC_PAD1, 752 EMU_HANA_DOCK_ADC_PAD1, 753 EMU_HANA_DOCK_ADC_PAD2, 754 EMU_HANA_DOCK_ADC_PAD3, 755 }; 756 757 #define snd_emu1010_adc_pads_info snd_ctl_boolean_mono_info 758 759 static int snd_emu1010_adc_pads_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 760 { 761 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 762 unsigned int mask = snd_emu1010_adc_pad_regs[kcontrol->private_value]; 763 764 ucontrol->value.integer.value[0] = (emu->emu1010.adc_pads & mask) ? 1 : 0; 765 return 0; 766 } 767 768 static int snd_emu1010_adc_pads_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 769 { 770 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 771 unsigned int mask = snd_emu1010_adc_pad_regs[kcontrol->private_value]; 772 unsigned int val, cache; 773 val = ucontrol->value.integer.value[0]; 774 cache = emu->emu1010.adc_pads; 775 if (val == 1) 776 cache = cache | mask; 777 else 778 cache = cache & ~mask; 779 if (cache != emu->emu1010.adc_pads) { 780 snd_emu1010_fpga_write(emu, EMU_HANA_ADC_PADS, cache ); 781 emu->emu1010.adc_pads = cache; 782 } 783 784 return 0; 785 } 786 787 static const struct snd_kcontrol_new emu1010_adc_pads_ctl = { 788 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 789 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 790 .info = snd_emu1010_adc_pads_info, 791 .get = snd_emu1010_adc_pads_get, 792 .put = snd_emu1010_adc_pads_put 793 }; 794 795 796 static const char * const snd_emu1010_dac_pads[] = { 797 "DAC1 0202 14dB PAD Playback Switch", 798 "DAC1 Audio Dock 14dB PAD Playback Switch", 799 "DAC2 Audio Dock 14dB PAD Playback Switch", 800 "DAC3 Audio Dock 14dB PAD Playback Switch", 801 "DAC4 Audio Dock 14dB PAD Playback Switch", 802 }; 803 804 static const unsigned short snd_emu1010_dac_regs[] = { 805 EMU_HANA_0202_DAC_PAD1, 806 EMU_HANA_DOCK_DAC_PAD1, 807 EMU_HANA_DOCK_DAC_PAD2, 808 EMU_HANA_DOCK_DAC_PAD3, 809 EMU_HANA_DOCK_DAC_PAD4, 810 }; 811 812 #define snd_emu1010_dac_pads_info snd_ctl_boolean_mono_info 813 814 static int snd_emu1010_dac_pads_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 815 { 816 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 817 unsigned int mask = snd_emu1010_dac_regs[kcontrol->private_value]; 818 819 ucontrol->value.integer.value[0] = (emu->emu1010.dac_pads & mask) ? 1 : 0; 820 return 0; 821 } 822 823 static int snd_emu1010_dac_pads_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 824 { 825 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 826 unsigned int mask = snd_emu1010_dac_regs[kcontrol->private_value]; 827 unsigned int val, cache; 828 int change; 829 830 val = ucontrol->value.integer.value[0]; 831 cache = emu->emu1010.dac_pads; 832 if (val == 1) 833 cache = cache | mask; 834 else 835 cache = cache & ~mask; 836 change = (cache != emu->emu1010.dac_pads); 837 if (change) { 838 snd_emu1010_fpga_write(emu, EMU_HANA_DAC_PADS, cache ); 839 emu->emu1010.dac_pads = cache; 840 } 841 842 return change; 843 } 844 845 static const struct snd_kcontrol_new emu1010_dac_pads_ctl = { 846 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 847 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 848 .info = snd_emu1010_dac_pads_info, 849 .get = snd_emu1010_dac_pads_get, 850 .put = snd_emu1010_dac_pads_put 851 }; 852 853 854 struct snd_emu1010_pads_info { 855 const char * const *adc_ctls, * const *dac_ctls; 856 unsigned n_adc_ctls, n_dac_ctls; 857 }; 858 859 static const struct snd_emu1010_pads_info emu1010_pads_info[] = { 860 { 861 /* rev1 1010 */ 862 .adc_ctls = snd_emu1010_adc_pads, 863 .n_adc_ctls = ARRAY_SIZE(snd_emu1010_adc_pads), 864 .dac_ctls = snd_emu1010_dac_pads, 865 .n_dac_ctls = ARRAY_SIZE(snd_emu1010_dac_pads), 866 }, 867 { 868 /* rev2 1010 */ 869 .adc_ctls = snd_emu1010_adc_pads, 870 .n_adc_ctls = ARRAY_SIZE(snd_emu1010_adc_pads) - 1, 871 .dac_ctls = snd_emu1010_dac_pads, 872 .n_dac_ctls = ARRAY_SIZE(snd_emu1010_dac_pads) - 1, 873 }, 874 { 875 /* 1616(m) cardbus */ 876 .adc_ctls = snd_emu1010_adc_pads + 1, 877 .n_adc_ctls = ARRAY_SIZE(snd_emu1010_adc_pads) - 2, 878 .dac_ctls = snd_emu1010_dac_pads + 1, 879 .n_dac_ctls = ARRAY_SIZE(snd_emu1010_dac_pads) - 2, 880 }, 881 { 882 /* 0404 */ 883 .adc_ctls = NULL, 884 .n_adc_ctls = 0, 885 .dac_ctls = NULL, 886 .n_dac_ctls = 0, 887 }, 888 }; 889 890 891 static int snd_emu1010_internal_clock_info(struct snd_kcontrol *kcontrol, 892 struct snd_ctl_elem_info *uinfo) 893 { 894 static const char * const texts[4] = { 895 "44100", "48000", "SPDIF", "ADAT" 896 }; 897 898 return snd_ctl_enum_info(uinfo, 1, 4, texts); 899 } 900 901 static int snd_emu1010_internal_clock_get(struct snd_kcontrol *kcontrol, 902 struct snd_ctl_elem_value *ucontrol) 903 { 904 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 905 906 ucontrol->value.enumerated.item[0] = emu->emu1010.internal_clock; 907 return 0; 908 } 909 910 static int snd_emu1010_internal_clock_put(struct snd_kcontrol *kcontrol, 911 struct snd_ctl_elem_value *ucontrol) 912 { 913 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 914 unsigned int val; 915 int change = 0; 916 917 val = ucontrol->value.enumerated.item[0] ; 918 /* Limit: uinfo->value.enumerated.items = 4; */ 919 if (val >= 4) 920 return -EINVAL; 921 change = (emu->emu1010.internal_clock != val); 922 if (change) { 923 emu->emu1010.internal_clock = val; 924 switch (val) { 925 case 0: 926 /* 44100 */ 927 /* Mute all */ 928 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE ); 929 /* Default fallback clock 44.1kHz */ 930 snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, EMU_HANA_DEFCLOCK_44_1K ); 931 /* Word Clock source, Internal 44.1kHz x1 */ 932 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK, 933 EMU_HANA_WCLOCK_INT_44_1K | EMU_HANA_WCLOCK_1X ); 934 /* Set LEDs on Audio Dock */ 935 snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_LEDS_2, 936 EMU_HANA_DOCK_LEDS_2_44K | EMU_HANA_DOCK_LEDS_2_LOCK ); 937 /* Allow DLL to settle */ 938 msleep(10); 939 /* Unmute all */ 940 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE ); 941 break; 942 case 1: 943 /* 48000 */ 944 /* Mute all */ 945 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE ); 946 /* Default fallback clock 48kHz */ 947 snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, EMU_HANA_DEFCLOCK_48K ); 948 /* Word Clock source, Internal 48kHz x1 */ 949 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK, 950 EMU_HANA_WCLOCK_INT_48K | EMU_HANA_WCLOCK_1X ); 951 /* Set LEDs on Audio Dock */ 952 snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_LEDS_2, 953 EMU_HANA_DOCK_LEDS_2_48K | EMU_HANA_DOCK_LEDS_2_LOCK ); 954 /* Allow DLL to settle */ 955 msleep(10); 956 /* Unmute all */ 957 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE ); 958 break; 959 960 case 2: /* Take clock from S/PDIF IN */ 961 /* Mute all */ 962 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE ); 963 /* Default fallback clock 48kHz */ 964 snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, EMU_HANA_DEFCLOCK_48K ); 965 /* Word Clock source, sync to S/PDIF input */ 966 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK, 967 EMU_HANA_WCLOCK_HANA_SPDIF_IN | EMU_HANA_WCLOCK_1X ); 968 /* Set LEDs on Audio Dock */ 969 snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_LEDS_2, 970 EMU_HANA_DOCK_LEDS_2_EXT | EMU_HANA_DOCK_LEDS_2_LOCK ); 971 /* FIXME: We should set EMU_HANA_DOCK_LEDS_2_LOCK only when clock signal is present and valid */ 972 /* Allow DLL to settle */ 973 msleep(10); 974 /* Unmute all */ 975 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE ); 976 break; 977 978 case 3: 979 /* Take clock from ADAT IN */ 980 /* Mute all */ 981 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE ); 982 /* Default fallback clock 48kHz */ 983 snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, EMU_HANA_DEFCLOCK_48K ); 984 /* Word Clock source, sync to ADAT input */ 985 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK, 986 EMU_HANA_WCLOCK_HANA_ADAT_IN | EMU_HANA_WCLOCK_1X ); 987 /* Set LEDs on Audio Dock */ 988 snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_LEDS_2, EMU_HANA_DOCK_LEDS_2_EXT | EMU_HANA_DOCK_LEDS_2_LOCK ); 989 /* FIXME: We should set EMU_HANA_DOCK_LEDS_2_LOCK only when clock signal is present and valid */ 990 /* Allow DLL to settle */ 991 msleep(10); 992 /* Unmute all */ 993 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE ); 994 995 996 break; 997 } 998 } 999 return change; 1000 } 1001 1002 static const struct snd_kcontrol_new snd_emu1010_internal_clock = 1003 { 1004 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 1005 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1006 .name = "Clock Internal Rate", 1007 .count = 1, 1008 .info = snd_emu1010_internal_clock_info, 1009 .get = snd_emu1010_internal_clock_get, 1010 .put = snd_emu1010_internal_clock_put 1011 }; 1012 1013 static int snd_emu1010_optical_out_info(struct snd_kcontrol *kcontrol, 1014 struct snd_ctl_elem_info *uinfo) 1015 { 1016 static const char * const texts[2] = { 1017 "SPDIF", "ADAT" 1018 }; 1019 1020 return snd_ctl_enum_info(uinfo, 1, 2, texts); 1021 } 1022 1023 static int snd_emu1010_optical_out_get(struct snd_kcontrol *kcontrol, 1024 struct snd_ctl_elem_value *ucontrol) 1025 { 1026 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1027 1028 ucontrol->value.enumerated.item[0] = emu->emu1010.optical_out; 1029 return 0; 1030 } 1031 1032 static int snd_emu1010_optical_out_put(struct snd_kcontrol *kcontrol, 1033 struct snd_ctl_elem_value *ucontrol) 1034 { 1035 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1036 unsigned int val; 1037 u32 tmp; 1038 int change = 0; 1039 1040 val = ucontrol->value.enumerated.item[0]; 1041 /* Limit: uinfo->value.enumerated.items = 2; */ 1042 if (val >= 2) 1043 return -EINVAL; 1044 change = (emu->emu1010.optical_out != val); 1045 if (change) { 1046 emu->emu1010.optical_out = val; 1047 tmp = (emu->emu1010.optical_in ? EMU_HANA_OPTICAL_IN_ADAT : EMU_HANA_OPTICAL_IN_SPDIF) | 1048 (emu->emu1010.optical_out ? EMU_HANA_OPTICAL_OUT_ADAT : EMU_HANA_OPTICAL_OUT_SPDIF); 1049 snd_emu1010_fpga_write(emu, EMU_HANA_OPTICAL_TYPE, tmp); 1050 } 1051 return change; 1052 } 1053 1054 static const struct snd_kcontrol_new snd_emu1010_optical_out = { 1055 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 1056 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1057 .name = "Optical Output Mode", 1058 .count = 1, 1059 .info = snd_emu1010_optical_out_info, 1060 .get = snd_emu1010_optical_out_get, 1061 .put = snd_emu1010_optical_out_put 1062 }; 1063 1064 static int snd_emu1010_optical_in_info(struct snd_kcontrol *kcontrol, 1065 struct snd_ctl_elem_info *uinfo) 1066 { 1067 static const char * const texts[2] = { 1068 "SPDIF", "ADAT" 1069 }; 1070 1071 return snd_ctl_enum_info(uinfo, 1, 2, texts); 1072 } 1073 1074 static int snd_emu1010_optical_in_get(struct snd_kcontrol *kcontrol, 1075 struct snd_ctl_elem_value *ucontrol) 1076 { 1077 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1078 1079 ucontrol->value.enumerated.item[0] = emu->emu1010.optical_in; 1080 return 0; 1081 } 1082 1083 static int snd_emu1010_optical_in_put(struct snd_kcontrol *kcontrol, 1084 struct snd_ctl_elem_value *ucontrol) 1085 { 1086 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1087 unsigned int val; 1088 u32 tmp; 1089 int change = 0; 1090 1091 val = ucontrol->value.enumerated.item[0]; 1092 /* Limit: uinfo->value.enumerated.items = 2; */ 1093 if (val >= 2) 1094 return -EINVAL; 1095 change = (emu->emu1010.optical_in != val); 1096 if (change) { 1097 emu->emu1010.optical_in = val; 1098 tmp = (emu->emu1010.optical_in ? EMU_HANA_OPTICAL_IN_ADAT : EMU_HANA_OPTICAL_IN_SPDIF) | 1099 (emu->emu1010.optical_out ? EMU_HANA_OPTICAL_OUT_ADAT : EMU_HANA_OPTICAL_OUT_SPDIF); 1100 snd_emu1010_fpga_write(emu, EMU_HANA_OPTICAL_TYPE, tmp); 1101 } 1102 return change; 1103 } 1104 1105 static const struct snd_kcontrol_new snd_emu1010_optical_in = { 1106 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 1107 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1108 .name = "Optical Input Mode", 1109 .count = 1, 1110 .info = snd_emu1010_optical_in_info, 1111 .get = snd_emu1010_optical_in_get, 1112 .put = snd_emu1010_optical_in_put 1113 }; 1114 1115 static int snd_audigy_i2c_capture_source_info(struct snd_kcontrol *kcontrol, 1116 struct snd_ctl_elem_info *uinfo) 1117 { 1118 #if 0 1119 static const char * const texts[4] = { 1120 "Unknown1", "Unknown2", "Mic", "Line" 1121 }; 1122 #endif 1123 static const char * const texts[2] = { 1124 "Mic", "Line" 1125 }; 1126 1127 return snd_ctl_enum_info(uinfo, 1, 2, texts); 1128 } 1129 1130 static int snd_audigy_i2c_capture_source_get(struct snd_kcontrol *kcontrol, 1131 struct snd_ctl_elem_value *ucontrol) 1132 { 1133 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1134 1135 ucontrol->value.enumerated.item[0] = emu->i2c_capture_source; 1136 return 0; 1137 } 1138 1139 static int snd_audigy_i2c_capture_source_put(struct snd_kcontrol *kcontrol, 1140 struct snd_ctl_elem_value *ucontrol) 1141 { 1142 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1143 unsigned int source_id; 1144 unsigned int ngain, ogain; 1145 u16 gpio; 1146 int change = 0; 1147 unsigned long flags; 1148 u32 source; 1149 /* If the capture source has changed, 1150 * update the capture volume from the cached value 1151 * for the particular source. 1152 */ 1153 source_id = ucontrol->value.enumerated.item[0]; 1154 /* Limit: uinfo->value.enumerated.items = 2; */ 1155 /* emu->i2c_capture_volume */ 1156 if (source_id >= 2) 1157 return -EINVAL; 1158 change = (emu->i2c_capture_source != source_id); 1159 if (change) { 1160 snd_emu10k1_i2c_write(emu, ADC_MUX, 0); /* Mute input */ 1161 spin_lock_irqsave(&emu->emu_lock, flags); 1162 gpio = inw(emu->port + A_IOCFG); 1163 if (source_id==0) 1164 outw(gpio | 0x4, emu->port + A_IOCFG); 1165 else 1166 outw(gpio & ~0x4, emu->port + A_IOCFG); 1167 spin_unlock_irqrestore(&emu->emu_lock, flags); 1168 1169 ngain = emu->i2c_capture_volume[source_id][0]; /* Left */ 1170 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */ 1171 if (ngain != ogain) 1172 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff)); 1173 ngain = emu->i2c_capture_volume[source_id][1]; /* Right */ 1174 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Right */ 1175 if (ngain != ogain) 1176 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff)); 1177 1178 source = 1 << (source_id + 2); 1179 snd_emu10k1_i2c_write(emu, ADC_MUX, source); /* Set source */ 1180 emu->i2c_capture_source = source_id; 1181 } 1182 return change; 1183 } 1184 1185 static const struct snd_kcontrol_new snd_audigy_i2c_capture_source = 1186 { 1187 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1188 .name = "Capture Source", 1189 .info = snd_audigy_i2c_capture_source_info, 1190 .get = snd_audigy_i2c_capture_source_get, 1191 .put = snd_audigy_i2c_capture_source_put 1192 }; 1193 1194 static int snd_audigy_i2c_volume_info(struct snd_kcontrol *kcontrol, 1195 struct snd_ctl_elem_info *uinfo) 1196 { 1197 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1198 uinfo->count = 2; 1199 uinfo->value.integer.min = 0; 1200 uinfo->value.integer.max = 255; 1201 return 0; 1202 } 1203 1204 static int snd_audigy_i2c_volume_get(struct snd_kcontrol *kcontrol, 1205 struct snd_ctl_elem_value *ucontrol) 1206 { 1207 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1208 unsigned int source_id; 1209 1210 source_id = kcontrol->private_value; 1211 /* Limit: emu->i2c_capture_volume */ 1212 /* capture_source: uinfo->value.enumerated.items = 2 */ 1213 if (source_id >= 2) 1214 return -EINVAL; 1215 1216 ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0]; 1217 ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1]; 1218 return 0; 1219 } 1220 1221 static int snd_audigy_i2c_volume_put(struct snd_kcontrol *kcontrol, 1222 struct snd_ctl_elem_value *ucontrol) 1223 { 1224 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1225 unsigned int ogain; 1226 unsigned int ngain0, ngain1; 1227 unsigned int source_id; 1228 int change = 0; 1229 1230 source_id = kcontrol->private_value; 1231 /* Limit: emu->i2c_capture_volume */ 1232 /* capture_source: uinfo->value.enumerated.items = 2 */ 1233 if (source_id >= 2) 1234 return -EINVAL; 1235 ngain0 = ucontrol->value.integer.value[0]; 1236 ngain1 = ucontrol->value.integer.value[1]; 1237 if (ngain0 > 0xff) 1238 return -EINVAL; 1239 if (ngain1 > 0xff) 1240 return -EINVAL; 1241 ogain = emu->i2c_capture_volume[source_id][0]; /* Left */ 1242 if (ogain != ngain0) { 1243 if (emu->i2c_capture_source == source_id) 1244 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCL, ngain0); 1245 emu->i2c_capture_volume[source_id][0] = ngain0; 1246 change = 1; 1247 } 1248 ogain = emu->i2c_capture_volume[source_id][1]; /* Right */ 1249 if (ogain != ngain1) { 1250 if (emu->i2c_capture_source == source_id) 1251 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCR, ngain1); 1252 emu->i2c_capture_volume[source_id][1] = ngain1; 1253 change = 1; 1254 } 1255 1256 return change; 1257 } 1258 1259 static const struct snd_kcontrol_new i2c_volume_ctl = { 1260 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1261 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 1262 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 1263 .info = snd_audigy_i2c_volume_info, 1264 .get = snd_audigy_i2c_volume_get, 1265 .put = snd_audigy_i2c_volume_put, 1266 .tlv = { .p = snd_audigy_db_scale2 } 1267 }; 1268 1269 static const char * const snd_audigy_i2c_volume_ctls[] = { 1270 "Mic Capture Volume", 1271 "Line Capture Volume", 1272 }; 1273 1274 #if 0 1275 static int snd_audigy_spdif_output_rate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1276 { 1277 static const char * const texts[] = {"44100", "48000", "96000"}; 1278 1279 return snd_ctl_enum_info(uinfo, 1, 3, texts); 1280 } 1281 1282 static int snd_audigy_spdif_output_rate_get(struct snd_kcontrol *kcontrol, 1283 struct snd_ctl_elem_value *ucontrol) 1284 { 1285 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1286 unsigned int tmp; 1287 1288 tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0); 1289 switch (tmp & A_SPDIF_RATE_MASK) { 1290 case A_SPDIF_44100: 1291 ucontrol->value.enumerated.item[0] = 0; 1292 break; 1293 case A_SPDIF_48000: 1294 ucontrol->value.enumerated.item[0] = 1; 1295 break; 1296 case A_SPDIF_96000: 1297 ucontrol->value.enumerated.item[0] = 2; 1298 break; 1299 default: 1300 ucontrol->value.enumerated.item[0] = 1; 1301 } 1302 return 0; 1303 } 1304 1305 static int snd_audigy_spdif_output_rate_put(struct snd_kcontrol *kcontrol, 1306 struct snd_ctl_elem_value *ucontrol) 1307 { 1308 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1309 int change; 1310 unsigned int reg, val, tmp; 1311 unsigned long flags; 1312 1313 switch(ucontrol->value.enumerated.item[0]) { 1314 case 0: 1315 val = A_SPDIF_44100; 1316 break; 1317 case 1: 1318 val = A_SPDIF_48000; 1319 break; 1320 case 2: 1321 val = A_SPDIF_96000; 1322 break; 1323 default: 1324 val = A_SPDIF_48000; 1325 break; 1326 } 1327 1328 1329 spin_lock_irqsave(&emu->reg_lock, flags); 1330 reg = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0); 1331 tmp = reg & ~A_SPDIF_RATE_MASK; 1332 tmp |= val; 1333 change = (tmp != reg); 1334 if (change) 1335 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, 0, tmp); 1336 spin_unlock_irqrestore(&emu->reg_lock, flags); 1337 return change; 1338 } 1339 1340 static const struct snd_kcontrol_new snd_audigy_spdif_output_rate = 1341 { 1342 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 1343 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1344 .name = "Audigy SPDIF Output Sample Rate", 1345 .count = 1, 1346 .info = snd_audigy_spdif_output_rate_info, 1347 .get = snd_audigy_spdif_output_rate_get, 1348 .put = snd_audigy_spdif_output_rate_put 1349 }; 1350 #endif 1351 1352 static int snd_emu10k1_spdif_put(struct snd_kcontrol *kcontrol, 1353 struct snd_ctl_elem_value *ucontrol) 1354 { 1355 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1356 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1357 int change; 1358 unsigned int val; 1359 1360 /* Limit: emu->spdif_bits */ 1361 if (idx >= 3) 1362 return -EINVAL; 1363 val = (ucontrol->value.iec958.status[0] << 0) | 1364 (ucontrol->value.iec958.status[1] << 8) | 1365 (ucontrol->value.iec958.status[2] << 16) | 1366 (ucontrol->value.iec958.status[3] << 24); 1367 change = val != emu->spdif_bits[idx]; 1368 if (change) { 1369 snd_emu10k1_ptr_write(emu, SPCS0 + idx, 0, val); 1370 emu->spdif_bits[idx] = val; 1371 } 1372 return change; 1373 } 1374 1375 static const struct snd_kcontrol_new snd_emu10k1_spdif_mask_control = 1376 { 1377 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1378 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1379 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), 1380 .count = 3, 1381 .info = snd_emu10k1_spdif_info, 1382 .get = snd_emu10k1_spdif_get_mask 1383 }; 1384 1385 static const struct snd_kcontrol_new snd_emu10k1_spdif_control = 1386 { 1387 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1388 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 1389 .count = 3, 1390 .info = snd_emu10k1_spdif_info, 1391 .get = snd_emu10k1_spdif_get, 1392 .put = snd_emu10k1_spdif_put 1393 }; 1394 1395 1396 static void update_emu10k1_fxrt(struct snd_emu10k1 *emu, int voice, unsigned char *route) 1397 { 1398 if (emu->audigy) { 1399 snd_emu10k1_ptr_write_multiple(emu, voice, 1400 A_FXRT1, snd_emu10k1_compose_audigy_fxrt1(route), 1401 A_FXRT2, snd_emu10k1_compose_audigy_fxrt2(route), 1402 REGLIST_END); 1403 } else { 1404 snd_emu10k1_ptr_write(emu, FXRT, voice, 1405 snd_emu10k1_compose_send_routing(route)); 1406 } 1407 } 1408 1409 static void update_emu10k1_send_volume(struct snd_emu10k1 *emu, int voice, unsigned char *volume) 1410 { 1411 snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_A, voice, volume[0]); 1412 snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_B, voice, volume[1]); 1413 snd_emu10k1_ptr_write(emu, PSST_FXSENDAMOUNT_C, voice, volume[2]); 1414 snd_emu10k1_ptr_write(emu, DSL_FXSENDAMOUNT_D, voice, volume[3]); 1415 if (emu->audigy) { 1416 snd_emu10k1_ptr_write(emu, A_SENDAMOUNTS, voice, 1417 snd_emu10k1_compose_audigy_sendamounts(volume)); 1418 } 1419 } 1420 1421 /* PCM stream controls */ 1422 1423 static int snd_emu10k1_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1424 { 1425 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1426 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1427 uinfo->count = emu->audigy ? 3*8 : 3*4; 1428 uinfo->value.integer.min = 0; 1429 uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f; 1430 return 0; 1431 } 1432 1433 static int snd_emu10k1_send_routing_get(struct snd_kcontrol *kcontrol, 1434 struct snd_ctl_elem_value *ucontrol) 1435 { 1436 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1437 struct snd_emu10k1_pcm_mixer *mix = 1438 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1439 int voice, idx; 1440 int num_efx = emu->audigy ? 8 : 4; 1441 int mask = emu->audigy ? 0x3f : 0x0f; 1442 1443 for (voice = 0; voice < 3; voice++) 1444 for (idx = 0; idx < num_efx; idx++) 1445 ucontrol->value.integer.value[(voice * num_efx) + idx] = 1446 mix->send_routing[voice][idx] & mask; 1447 return 0; 1448 } 1449 1450 static int snd_emu10k1_send_routing_put(struct snd_kcontrol *kcontrol, 1451 struct snd_ctl_elem_value *ucontrol) 1452 { 1453 unsigned long flags; 1454 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1455 struct snd_emu10k1_pcm_mixer *mix = 1456 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1457 int change = 0, voice, idx, val; 1458 int num_efx = emu->audigy ? 8 : 4; 1459 int mask = emu->audigy ? 0x3f : 0x0f; 1460 1461 spin_lock_irqsave(&emu->reg_lock, flags); 1462 for (voice = 0; voice < 3; voice++) 1463 for (idx = 0; idx < num_efx; idx++) { 1464 val = ucontrol->value.integer.value[(voice * num_efx) + idx] & mask; 1465 if (mix->send_routing[voice][idx] != val) { 1466 mix->send_routing[voice][idx] = val; 1467 change = 1; 1468 } 1469 } 1470 if (change && mix->epcm && mix->epcm->voices[0]) { 1471 if (!mix->epcm->voices[0]->last) { 1472 update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number, 1473 &mix->send_routing[1][0]); 1474 update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number + 1, 1475 &mix->send_routing[2][0]); 1476 } else { 1477 update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number, 1478 &mix->send_routing[0][0]); 1479 } 1480 } 1481 spin_unlock_irqrestore(&emu->reg_lock, flags); 1482 return change; 1483 } 1484 1485 static const struct snd_kcontrol_new snd_emu10k1_send_routing_control = 1486 { 1487 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 1488 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1489 .name = "EMU10K1 PCM Send Routing", 1490 .count = 32, 1491 .info = snd_emu10k1_send_routing_info, 1492 .get = snd_emu10k1_send_routing_get, 1493 .put = snd_emu10k1_send_routing_put 1494 }; 1495 1496 static int snd_emu10k1_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1497 { 1498 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1499 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1500 uinfo->count = emu->audigy ? 3*8 : 3*4; 1501 uinfo->value.integer.min = 0; 1502 uinfo->value.integer.max = 255; 1503 return 0; 1504 } 1505 1506 static int snd_emu10k1_send_volume_get(struct snd_kcontrol *kcontrol, 1507 struct snd_ctl_elem_value *ucontrol) 1508 { 1509 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1510 struct snd_emu10k1_pcm_mixer *mix = 1511 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1512 int idx; 1513 int num_efx = emu->audigy ? 8 : 4; 1514 1515 for (idx = 0; idx < 3*num_efx; idx++) 1516 ucontrol->value.integer.value[idx] = mix->send_volume[idx/num_efx][idx%num_efx]; 1517 return 0; 1518 } 1519 1520 static int snd_emu10k1_send_volume_put(struct snd_kcontrol *kcontrol, 1521 struct snd_ctl_elem_value *ucontrol) 1522 { 1523 unsigned long flags; 1524 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1525 struct snd_emu10k1_pcm_mixer *mix = 1526 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1527 int change = 0, idx, val; 1528 int num_efx = emu->audigy ? 8 : 4; 1529 1530 spin_lock_irqsave(&emu->reg_lock, flags); 1531 for (idx = 0; idx < 3*num_efx; idx++) { 1532 val = ucontrol->value.integer.value[idx] & 255; 1533 if (mix->send_volume[idx/num_efx][idx%num_efx] != val) { 1534 mix->send_volume[idx/num_efx][idx%num_efx] = val; 1535 change = 1; 1536 } 1537 } 1538 if (change && mix->epcm && mix->epcm->voices[0]) { 1539 if (!mix->epcm->voices[0]->last) { 1540 update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number, 1541 &mix->send_volume[1][0]); 1542 update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number + 1, 1543 &mix->send_volume[2][0]); 1544 } else { 1545 update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number, 1546 &mix->send_volume[0][0]); 1547 } 1548 } 1549 spin_unlock_irqrestore(&emu->reg_lock, flags); 1550 return change; 1551 } 1552 1553 static const struct snd_kcontrol_new snd_emu10k1_send_volume_control = 1554 { 1555 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 1556 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1557 .name = "EMU10K1 PCM Send Volume", 1558 .count = 32, 1559 .info = snd_emu10k1_send_volume_info, 1560 .get = snd_emu10k1_send_volume_get, 1561 .put = snd_emu10k1_send_volume_put 1562 }; 1563 1564 static int snd_emu10k1_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1565 { 1566 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1567 uinfo->count = 3; 1568 uinfo->value.integer.min = 0; 1569 uinfo->value.integer.max = 0x1fffd; 1570 return 0; 1571 } 1572 1573 static int snd_emu10k1_attn_get(struct snd_kcontrol *kcontrol, 1574 struct snd_ctl_elem_value *ucontrol) 1575 { 1576 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1577 struct snd_emu10k1_pcm_mixer *mix = 1578 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1579 int idx; 1580 1581 for (idx = 0; idx < 3; idx++) 1582 ucontrol->value.integer.value[idx] = mix->attn[idx] * 0xffffU / 0x8000U; 1583 return 0; 1584 } 1585 1586 static int snd_emu10k1_attn_put(struct snd_kcontrol *kcontrol, 1587 struct snd_ctl_elem_value *ucontrol) 1588 { 1589 unsigned long flags; 1590 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1591 struct snd_emu10k1_pcm_mixer *mix = 1592 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1593 int change = 0, idx, val; 1594 1595 spin_lock_irqsave(&emu->reg_lock, flags); 1596 for (idx = 0; idx < 3; idx++) { 1597 unsigned uval = ucontrol->value.integer.value[idx] & 0x1ffff; 1598 val = uval * 0x8000U / 0xffffU; 1599 if (mix->attn[idx] != val) { 1600 mix->attn[idx] = val; 1601 change = 1; 1602 } 1603 } 1604 if (change && mix->epcm && mix->epcm->voices[0]) { 1605 if (!mix->epcm->voices[0]->last) { 1606 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[1]); 1607 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number + 1, mix->attn[2]); 1608 } else { 1609 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[0]); 1610 } 1611 } 1612 spin_unlock_irqrestore(&emu->reg_lock, flags); 1613 return change; 1614 } 1615 1616 static const struct snd_kcontrol_new snd_emu10k1_attn_control = 1617 { 1618 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 1619 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1620 .name = "EMU10K1 PCM Volume", 1621 .count = 32, 1622 .info = snd_emu10k1_attn_info, 1623 .get = snd_emu10k1_attn_get, 1624 .put = snd_emu10k1_attn_put 1625 }; 1626 1627 /* Mutichannel PCM stream controls */ 1628 1629 static int snd_emu10k1_efx_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1630 { 1631 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1632 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1633 uinfo->count = emu->audigy ? 8 : 4; 1634 uinfo->value.integer.min = 0; 1635 uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f; 1636 return 0; 1637 } 1638 1639 static int snd_emu10k1_efx_send_routing_get(struct snd_kcontrol *kcontrol, 1640 struct snd_ctl_elem_value *ucontrol) 1641 { 1642 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1643 struct snd_emu10k1_pcm_mixer *mix = 1644 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1645 int idx; 1646 int num_efx = emu->audigy ? 8 : 4; 1647 int mask = emu->audigy ? 0x3f : 0x0f; 1648 1649 for (idx = 0; idx < num_efx; idx++) 1650 ucontrol->value.integer.value[idx] = 1651 mix->send_routing[0][idx] & mask; 1652 return 0; 1653 } 1654 1655 static int snd_emu10k1_efx_send_routing_put(struct snd_kcontrol *kcontrol, 1656 struct snd_ctl_elem_value *ucontrol) 1657 { 1658 unsigned long flags; 1659 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1660 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1661 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch]; 1662 int change = 0, idx, val; 1663 int num_efx = emu->audigy ? 8 : 4; 1664 int mask = emu->audigy ? 0x3f : 0x0f; 1665 1666 spin_lock_irqsave(&emu->reg_lock, flags); 1667 for (idx = 0; idx < num_efx; idx++) { 1668 val = ucontrol->value.integer.value[idx] & mask; 1669 if (mix->send_routing[0][idx] != val) { 1670 mix->send_routing[0][idx] = val; 1671 change = 1; 1672 } 1673 } 1674 1675 if (change && mix->epcm) { 1676 if (mix->epcm->voices[ch]) { 1677 update_emu10k1_fxrt(emu, mix->epcm->voices[ch]->number, 1678 &mix->send_routing[0][0]); 1679 } 1680 } 1681 spin_unlock_irqrestore(&emu->reg_lock, flags); 1682 return change; 1683 } 1684 1685 static const struct snd_kcontrol_new snd_emu10k1_efx_send_routing_control = 1686 { 1687 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 1688 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1689 .name = "Multichannel PCM Send Routing", 1690 .count = 16, 1691 .info = snd_emu10k1_efx_send_routing_info, 1692 .get = snd_emu10k1_efx_send_routing_get, 1693 .put = snd_emu10k1_efx_send_routing_put 1694 }; 1695 1696 static int snd_emu10k1_efx_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1697 { 1698 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1699 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1700 uinfo->count = emu->audigy ? 8 : 4; 1701 uinfo->value.integer.min = 0; 1702 uinfo->value.integer.max = 255; 1703 return 0; 1704 } 1705 1706 static int snd_emu10k1_efx_send_volume_get(struct snd_kcontrol *kcontrol, 1707 struct snd_ctl_elem_value *ucontrol) 1708 { 1709 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1710 struct snd_emu10k1_pcm_mixer *mix = 1711 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1712 int idx; 1713 int num_efx = emu->audigy ? 8 : 4; 1714 1715 for (idx = 0; idx < num_efx; idx++) 1716 ucontrol->value.integer.value[idx] = mix->send_volume[0][idx]; 1717 return 0; 1718 } 1719 1720 static int snd_emu10k1_efx_send_volume_put(struct snd_kcontrol *kcontrol, 1721 struct snd_ctl_elem_value *ucontrol) 1722 { 1723 unsigned long flags; 1724 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1725 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1726 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch]; 1727 int change = 0, idx, val; 1728 int num_efx = emu->audigy ? 8 : 4; 1729 1730 spin_lock_irqsave(&emu->reg_lock, flags); 1731 for (idx = 0; idx < num_efx; idx++) { 1732 val = ucontrol->value.integer.value[idx] & 255; 1733 if (mix->send_volume[0][idx] != val) { 1734 mix->send_volume[0][idx] = val; 1735 change = 1; 1736 } 1737 } 1738 if (change && mix->epcm) { 1739 if (mix->epcm->voices[ch]) { 1740 update_emu10k1_send_volume(emu, mix->epcm->voices[ch]->number, 1741 &mix->send_volume[0][0]); 1742 } 1743 } 1744 spin_unlock_irqrestore(&emu->reg_lock, flags); 1745 return change; 1746 } 1747 1748 1749 static const struct snd_kcontrol_new snd_emu10k1_efx_send_volume_control = 1750 { 1751 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 1752 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1753 .name = "Multichannel PCM Send Volume", 1754 .count = 16, 1755 .info = snd_emu10k1_efx_send_volume_info, 1756 .get = snd_emu10k1_efx_send_volume_get, 1757 .put = snd_emu10k1_efx_send_volume_put 1758 }; 1759 1760 static int snd_emu10k1_efx_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1761 { 1762 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1763 uinfo->count = 1; 1764 uinfo->value.integer.min = 0; 1765 uinfo->value.integer.max = 0x1fffd; 1766 return 0; 1767 } 1768 1769 static int snd_emu10k1_efx_attn_get(struct snd_kcontrol *kcontrol, 1770 struct snd_ctl_elem_value *ucontrol) 1771 { 1772 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1773 struct snd_emu10k1_pcm_mixer *mix = 1774 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; 1775 1776 ucontrol->value.integer.value[0] = mix->attn[0] * 0xffffU / 0x8000U; 1777 return 0; 1778 } 1779 1780 static int snd_emu10k1_efx_attn_put(struct snd_kcontrol *kcontrol, 1781 struct snd_ctl_elem_value *ucontrol) 1782 { 1783 unsigned long flags; 1784 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1785 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1786 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch]; 1787 int change = 0, val; 1788 unsigned uval; 1789 1790 spin_lock_irqsave(&emu->reg_lock, flags); 1791 uval = ucontrol->value.integer.value[0] & 0x1ffff; 1792 val = uval * 0x8000U / 0xffffU; 1793 if (mix->attn[0] != val) { 1794 mix->attn[0] = val; 1795 change = 1; 1796 } 1797 if (change && mix->epcm) { 1798 if (mix->epcm->voices[ch]) { 1799 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[ch]->number, mix->attn[0]); 1800 } 1801 } 1802 spin_unlock_irqrestore(&emu->reg_lock, flags); 1803 return change; 1804 } 1805 1806 static const struct snd_kcontrol_new snd_emu10k1_efx_attn_control = 1807 { 1808 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 1809 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1810 .name = "Multichannel PCM Volume", 1811 .count = 16, 1812 .info = snd_emu10k1_efx_attn_info, 1813 .get = snd_emu10k1_efx_attn_get, 1814 .put = snd_emu10k1_efx_attn_put 1815 }; 1816 1817 #define snd_emu10k1_shared_spdif_info snd_ctl_boolean_mono_info 1818 1819 static int snd_emu10k1_shared_spdif_get(struct snd_kcontrol *kcontrol, 1820 struct snd_ctl_elem_value *ucontrol) 1821 { 1822 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1823 1824 if (emu->audigy) 1825 ucontrol->value.integer.value[0] = inw(emu->port + A_IOCFG) & A_IOCFG_GPOUT0 ? 1 : 0; 1826 else 1827 ucontrol->value.integer.value[0] = inl(emu->port + HCFG) & HCFG_GPOUT0 ? 1 : 0; 1828 if (emu->card_capabilities->invert_shared_spdif) 1829 ucontrol->value.integer.value[0] = 1830 !ucontrol->value.integer.value[0]; 1831 1832 return 0; 1833 } 1834 1835 static int snd_emu10k1_shared_spdif_put(struct snd_kcontrol *kcontrol, 1836 struct snd_ctl_elem_value *ucontrol) 1837 { 1838 unsigned long flags; 1839 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1840 unsigned int reg, val, sw; 1841 int change = 0; 1842 1843 sw = ucontrol->value.integer.value[0]; 1844 if (emu->card_capabilities->invert_shared_spdif) 1845 sw = !sw; 1846 spin_lock_irqsave(&emu->emu_lock, flags); 1847 if ( emu->card_capabilities->i2c_adc) { 1848 /* Do nothing for Audigy 2 ZS Notebook */ 1849 } else if (emu->audigy) { 1850 reg = inw(emu->port + A_IOCFG); 1851 val = sw ? A_IOCFG_GPOUT0 : 0; 1852 change = (reg & A_IOCFG_GPOUT0) != val; 1853 if (change) { 1854 reg &= ~A_IOCFG_GPOUT0; 1855 reg |= val; 1856 outw(reg | val, emu->port + A_IOCFG); 1857 } 1858 } 1859 reg = inl(emu->port + HCFG); 1860 val = sw ? HCFG_GPOUT0 : 0; 1861 change |= (reg & HCFG_GPOUT0) != val; 1862 if (change) { 1863 reg &= ~HCFG_GPOUT0; 1864 reg |= val; 1865 outl(reg | val, emu->port + HCFG); 1866 } 1867 spin_unlock_irqrestore(&emu->emu_lock, flags); 1868 return change; 1869 } 1870 1871 static const struct snd_kcontrol_new snd_emu10k1_shared_spdif = 1872 { 1873 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1874 .name = "SB Live Analog/Digital Output Jack", 1875 .info = snd_emu10k1_shared_spdif_info, 1876 .get = snd_emu10k1_shared_spdif_get, 1877 .put = snd_emu10k1_shared_spdif_put 1878 }; 1879 1880 static const struct snd_kcontrol_new snd_audigy_shared_spdif = 1881 { 1882 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1883 .name = "Audigy Analog/Digital Output Jack", 1884 .info = snd_emu10k1_shared_spdif_info, 1885 .get = snd_emu10k1_shared_spdif_get, 1886 .put = snd_emu10k1_shared_spdif_put 1887 }; 1888 1889 /* workaround for too low volume on Audigy due to 16bit/24bit conversion */ 1890 1891 #define snd_audigy_capture_boost_info snd_ctl_boolean_mono_info 1892 1893 static int snd_audigy_capture_boost_get(struct snd_kcontrol *kcontrol, 1894 struct snd_ctl_elem_value *ucontrol) 1895 { 1896 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1897 unsigned int val; 1898 1899 /* FIXME: better to use a cached version */ 1900 val = snd_ac97_read(emu->ac97, AC97_REC_GAIN); 1901 ucontrol->value.integer.value[0] = !!val; 1902 return 0; 1903 } 1904 1905 static int snd_audigy_capture_boost_put(struct snd_kcontrol *kcontrol, 1906 struct snd_ctl_elem_value *ucontrol) 1907 { 1908 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); 1909 unsigned int val; 1910 1911 if (ucontrol->value.integer.value[0]) 1912 val = 0x0f0f; 1913 else 1914 val = 0; 1915 return snd_ac97_update(emu->ac97, AC97_REC_GAIN, val); 1916 } 1917 1918 static const struct snd_kcontrol_new snd_audigy_capture_boost = 1919 { 1920 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1921 .name = "Mic Extra Boost", 1922 .info = snd_audigy_capture_boost_info, 1923 .get = snd_audigy_capture_boost_get, 1924 .put = snd_audigy_capture_boost_put 1925 }; 1926 1927 1928 /* 1929 */ 1930 static void snd_emu10k1_mixer_free_ac97(struct snd_ac97 *ac97) 1931 { 1932 struct snd_emu10k1 *emu = ac97->private_data; 1933 emu->ac97 = NULL; 1934 } 1935 1936 /* 1937 */ 1938 static int remove_ctl(struct snd_card *card, const char *name) 1939 { 1940 struct snd_ctl_elem_id id; 1941 memset(&id, 0, sizeof(id)); 1942 strcpy(id.name, name); 1943 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1944 return snd_ctl_remove_id(card, &id); 1945 } 1946 1947 static struct snd_kcontrol *ctl_find(struct snd_card *card, const char *name) 1948 { 1949 struct snd_ctl_elem_id sid; 1950 memset(&sid, 0, sizeof(sid)); 1951 strcpy(sid.name, name); 1952 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1953 return snd_ctl_find_id(card, &sid); 1954 } 1955 1956 static int rename_ctl(struct snd_card *card, const char *src, const char *dst) 1957 { 1958 struct snd_kcontrol *kctl = ctl_find(card, src); 1959 if (kctl) { 1960 snd_ctl_rename(card, kctl, dst); 1961 return 0; 1962 } 1963 return -ENOENT; 1964 } 1965 1966 int snd_emu10k1_mixer(struct snd_emu10k1 *emu, 1967 int pcm_device, int multi_device) 1968 { 1969 int err; 1970 struct snd_kcontrol *kctl; 1971 struct snd_card *card = emu->card; 1972 const char * const *c; 1973 static const char * const emu10k1_remove_ctls[] = { 1974 /* no AC97 mono, surround, center/lfe */ 1975 "Master Mono Playback Switch", 1976 "Master Mono Playback Volume", 1977 "PCM Out Path & Mute", 1978 "Mono Output Select", 1979 "Surround Playback Switch", 1980 "Surround Playback Volume", 1981 "Center Playback Switch", 1982 "Center Playback Volume", 1983 "LFE Playback Switch", 1984 "LFE Playback Volume", 1985 NULL 1986 }; 1987 static const char * const emu10k1_rename_ctls[] = { 1988 "Surround Digital Playback Volume", "Surround Playback Volume", 1989 "Center Digital Playback Volume", "Center Playback Volume", 1990 "LFE Digital Playback Volume", "LFE Playback Volume", 1991 NULL 1992 }; 1993 static const char * const audigy_remove_ctls[] = { 1994 /* Master/PCM controls on ac97 of Audigy has no effect */ 1995 /* On the Audigy2 the AC97 playback is piped into 1996 * the Philips ADC for 24bit capture */ 1997 "PCM Playback Switch", 1998 "PCM Playback Volume", 1999 "Master Playback Switch", 2000 "Master Playback Volume", 2001 "PCM Out Path & Mute", 2002 "Mono Output Select", 2003 /* remove unused AC97 capture controls */ 2004 "Capture Source", 2005 "Capture Switch", 2006 "Capture Volume", 2007 "Mic Select", 2008 "Headphone Playback Switch", 2009 "Headphone Playback Volume", 2010 "3D Control - Center", 2011 "3D Control - Depth", 2012 "3D Control - Switch", 2013 "Video Playback Switch", 2014 "Video Playback Volume", 2015 "Mic Playback Switch", 2016 "Mic Playback Volume", 2017 "External Amplifier", 2018 NULL 2019 }; 2020 static const char * const audigy_rename_ctls[] = { 2021 /* use conventional names */ 2022 "Wave Playback Volume", "PCM Playback Volume", 2023 /* "Wave Capture Volume", "PCM Capture Volume", */ 2024 "Wave Master Playback Volume", "Master Playback Volume", 2025 "AMic Playback Volume", "Mic Playback Volume", 2026 "Master Mono Playback Switch", "Phone Output Playback Switch", 2027 "Master Mono Playback Volume", "Phone Output Playback Volume", 2028 NULL 2029 }; 2030 static const char * const audigy_rename_ctls_i2c_adc[] = { 2031 //"Analog Mix Capture Volume","OLD Analog Mix Capture Volume", 2032 "Line Capture Volume", "Analog Mix Capture Volume", 2033 "Wave Playback Volume", "OLD PCM Playback Volume", 2034 "Wave Master Playback Volume", "Master Playback Volume", 2035 "AMic Playback Volume", "Old Mic Playback Volume", 2036 "CD Capture Volume", "IEC958 Optical Capture Volume", 2037 NULL 2038 }; 2039 static const char * const audigy_remove_ctls_i2c_adc[] = { 2040 /* On the Audigy2 ZS Notebook 2041 * Capture via WM8775 */ 2042 "Mic Capture Volume", 2043 "Analog Mix Capture Volume", 2044 "Aux Capture Volume", 2045 "IEC958 Optical Capture Volume", 2046 NULL 2047 }; 2048 static const char * const audigy_remove_ctls_1361t_adc[] = { 2049 /* On the Audigy2 the AC97 playback is piped into 2050 * the Philips ADC for 24bit capture */ 2051 "PCM Playback Switch", 2052 "PCM Playback Volume", 2053 "Capture Source", 2054 "Capture Switch", 2055 "Capture Volume", 2056 "Mic Capture Volume", 2057 "Headphone Playback Switch", 2058 "Headphone Playback Volume", 2059 "3D Control - Center", 2060 "3D Control - Depth", 2061 "3D Control - Switch", 2062 "Line2 Playback Volume", 2063 "Line2 Capture Volume", 2064 NULL 2065 }; 2066 static const char * const audigy_rename_ctls_1361t_adc[] = { 2067 "Master Playback Switch", "Master Capture Switch", 2068 "Master Playback Volume", "Master Capture Volume", 2069 "Wave Master Playback Volume", "Master Playback Volume", 2070 "Beep Playback Switch", "Beep Capture Switch", 2071 "Beep Playback Volume", "Beep Capture Volume", 2072 "Phone Playback Switch", "Phone Capture Switch", 2073 "Phone Playback Volume", "Phone Capture Volume", 2074 "Mic Playback Switch", "Mic Capture Switch", 2075 "Mic Playback Volume", "Mic Capture Volume", 2076 "Line Playback Switch", "Line Capture Switch", 2077 "Line Playback Volume", "Line Capture Volume", 2078 "CD Playback Switch", "CD Capture Switch", 2079 "CD Playback Volume", "CD Capture Volume", 2080 "Aux Playback Switch", "Aux Capture Switch", 2081 "Aux Playback Volume", "Aux Capture Volume", 2082 "Video Playback Switch", "Video Capture Switch", 2083 "Video Playback Volume", "Video Capture Volume", 2084 "Master Mono Playback Switch", "Phone Output Playback Switch", 2085 "Master Mono Playback Volume", "Phone Output Playback Volume", 2086 NULL 2087 }; 2088 2089 if (emu->card_capabilities->ac97_chip) { 2090 struct snd_ac97_bus *pbus; 2091 struct snd_ac97_template ac97; 2092 static const struct snd_ac97_bus_ops ops = { 2093 .write = snd_emu10k1_ac97_write, 2094 .read = snd_emu10k1_ac97_read, 2095 }; 2096 2097 err = snd_ac97_bus(emu->card, 0, &ops, NULL, &pbus); 2098 if (err < 0) 2099 return err; 2100 pbus->no_vra = 1; /* we don't need VRA */ 2101 2102 memset(&ac97, 0, sizeof(ac97)); 2103 ac97.private_data = emu; 2104 ac97.private_free = snd_emu10k1_mixer_free_ac97; 2105 ac97.scaps = AC97_SCAP_NO_SPDIF; 2106 err = snd_ac97_mixer(pbus, &ac97, &emu->ac97); 2107 if (err < 0) { 2108 if (emu->card_capabilities->ac97_chip == 1) 2109 return err; 2110 dev_info(emu->card->dev, 2111 "AC97 is optional on this board\n"); 2112 dev_info(emu->card->dev, 2113 "Proceeding without ac97 mixers...\n"); 2114 snd_device_free(emu->card, pbus); 2115 goto no_ac97; /* FIXME: get rid of ugly gotos.. */ 2116 } 2117 if (emu->audigy) { 2118 /* set master volume to 0 dB */ 2119 snd_ac97_write_cache(emu->ac97, AC97_MASTER, 0x0000); 2120 /* set capture source to mic */ 2121 snd_ac97_write_cache(emu->ac97, AC97_REC_SEL, 0x0000); 2122 /* set mono output (TAD) to mic */ 2123 snd_ac97_update_bits(emu->ac97, AC97_GENERAL_PURPOSE, 2124 0x0200, 0x0200); 2125 if (emu->card_capabilities->adc_1361t) 2126 c = audigy_remove_ctls_1361t_adc; 2127 else 2128 c = audigy_remove_ctls; 2129 } else { 2130 /* 2131 * Credits for cards based on STAC9758: 2132 * James Courtier-Dutton <James@superbug.demon.co.uk> 2133 * Voluspa <voluspa@comhem.se> 2134 */ 2135 if (emu->ac97->id == AC97_ID_STAC9758) { 2136 emu->rear_ac97 = 1; 2137 snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_CNTR|AC97SLOT_LFE|AC97SLOT_REAR_LEFT|AC97SLOT_REAR_RIGHT); 2138 snd_ac97_write_cache(emu->ac97, AC97_HEADPHONE, 0x0202); 2139 remove_ctl(card,"Front Playback Volume"); 2140 remove_ctl(card,"Front Playback Switch"); 2141 } 2142 /* remove unused AC97 controls */ 2143 snd_ac97_write_cache(emu->ac97, AC97_SURROUND_MASTER, 0x0202); 2144 snd_ac97_write_cache(emu->ac97, AC97_CENTER_LFE_MASTER, 0x0202); 2145 c = emu10k1_remove_ctls; 2146 } 2147 for (; *c; c++) 2148 remove_ctl(card, *c); 2149 } else if (emu->card_capabilities->i2c_adc) { 2150 c = audigy_remove_ctls_i2c_adc; 2151 for (; *c; c++) 2152 remove_ctl(card, *c); 2153 } else { 2154 no_ac97: 2155 if (emu->card_capabilities->ecard) 2156 strcpy(emu->card->mixername, "EMU APS"); 2157 else if (emu->audigy) 2158 strcpy(emu->card->mixername, "SB Audigy"); 2159 else 2160 strcpy(emu->card->mixername, "Emu10k1"); 2161 } 2162 2163 if (emu->audigy) 2164 if (emu->card_capabilities->adc_1361t) 2165 c = audigy_rename_ctls_1361t_adc; 2166 else if (emu->card_capabilities->i2c_adc) 2167 c = audigy_rename_ctls_i2c_adc; 2168 else 2169 c = audigy_rename_ctls; 2170 else 2171 c = emu10k1_rename_ctls; 2172 for (; *c; c += 2) 2173 rename_ctl(card, c[0], c[1]); 2174 2175 if (emu->card_capabilities->subsystem == 0x80401102) { /* SB Live! Platinum CT4760P */ 2176 remove_ctl(card, "Center Playback Volume"); 2177 remove_ctl(card, "LFE Playback Volume"); 2178 remove_ctl(card, "Wave Center Playback Volume"); 2179 remove_ctl(card, "Wave LFE Playback Volume"); 2180 } 2181 if (emu->card_capabilities->subsystem == 0x20071102) { /* Audigy 4 Pro */ 2182 rename_ctl(card, "Line2 Capture Volume", "Line1/Mic Capture Volume"); 2183 rename_ctl(card, "Analog Mix Capture Volume", "Line2 Capture Volume"); 2184 rename_ctl(card, "Aux2 Capture Volume", "Line3 Capture Volume"); 2185 rename_ctl(card, "Mic Capture Volume", "Unknown1 Capture Volume"); 2186 } 2187 kctl = emu->ctl_send_routing = snd_ctl_new1(&snd_emu10k1_send_routing_control, emu); 2188 if (!kctl) 2189 return -ENOMEM; 2190 kctl->id.device = pcm_device; 2191 err = snd_ctl_add(card, kctl); 2192 if (err) 2193 return err; 2194 kctl = emu->ctl_send_volume = snd_ctl_new1(&snd_emu10k1_send_volume_control, emu); 2195 if (!kctl) 2196 return -ENOMEM; 2197 kctl->id.device = pcm_device; 2198 err = snd_ctl_add(card, kctl); 2199 if (err) 2200 return err; 2201 kctl = emu->ctl_attn = snd_ctl_new1(&snd_emu10k1_attn_control, emu); 2202 if (!kctl) 2203 return -ENOMEM; 2204 kctl->id.device = pcm_device; 2205 err = snd_ctl_add(card, kctl); 2206 if (err) 2207 return err; 2208 2209 kctl = emu->ctl_efx_send_routing = snd_ctl_new1(&snd_emu10k1_efx_send_routing_control, emu); 2210 if (!kctl) 2211 return -ENOMEM; 2212 kctl->id.device = multi_device; 2213 err = snd_ctl_add(card, kctl); 2214 if (err) 2215 return err; 2216 2217 kctl = emu->ctl_efx_send_volume = snd_ctl_new1(&snd_emu10k1_efx_send_volume_control, emu); 2218 if (!kctl) 2219 return -ENOMEM; 2220 kctl->id.device = multi_device; 2221 err = snd_ctl_add(card, kctl); 2222 if (err) 2223 return err; 2224 2225 kctl = emu->ctl_efx_attn = snd_ctl_new1(&snd_emu10k1_efx_attn_control, emu); 2226 if (!kctl) 2227 return -ENOMEM; 2228 kctl->id.device = multi_device; 2229 err = snd_ctl_add(card, kctl); 2230 if (err) 2231 return err; 2232 2233 if (!emu->card_capabilities->ecard && !emu->card_capabilities->emu_model) { 2234 /* sb live! and audigy */ 2235 kctl = snd_ctl_new1(&snd_emu10k1_spdif_mask_control, emu); 2236 if (!kctl) 2237 return -ENOMEM; 2238 if (!emu->audigy) 2239 kctl->id.device = emu->pcm_efx->device; 2240 err = snd_ctl_add(card, kctl); 2241 if (err) 2242 return err; 2243 kctl = snd_ctl_new1(&snd_emu10k1_spdif_control, emu); 2244 if (!kctl) 2245 return -ENOMEM; 2246 if (!emu->audigy) 2247 kctl->id.device = emu->pcm_efx->device; 2248 err = snd_ctl_add(card, kctl); 2249 if (err) 2250 return err; 2251 } 2252 2253 if (emu->card_capabilities->emu_model) { 2254 ; /* Disable the snd_audigy_spdif_shared_spdif */ 2255 } else if (emu->audigy) { 2256 kctl = snd_ctl_new1(&snd_audigy_shared_spdif, emu); 2257 if (!kctl) 2258 return -ENOMEM; 2259 err = snd_ctl_add(card, kctl); 2260 if (err) 2261 return err; 2262 #if 0 2263 kctl = snd_ctl_new1(&snd_audigy_spdif_output_rate, emu); 2264 if (!kctl) 2265 return -ENOMEM; 2266 err = snd_ctl_add(card, kctl); 2267 if (err) 2268 return err; 2269 #endif 2270 } else if (! emu->card_capabilities->ecard) { 2271 /* sb live! */ 2272 kctl = snd_ctl_new1(&snd_emu10k1_shared_spdif, emu); 2273 if (!kctl) 2274 return -ENOMEM; 2275 err = snd_ctl_add(card, kctl); 2276 if (err) 2277 return err; 2278 } 2279 if (emu->card_capabilities->ca0151_chip) { /* P16V */ 2280 err = snd_p16v_mixer(emu); 2281 if (err) 2282 return err; 2283 } 2284 2285 if (emu->card_capabilities->emu_model) { 2286 unsigned i, emu_idx = emu1010_idx(emu); 2287 const struct snd_emu1010_routing_info *emu_ri = 2288 &emu1010_routing_info[emu_idx]; 2289 const struct snd_emu1010_pads_info *emu_pi = &emu1010_pads_info[emu_idx]; 2290 2291 for (i = 0; i < emu_ri->n_ins; i++) 2292 emu->emu1010.input_source[i] = 2293 emu1010_map_source(emu_ri, emu_ri->in_dflts[i]); 2294 for (i = 0; i < emu_ri->n_outs; i++) 2295 emu->emu1010.output_source[i] = 2296 emu1010_map_source(emu_ri, emu_ri->out_dflts[i]); 2297 snd_emu1010_apply_sources(emu); 2298 2299 err = snd_ctl_add(card, 2300 snd_ctl_new1(&snd_emu1010_internal_clock, emu)); 2301 if (err < 0) 2302 return err; 2303 2304 err = add_ctls(emu, &emu1010_adc_pads_ctl, 2305 emu_pi->adc_ctls, emu_pi->n_adc_ctls); 2306 if (err < 0) 2307 return err; 2308 err = add_ctls(emu, &emu1010_dac_pads_ctl, 2309 emu_pi->dac_ctls, emu_pi->n_dac_ctls); 2310 if (err < 0) 2311 return err; 2312 2313 if (!emu->card_capabilities->no_adat) { 2314 err = snd_ctl_add(card, 2315 snd_ctl_new1(&snd_emu1010_optical_out, emu)); 2316 if (err < 0) 2317 return err; 2318 err = snd_ctl_add(card, 2319 snd_ctl_new1(&snd_emu1010_optical_in, emu)); 2320 if (err < 0) 2321 return err; 2322 } 2323 2324 err = add_emu1010_source_mixers(emu); 2325 if (err < 0) 2326 return err; 2327 } 2328 2329 if ( emu->card_capabilities->i2c_adc) { 2330 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_i2c_capture_source, emu)); 2331 if (err < 0) 2332 return err; 2333 2334 err = add_ctls(emu, &i2c_volume_ctl, 2335 snd_audigy_i2c_volume_ctls, 2336 ARRAY_SIZE(snd_audigy_i2c_volume_ctls)); 2337 if (err < 0) 2338 return err; 2339 } 2340 2341 if (emu->card_capabilities->ac97_chip && emu->audigy) { 2342 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_capture_boost, 2343 emu)); 2344 if (err < 0) 2345 return err; 2346 } 2347 2348 return 0; 2349 } 2350