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