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