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