1 #define __NO_VERSION__ 2 /* 3 * Driver for Digigram pcxhr compatible soundcards 4 * 5 * mixer callbacks 6 * 7 * Copyright (c) 2004 by Digigram <alsa@digigram.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 */ 23 24 #include <sound/driver.h> 25 #include <linux/time.h> 26 #include <linux/interrupt.h> 27 #include <linux/init.h> 28 #include <linux/mutex.h> 29 #include <sound/core.h> 30 #include "pcxhr.h" 31 #include "pcxhr_hwdep.h" 32 #include "pcxhr_core.h" 33 #include <sound/control.h> 34 #include <sound/tlv.h> 35 #include <sound/asoundef.h> 36 #include "pcxhr_mixer.h" 37 38 39 #define PCXHR_ANALOG_CAPTURE_LEVEL_MIN 0 /* -96.0 dB */ 40 #define PCXHR_ANALOG_CAPTURE_LEVEL_MAX 255 /* +31.5 dB */ 41 #define PCXHR_ANALOG_CAPTURE_ZERO_LEVEL 224 /* +16.0 dB ( +31.5 dB - fix level +15.5 dB ) */ 42 43 #define PCXHR_ANALOG_PLAYBACK_LEVEL_MIN 0 /* -128.0 dB */ 44 #define PCXHR_ANALOG_PLAYBACK_LEVEL_MAX 128 /* 0.0 dB */ 45 #define PCXHR_ANALOG_PLAYBACK_ZERO_LEVEL 104 /* -24.0 dB ( 0.0 dB - fix level +24.0 dB ) */ 46 47 static const DECLARE_TLV_DB_SCALE(db_scale_analog_capture, -9600, 50, 3150); 48 static const DECLARE_TLV_DB_SCALE(db_scale_analog_playback, -10400, 100, 2400); 49 50 static int pcxhr_update_analog_audio_level(struct snd_pcxhr *chip, int is_capture, int channel) 51 { 52 int err, vol; 53 struct pcxhr_rmh rmh; 54 55 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); 56 if (is_capture) { 57 rmh.cmd[0] |= IO_NUM_REG_IN_ANA_LEVEL; 58 rmh.cmd[2] = chip->analog_capture_volume[channel]; 59 } else { 60 rmh.cmd[0] |= IO_NUM_REG_OUT_ANA_LEVEL; 61 if (chip->analog_playback_active[channel]) 62 vol = chip->analog_playback_volume[channel]; 63 else 64 vol = PCXHR_ANALOG_PLAYBACK_LEVEL_MIN; 65 rmh.cmd[2] = PCXHR_ANALOG_PLAYBACK_LEVEL_MAX - vol; /* playback analog levels are inversed */ 66 } 67 rmh.cmd[1] = 1 << ((2 * chip->chip_idx) + channel); /* audio mask */ 68 rmh.cmd_len = 3; 69 err = pcxhr_send_msg(chip->mgr, &rmh); 70 if (err < 0) { 71 snd_printk(KERN_DEBUG "error update_analog_audio_level card(%d) " 72 "is_capture(%d) err(%x)\n", chip->chip_idx, is_capture, err); 73 return -EINVAL; 74 } 75 return 0; 76 } 77 78 /* 79 * analog level control 80 */ 81 static int pcxhr_analog_vol_info(struct snd_kcontrol *kcontrol, 82 struct snd_ctl_elem_info *uinfo) 83 { 84 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 85 uinfo->count = 2; 86 if (kcontrol->private_value == 0) { /* playback */ 87 uinfo->value.integer.min = PCXHR_ANALOG_PLAYBACK_LEVEL_MIN; /* -128 dB */ 88 uinfo->value.integer.max = PCXHR_ANALOG_PLAYBACK_LEVEL_MAX; /* 0 dB */ 89 } else { /* capture */ 90 uinfo->value.integer.min = PCXHR_ANALOG_CAPTURE_LEVEL_MIN; /* -96 dB */ 91 uinfo->value.integer.max = PCXHR_ANALOG_CAPTURE_LEVEL_MAX; /* 31.5 dB */ 92 } 93 return 0; 94 } 95 96 static int pcxhr_analog_vol_get(struct snd_kcontrol *kcontrol, 97 struct snd_ctl_elem_value *ucontrol) 98 { 99 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 100 mutex_lock(&chip->mgr->mixer_mutex); 101 if (kcontrol->private_value == 0) { /* playback */ 102 ucontrol->value.integer.value[0] = chip->analog_playback_volume[0]; 103 ucontrol->value.integer.value[1] = chip->analog_playback_volume[1]; 104 } else { /* capture */ 105 ucontrol->value.integer.value[0] = chip->analog_capture_volume[0]; 106 ucontrol->value.integer.value[1] = chip->analog_capture_volume[1]; 107 } 108 mutex_unlock(&chip->mgr->mixer_mutex); 109 return 0; 110 } 111 112 static int pcxhr_analog_vol_put(struct snd_kcontrol *kcontrol, 113 struct snd_ctl_elem_value *ucontrol) 114 { 115 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 116 int changed = 0; 117 int is_capture, i; 118 119 mutex_lock(&chip->mgr->mixer_mutex); 120 is_capture = (kcontrol->private_value != 0); 121 for (i = 0; i < 2; i++) { 122 int new_volume = ucontrol->value.integer.value[i]; 123 int* stored_volume = is_capture ? &chip->analog_capture_volume[i] : 124 &chip->analog_playback_volume[i]; 125 if (*stored_volume != new_volume) { 126 *stored_volume = new_volume; 127 changed = 1; 128 pcxhr_update_analog_audio_level(chip, is_capture, i); 129 } 130 } 131 mutex_unlock(&chip->mgr->mixer_mutex); 132 return changed; 133 } 134 135 static struct snd_kcontrol_new pcxhr_control_analog_level = { 136 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 137 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 138 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 139 /* name will be filled later */ 140 .info = pcxhr_analog_vol_info, 141 .get = pcxhr_analog_vol_get, 142 .put = pcxhr_analog_vol_put, 143 /* tlv will be filled later */ 144 }; 145 146 /* shared */ 147 #define pcxhr_sw_info snd_ctl_boolean_stereo_info 148 149 static int pcxhr_audio_sw_get(struct snd_kcontrol *kcontrol, 150 struct snd_ctl_elem_value *ucontrol) 151 { 152 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 153 154 mutex_lock(&chip->mgr->mixer_mutex); 155 ucontrol->value.integer.value[0] = chip->analog_playback_active[0]; 156 ucontrol->value.integer.value[1] = chip->analog_playback_active[1]; 157 mutex_unlock(&chip->mgr->mixer_mutex); 158 return 0; 159 } 160 161 static int pcxhr_audio_sw_put(struct snd_kcontrol *kcontrol, 162 struct snd_ctl_elem_value *ucontrol) 163 { 164 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 165 int i, changed = 0; 166 mutex_lock(&chip->mgr->mixer_mutex); 167 for(i = 0; i < 2; i++) { 168 if (chip->analog_playback_active[i] != ucontrol->value.integer.value[i]) { 169 chip->analog_playback_active[i] = ucontrol->value.integer.value[i]; 170 changed = 1; 171 pcxhr_update_analog_audio_level(chip, 0, i); /* update playback levels */ 172 } 173 } 174 mutex_unlock(&chip->mgr->mixer_mutex); 175 return changed; 176 } 177 178 static struct snd_kcontrol_new pcxhr_control_output_switch = { 179 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 180 .name = "Master Playback Switch", 181 .info = pcxhr_sw_info, /* shared */ 182 .get = pcxhr_audio_sw_get, 183 .put = pcxhr_audio_sw_put 184 }; 185 186 187 #define PCXHR_DIGITAL_LEVEL_MIN 0x000 /* -110 dB */ 188 #define PCXHR_DIGITAL_LEVEL_MAX 0x1ff /* +18 dB */ 189 #define PCXHR_DIGITAL_ZERO_LEVEL 0x1b7 /* 0 dB */ 190 191 static const DECLARE_TLV_DB_SCALE(db_scale_digital, -10975, 25, 1800); 192 193 #define MORE_THAN_ONE_STREAM_LEVEL 0x000001 194 #define VALID_STREAM_PAN_LEVEL_MASK 0x800000 195 #define VALID_STREAM_LEVEL_MASK 0x400000 196 #define VALID_STREAM_LEVEL_1_MASK 0x200000 197 #define VALID_STREAM_LEVEL_2_MASK 0x100000 198 199 static int pcxhr_update_playback_stream_level(struct snd_pcxhr* chip, int idx) 200 { 201 int err; 202 struct pcxhr_rmh rmh; 203 struct pcxhr_pipe *pipe = &chip->playback_pipe; 204 int left, right; 205 206 if (chip->digital_playback_active[idx][0]) 207 left = chip->digital_playback_volume[idx][0]; 208 else 209 left = PCXHR_DIGITAL_LEVEL_MIN; 210 if (chip->digital_playback_active[idx][1]) 211 right = chip->digital_playback_volume[idx][1]; 212 else 213 right = PCXHR_DIGITAL_LEVEL_MIN; 214 215 pcxhr_init_rmh(&rmh, CMD_STREAM_OUT_LEVEL_ADJUST); 216 /* add pipe and stream mask */ 217 pcxhr_set_pipe_cmd_params(&rmh, 0, pipe->first_audio, 0, 1<<idx); 218 /* volume left->left / right->right panoramic level */ 219 rmh.cmd[0] |= MORE_THAN_ONE_STREAM_LEVEL; 220 rmh.cmd[2] = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_1_MASK; 221 rmh.cmd[2] |= (left << 10); 222 rmh.cmd[3] = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_2_MASK; 223 rmh.cmd[3] |= right; 224 rmh.cmd_len = 4; 225 226 err = pcxhr_send_msg(chip->mgr, &rmh); 227 if (err < 0) { 228 snd_printk(KERN_DEBUG "error update_playback_stream_level " 229 "card(%d) err(%x)\n", chip->chip_idx, err); 230 return -EINVAL; 231 } 232 return 0; 233 } 234 235 #define AUDIO_IO_HAS_MUTE_LEVEL 0x400000 236 #define AUDIO_IO_HAS_MUTE_MONITOR_1 0x200000 237 #define VALID_AUDIO_IO_DIGITAL_LEVEL 0x000001 238 #define VALID_AUDIO_IO_MONITOR_LEVEL 0x000002 239 #define VALID_AUDIO_IO_MUTE_LEVEL 0x000004 240 #define VALID_AUDIO_IO_MUTE_MONITOR_1 0x000008 241 242 static int pcxhr_update_audio_pipe_level(struct snd_pcxhr* chip, int capture, int channel) 243 { 244 int err; 245 struct pcxhr_rmh rmh; 246 struct pcxhr_pipe *pipe; 247 248 if (capture) 249 pipe = &chip->capture_pipe[0]; 250 else 251 pipe = &chip->playback_pipe; 252 253 pcxhr_init_rmh(&rmh, CMD_AUDIO_LEVEL_ADJUST); 254 /* add channel mask */ 255 pcxhr_set_pipe_cmd_params(&rmh, capture, 0, 0, 1 << (channel + pipe->first_audio)); 256 /* TODO : if mask (3 << pipe->first_audio) is used, left and right channel 257 * will be programmed to the same params 258 */ 259 if (capture) { 260 rmh.cmd[0] |= VALID_AUDIO_IO_DIGITAL_LEVEL; 261 /* VALID_AUDIO_IO_MUTE_LEVEL not yet handled (capture pipe level) */ 262 rmh.cmd[2] = chip->digital_capture_volume[channel]; 263 } else { 264 rmh.cmd[0] |= VALID_AUDIO_IO_MONITOR_LEVEL | VALID_AUDIO_IO_MUTE_MONITOR_1; 265 /* VALID_AUDIO_IO_DIGITAL_LEVEL and VALID_AUDIO_IO_MUTE_LEVEL not yet 266 * handled (playback pipe level) 267 */ 268 rmh.cmd[2] = chip->monitoring_volume[channel] << 10; 269 if (chip->monitoring_active[channel] == 0) 270 rmh.cmd[2] |= AUDIO_IO_HAS_MUTE_MONITOR_1; 271 } 272 rmh.cmd_len = 3; 273 274 err = pcxhr_send_msg(chip->mgr, &rmh); 275 if(err<0) { 276 snd_printk(KERN_DEBUG "error update_audio_level card(%d) err(%x)\n", 277 chip->chip_idx, err); 278 return -EINVAL; 279 } 280 return 0; 281 } 282 283 284 /* shared */ 285 static int pcxhr_digital_vol_info(struct snd_kcontrol *kcontrol, 286 struct snd_ctl_elem_info *uinfo) 287 { 288 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 289 uinfo->count = 2; 290 uinfo->value.integer.min = PCXHR_DIGITAL_LEVEL_MIN; /* -109.5 dB */ 291 uinfo->value.integer.max = PCXHR_DIGITAL_LEVEL_MAX; /* 18.0 dB */ 292 return 0; 293 } 294 295 296 static int pcxhr_pcm_vol_get(struct snd_kcontrol *kcontrol, 297 struct snd_ctl_elem_value *ucontrol) 298 { 299 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 300 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ 301 int *stored_volume; 302 int is_capture = kcontrol->private_value; 303 304 mutex_lock(&chip->mgr->mixer_mutex); 305 if (is_capture) 306 stored_volume = chip->digital_capture_volume; /* digital capture */ 307 else 308 stored_volume = chip->digital_playback_volume[idx]; /* digital playback */ 309 ucontrol->value.integer.value[0] = stored_volume[0]; 310 ucontrol->value.integer.value[1] = stored_volume[1]; 311 mutex_unlock(&chip->mgr->mixer_mutex); 312 return 0; 313 } 314 315 static int pcxhr_pcm_vol_put(struct snd_kcontrol *kcontrol, 316 struct snd_ctl_elem_value *ucontrol) 317 { 318 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 319 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ 320 int changed = 0; 321 int is_capture = kcontrol->private_value; 322 int *stored_volume; 323 int i; 324 325 mutex_lock(&chip->mgr->mixer_mutex); 326 if (is_capture) 327 stored_volume = chip->digital_capture_volume; /* digital capture */ 328 else 329 stored_volume = chip->digital_playback_volume[idx]; /* digital playback */ 330 for (i = 0; i < 2; i++) { 331 if (stored_volume[i] != ucontrol->value.integer.value[i]) { 332 stored_volume[i] = ucontrol->value.integer.value[i]; 333 changed = 1; 334 if (is_capture) /* update capture volume */ 335 pcxhr_update_audio_pipe_level(chip, 1, i); 336 } 337 } 338 if (! is_capture && changed) 339 pcxhr_update_playback_stream_level(chip, idx); /* update playback volume */ 340 mutex_unlock(&chip->mgr->mixer_mutex); 341 return changed; 342 } 343 344 static struct snd_kcontrol_new snd_pcxhr_pcm_vol = 345 { 346 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 347 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 348 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 349 /* name will be filled later */ 350 /* count will be filled later */ 351 .info = pcxhr_digital_vol_info, /* shared */ 352 .get = pcxhr_pcm_vol_get, 353 .put = pcxhr_pcm_vol_put, 354 .tlv = { .p = db_scale_digital }, 355 }; 356 357 358 static int pcxhr_pcm_sw_get(struct snd_kcontrol *kcontrol, 359 struct snd_ctl_elem_value *ucontrol) 360 { 361 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 362 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ 363 364 mutex_lock(&chip->mgr->mixer_mutex); 365 ucontrol->value.integer.value[0] = chip->digital_playback_active[idx][0]; 366 ucontrol->value.integer.value[1] = chip->digital_playback_active[idx][1]; 367 mutex_unlock(&chip->mgr->mixer_mutex); 368 return 0; 369 } 370 371 static int pcxhr_pcm_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 372 { 373 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 374 int changed = 0; 375 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ 376 int i, j; 377 378 mutex_lock(&chip->mgr->mixer_mutex); 379 j = idx; 380 for (i = 0; i < 2; i++) { 381 if (chip->digital_playback_active[j][i] != ucontrol->value.integer.value[i]) { 382 chip->digital_playback_active[j][i] = ucontrol->value.integer.value[i]; 383 changed = 1; 384 } 385 } 386 if (changed) 387 pcxhr_update_playback_stream_level(chip, idx); 388 mutex_unlock(&chip->mgr->mixer_mutex); 389 return changed; 390 } 391 392 static struct snd_kcontrol_new pcxhr_control_pcm_switch = { 393 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 394 .name = "PCM Playback Switch", 395 .count = PCXHR_PLAYBACK_STREAMS, 396 .info = pcxhr_sw_info, /* shared */ 397 .get = pcxhr_pcm_sw_get, 398 .put = pcxhr_pcm_sw_put 399 }; 400 401 402 /* 403 * monitoring level control 404 */ 405 406 static int pcxhr_monitor_vol_get(struct snd_kcontrol *kcontrol, 407 struct snd_ctl_elem_value *ucontrol) 408 { 409 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 410 mutex_lock(&chip->mgr->mixer_mutex); 411 ucontrol->value.integer.value[0] = chip->monitoring_volume[0]; 412 ucontrol->value.integer.value[1] = chip->monitoring_volume[1]; 413 mutex_unlock(&chip->mgr->mixer_mutex); 414 return 0; 415 } 416 417 static int pcxhr_monitor_vol_put(struct snd_kcontrol *kcontrol, 418 struct snd_ctl_elem_value *ucontrol) 419 { 420 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 421 int changed = 0; 422 int i; 423 424 mutex_lock(&chip->mgr->mixer_mutex); 425 for (i = 0; i < 2; i++) { 426 if (chip->monitoring_volume[i] != ucontrol->value.integer.value[i]) { 427 chip->monitoring_volume[i] = ucontrol->value.integer.value[i]; 428 if(chip->monitoring_active[i]) /* do only when monitoring is unmuted */ 429 /* update monitoring volume and mute */ 430 pcxhr_update_audio_pipe_level(chip, 0, i); 431 changed = 1; 432 } 433 } 434 mutex_unlock(&chip->mgr->mixer_mutex); 435 return changed; 436 } 437 438 static struct snd_kcontrol_new pcxhr_control_monitor_vol = { 439 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 440 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 441 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 442 .name = "Monitoring Volume", 443 .info = pcxhr_digital_vol_info, /* shared */ 444 .get = pcxhr_monitor_vol_get, 445 .put = pcxhr_monitor_vol_put, 446 .tlv = { .p = db_scale_digital }, 447 }; 448 449 /* 450 * monitoring switch control 451 */ 452 453 static int pcxhr_monitor_sw_get(struct snd_kcontrol *kcontrol, 454 struct snd_ctl_elem_value *ucontrol) 455 { 456 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 457 mutex_lock(&chip->mgr->mixer_mutex); 458 ucontrol->value.integer.value[0] = chip->monitoring_active[0]; 459 ucontrol->value.integer.value[1] = chip->monitoring_active[1]; 460 mutex_unlock(&chip->mgr->mixer_mutex); 461 return 0; 462 } 463 464 static int pcxhr_monitor_sw_put(struct snd_kcontrol *kcontrol, 465 struct snd_ctl_elem_value *ucontrol) 466 { 467 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 468 int changed = 0; 469 int i; 470 471 mutex_lock(&chip->mgr->mixer_mutex); 472 for (i = 0; i < 2; i++) { 473 if (chip->monitoring_active[i] != ucontrol->value.integer.value[i]) { 474 chip->monitoring_active[i] = ucontrol->value.integer.value[i]; 475 changed |= (1<<i); /* mask 0x01 and 0x02 */ 476 } 477 } 478 if(changed & 0x01) 479 /* update left monitoring volume and mute */ 480 pcxhr_update_audio_pipe_level(chip, 0, 0); 481 if(changed & 0x02) 482 /* update right monitoring volume and mute */ 483 pcxhr_update_audio_pipe_level(chip, 0, 1); 484 485 mutex_unlock(&chip->mgr->mixer_mutex); 486 return (changed != 0); 487 } 488 489 static struct snd_kcontrol_new pcxhr_control_monitor_sw = { 490 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 491 .name = "Monitoring Switch", 492 .info = pcxhr_sw_info, /* shared */ 493 .get = pcxhr_monitor_sw_get, 494 .put = pcxhr_monitor_sw_put 495 }; 496 497 498 499 /* 500 * audio source select 501 */ 502 #define PCXHR_SOURCE_AUDIO01_UER 0x000100 503 #define PCXHR_SOURCE_AUDIO01_SYNC 0x000200 504 #define PCXHR_SOURCE_AUDIO23_UER 0x000400 505 #define PCXHR_SOURCE_AUDIO45_UER 0x001000 506 #define PCXHR_SOURCE_AUDIO67_UER 0x040000 507 508 static int pcxhr_set_audio_source(struct snd_pcxhr* chip) 509 { 510 struct pcxhr_rmh rmh; 511 unsigned int mask, reg; 512 unsigned int codec; 513 int err, use_src, changed; 514 515 switch (chip->chip_idx) { 516 case 0 : mask = PCXHR_SOURCE_AUDIO01_UER; codec = CS8420_01_CS; break; 517 case 1 : mask = PCXHR_SOURCE_AUDIO23_UER; codec = CS8420_23_CS; break; 518 case 2 : mask = PCXHR_SOURCE_AUDIO45_UER; codec = CS8420_45_CS; break; 519 case 3 : mask = PCXHR_SOURCE_AUDIO67_UER; codec = CS8420_67_CS; break; 520 default: return -EINVAL; 521 } 522 reg = 0; /* audio source from analog plug */ 523 use_src = 0; /* do not activate codec SRC */ 524 525 if (chip->audio_capture_source != 0) { 526 reg = mask; /* audio source from digital plug */ 527 if (chip->audio_capture_source == 2) 528 use_src = 1; 529 } 530 /* set the input source */ 531 pcxhr_write_io_num_reg_cont(chip->mgr, mask, reg, &changed); 532 /* resync them (otherwise channel inversion possible) */ 533 if (changed) { 534 pcxhr_init_rmh(&rmh, CMD_RESYNC_AUDIO_INPUTS); 535 rmh.cmd[0] |= (1 << chip->chip_idx); 536 err = pcxhr_send_msg(chip->mgr, &rmh); 537 if (err) 538 return err; 539 } 540 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); /* set codec SRC on off */ 541 rmh.cmd_len = 3; 542 rmh.cmd[0] |= IO_NUM_UER_CHIP_REG; 543 rmh.cmd[1] = codec; 544 rmh.cmd[2] = (CS8420_DATA_FLOW_CTL & CHIP_SIG_AND_MAP_SPI) | (use_src ? 0x41 : 0x54); 545 err = pcxhr_send_msg(chip->mgr, &rmh); 546 if(err) 547 return err; 548 rmh.cmd[2] = (CS8420_CLOCK_SRC_CTL & CHIP_SIG_AND_MAP_SPI) | (use_src ? 0x41 : 0x49); 549 err = pcxhr_send_msg(chip->mgr, &rmh); 550 return err; 551 } 552 553 static int pcxhr_audio_src_info(struct snd_kcontrol *kcontrol, 554 struct snd_ctl_elem_info *uinfo) 555 { 556 static char *texts[3] = {"Analog", "Digital", "Digi+SRC"}; 557 558 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 559 uinfo->count = 1; 560 uinfo->value.enumerated.items = 3; 561 if (uinfo->value.enumerated.item > 2) 562 uinfo->value.enumerated.item = 2; 563 strcpy(uinfo->value.enumerated.name, 564 texts[uinfo->value.enumerated.item]); 565 return 0; 566 } 567 568 static int pcxhr_audio_src_get(struct snd_kcontrol *kcontrol, 569 struct snd_ctl_elem_value *ucontrol) 570 { 571 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 572 ucontrol->value.enumerated.item[0] = chip->audio_capture_source; 573 return 0; 574 } 575 576 static int pcxhr_audio_src_put(struct snd_kcontrol *kcontrol, 577 struct snd_ctl_elem_value *ucontrol) 578 { 579 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 580 int ret = 0; 581 582 mutex_lock(&chip->mgr->mixer_mutex); 583 if (chip->audio_capture_source != ucontrol->value.enumerated.item[0]) { 584 chip->audio_capture_source = ucontrol->value.enumerated.item[0]; 585 pcxhr_set_audio_source(chip); 586 ret = 1; 587 } 588 mutex_unlock(&chip->mgr->mixer_mutex); 589 return ret; 590 } 591 592 static struct snd_kcontrol_new pcxhr_control_audio_src = { 593 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 594 .name = "Capture Source", 595 .info = pcxhr_audio_src_info, 596 .get = pcxhr_audio_src_get, 597 .put = pcxhr_audio_src_put, 598 }; 599 600 601 /* 602 * clock type selection 603 * enum pcxhr_clock_type { 604 * PCXHR_CLOCK_TYPE_INTERNAL = 0, 605 * PCXHR_CLOCK_TYPE_WORD_CLOCK, 606 * PCXHR_CLOCK_TYPE_AES_SYNC, 607 * PCXHR_CLOCK_TYPE_AES_1, 608 * PCXHR_CLOCK_TYPE_AES_2, 609 * PCXHR_CLOCK_TYPE_AES_3, 610 * PCXHR_CLOCK_TYPE_AES_4, 611 * }; 612 */ 613 614 static int pcxhr_clock_type_info(struct snd_kcontrol *kcontrol, 615 struct snd_ctl_elem_info *uinfo) 616 { 617 static char *texts[7] = { 618 "Internal", "WordClock", "AES Sync", "AES 1", "AES 2", "AES 3", "AES 4" 619 }; 620 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); 621 int clock_items = 3 + mgr->capture_chips; 622 623 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 624 uinfo->count = 1; 625 uinfo->value.enumerated.items = clock_items; 626 if (uinfo->value.enumerated.item >= clock_items) 627 uinfo->value.enumerated.item = clock_items-1; 628 strcpy(uinfo->value.enumerated.name, 629 texts[uinfo->value.enumerated.item]); 630 return 0; 631 } 632 633 static int pcxhr_clock_type_get(struct snd_kcontrol *kcontrol, 634 struct snd_ctl_elem_value *ucontrol) 635 { 636 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); 637 ucontrol->value.enumerated.item[0] = mgr->use_clock_type; 638 return 0; 639 } 640 641 static int pcxhr_clock_type_put(struct snd_kcontrol *kcontrol, 642 struct snd_ctl_elem_value *ucontrol) 643 { 644 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); 645 int rate, ret = 0; 646 647 mutex_lock(&mgr->mixer_mutex); 648 if (mgr->use_clock_type != ucontrol->value.enumerated.item[0]) { 649 mutex_lock(&mgr->setup_mutex); 650 mgr->use_clock_type = ucontrol->value.enumerated.item[0]; 651 if (mgr->use_clock_type) 652 pcxhr_get_external_clock(mgr, mgr->use_clock_type, &rate); 653 else 654 rate = mgr->sample_rate; 655 if (rate) { 656 pcxhr_set_clock(mgr, rate); 657 if (mgr->sample_rate) 658 mgr->sample_rate = rate; 659 } 660 mutex_unlock(&mgr->setup_mutex); 661 ret = 1; /* return 1 even if the set was not done. ok ? */ 662 } 663 mutex_unlock(&mgr->mixer_mutex); 664 return ret; 665 } 666 667 static struct snd_kcontrol_new pcxhr_control_clock_type = { 668 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 669 .name = "Clock Mode", 670 .info = pcxhr_clock_type_info, 671 .get = pcxhr_clock_type_get, 672 .put = pcxhr_clock_type_put, 673 }; 674 675 /* 676 * clock rate control 677 * specific control that scans the sample rates on the external plugs 678 */ 679 static int pcxhr_clock_rate_info(struct snd_kcontrol *kcontrol, 680 struct snd_ctl_elem_info *uinfo) 681 { 682 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); 683 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 684 uinfo->count = 3 + mgr->capture_chips; 685 uinfo->value.integer.min = 0; /* clock not present */ 686 uinfo->value.integer.max = 192000; /* max sample rate 192 kHz */ 687 return 0; 688 } 689 690 static int pcxhr_clock_rate_get(struct snd_kcontrol *kcontrol, 691 struct snd_ctl_elem_value *ucontrol) 692 { 693 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); 694 int i, err, rate; 695 696 mutex_lock(&mgr->mixer_mutex); 697 for(i = 0; i < 3 + mgr->capture_chips; i++) { 698 if (i == PCXHR_CLOCK_TYPE_INTERNAL) 699 rate = mgr->sample_rate_real; 700 else { 701 err = pcxhr_get_external_clock(mgr, i, &rate); 702 if (err) 703 break; 704 } 705 ucontrol->value.integer.value[i] = rate; 706 } 707 mutex_unlock(&mgr->mixer_mutex); 708 return 0; 709 } 710 711 static struct snd_kcontrol_new pcxhr_control_clock_rate = { 712 .access = SNDRV_CTL_ELEM_ACCESS_READ, 713 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 714 .name = "Clock Rates", 715 .info = pcxhr_clock_rate_info, 716 .get = pcxhr_clock_rate_get, 717 }; 718 719 /* 720 * IEC958 status bits 721 */ 722 static int pcxhr_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 723 { 724 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 725 uinfo->count = 1; 726 return 0; 727 } 728 729 static int pcxhr_iec958_capture_byte(struct snd_pcxhr *chip, int aes_idx, unsigned char* aes_bits) 730 { 731 int i, err; 732 unsigned char temp; 733 struct pcxhr_rmh rmh; 734 735 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ); 736 rmh.cmd[0] |= IO_NUM_UER_CHIP_REG; 737 switch (chip->chip_idx) { 738 case 0: rmh.cmd[1] = CS8420_01_CS; break; /* use CS8416_01_CS for AES SYNC plug */ 739 case 1: rmh.cmd[1] = CS8420_23_CS; break; 740 case 2: rmh.cmd[1] = CS8420_45_CS; break; 741 case 3: rmh.cmd[1] = CS8420_67_CS; break; 742 default: return -EINVAL; 743 } 744 switch (aes_idx) { 745 case 0: rmh.cmd[2] = CS8420_CSB0; break; /* use CS8416_CSBx for AES SYNC plug */ 746 case 1: rmh.cmd[2] = CS8420_CSB1; break; 747 case 2: rmh.cmd[2] = CS8420_CSB2; break; 748 case 3: rmh.cmd[2] = CS8420_CSB3; break; 749 case 4: rmh.cmd[2] = CS8420_CSB4; break; 750 default: return -EINVAL; 751 } 752 rmh.cmd[1] &= 0x0fffff; /* size and code the chip id for the fpga */ 753 rmh.cmd[2] &= CHIP_SIG_AND_MAP_SPI; /* chip signature + map for spi read */ 754 rmh.cmd_len = 3; 755 err = pcxhr_send_msg(chip->mgr, &rmh); 756 if (err) 757 return err; 758 temp = 0; 759 for (i = 0; i < 8; i++) { 760 /* attention : reversed bit order (not with CS8416_01_CS) */ 761 temp <<= 1; 762 if (rmh.stat[1] & (1 << i)) 763 temp |= 1; 764 } 765 snd_printdd("read iec958 AES %d byte %d = 0x%x\n", chip->chip_idx, aes_idx, temp); 766 *aes_bits = temp; 767 return 0; 768 } 769 770 static int pcxhr_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 771 { 772 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 773 unsigned char aes_bits; 774 int i, err; 775 776 mutex_lock(&chip->mgr->mixer_mutex); 777 for(i = 0; i < 5; i++) { 778 if (kcontrol->private_value == 0) /* playback */ 779 aes_bits = chip->aes_bits[i]; 780 else { /* capture */ 781 err = pcxhr_iec958_capture_byte(chip, i, &aes_bits); 782 if (err) 783 break; 784 } 785 ucontrol->value.iec958.status[i] = aes_bits; 786 } 787 mutex_unlock(&chip->mgr->mixer_mutex); 788 return 0; 789 } 790 791 static int pcxhr_iec958_mask_get(struct snd_kcontrol *kcontrol, 792 struct snd_ctl_elem_value *ucontrol) 793 { 794 int i; 795 for (i = 0; i < 5; i++) 796 ucontrol->value.iec958.status[i] = 0xff; 797 return 0; 798 } 799 800 static int pcxhr_iec958_update_byte(struct snd_pcxhr *chip, int aes_idx, unsigned char aes_bits) 801 { 802 int i, err, cmd; 803 unsigned char new_bits = aes_bits; 804 unsigned char old_bits = chip->aes_bits[aes_idx]; 805 struct pcxhr_rmh rmh; 806 807 for (i = 0; i < 8; i++) { 808 if ((old_bits & 0x01) != (new_bits & 0x01)) { 809 cmd = chip->chip_idx & 0x03; /* chip index 0..3 */ 810 if(chip->chip_idx > 3) 811 /* new bit used if chip_idx>3 (PCX1222HR) */ 812 cmd |= 1 << 22; 813 cmd |= ((aes_idx << 3) + i) << 2; /* add bit offset */ 814 cmd |= (new_bits & 0x01) << 23; /* add bit value */ 815 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); 816 rmh.cmd[0] |= IO_NUM_REG_CUER; 817 rmh.cmd[1] = cmd; 818 rmh.cmd_len = 2; 819 snd_printdd("write iec958 AES %d byte %d bit %d (cmd %x)\n", 820 chip->chip_idx, aes_idx, i, cmd); 821 err = pcxhr_send_msg(chip->mgr, &rmh); 822 if (err) 823 return err; 824 } 825 old_bits >>= 1; 826 new_bits >>= 1; 827 } 828 chip->aes_bits[aes_idx] = aes_bits; 829 return 0; 830 } 831 832 static int pcxhr_iec958_put(struct snd_kcontrol *kcontrol, 833 struct snd_ctl_elem_value *ucontrol) 834 { 835 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); 836 int i, changed = 0; 837 838 /* playback */ 839 mutex_lock(&chip->mgr->mixer_mutex); 840 for (i = 0; i < 5; i++) { 841 if (ucontrol->value.iec958.status[i] != chip->aes_bits[i]) { 842 pcxhr_iec958_update_byte(chip, i, ucontrol->value.iec958.status[i]); 843 changed = 1; 844 } 845 } 846 mutex_unlock(&chip->mgr->mixer_mutex); 847 return changed; 848 } 849 850 static struct snd_kcontrol_new pcxhr_control_playback_iec958_mask = { 851 .access = SNDRV_CTL_ELEM_ACCESS_READ, 852 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 853 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), 854 .info = pcxhr_iec958_info, 855 .get = pcxhr_iec958_mask_get 856 }; 857 static struct snd_kcontrol_new pcxhr_control_playback_iec958 = { 858 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 859 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 860 .info = pcxhr_iec958_info, 861 .get = pcxhr_iec958_get, 862 .put = pcxhr_iec958_put, 863 .private_value = 0 /* playback */ 864 }; 865 866 static struct snd_kcontrol_new pcxhr_control_capture_iec958_mask = { 867 .access = SNDRV_CTL_ELEM_ACCESS_READ, 868 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 869 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,MASK), 870 .info = pcxhr_iec958_info, 871 .get = pcxhr_iec958_mask_get 872 }; 873 static struct snd_kcontrol_new pcxhr_control_capture_iec958 = { 874 .access = SNDRV_CTL_ELEM_ACCESS_READ, 875 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 876 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT), 877 .info = pcxhr_iec958_info, 878 .get = pcxhr_iec958_get, 879 .private_value = 1 /* capture */ 880 }; 881 882 static void pcxhr_init_audio_levels(struct snd_pcxhr *chip) 883 { 884 int i; 885 886 for (i = 0; i < 2; i++) { 887 if (chip->nb_streams_play) { 888 int j; 889 /* at boot time the digital volumes are unmuted 0dB */ 890 for (j = 0; j < PCXHR_PLAYBACK_STREAMS; j++) { 891 chip->digital_playback_active[j][i] = 1; 892 chip->digital_playback_volume[j][i] = PCXHR_DIGITAL_ZERO_LEVEL; 893 } 894 /* after boot, only two bits are set on the uer interface */ 895 chip->aes_bits[0] = IEC958_AES0_PROFESSIONAL | IEC958_AES0_PRO_FS_48000; 896 /* only for test purpose, remove later */ 897 #ifdef CONFIG_SND_DEBUG 898 /* analog volumes for playback (is LEVEL_MIN after boot) */ 899 chip->analog_playback_active[i] = 1; 900 chip->analog_playback_volume[i] = PCXHR_ANALOG_PLAYBACK_ZERO_LEVEL; 901 pcxhr_update_analog_audio_level(chip, 0, i); 902 #endif 903 /* test end */ 904 } 905 if (chip->nb_streams_capt) { 906 /* at boot time the digital volumes are unmuted 0dB */ 907 chip->digital_capture_volume[i] = PCXHR_DIGITAL_ZERO_LEVEL; 908 /* only for test purpose, remove later */ 909 #ifdef CONFIG_SND_DEBUG 910 /* analog volumes for playback (is LEVEL_MIN after boot) */ 911 chip->analog_capture_volume[i] = PCXHR_ANALOG_CAPTURE_ZERO_LEVEL; 912 pcxhr_update_analog_audio_level(chip, 1, i); 913 #endif 914 /* test end */ 915 } 916 } 917 918 return; 919 } 920 921 922 int pcxhr_create_mixer(struct pcxhr_mgr *mgr) 923 { 924 struct snd_pcxhr *chip; 925 int err, i; 926 927 mutex_init(&mgr->mixer_mutex); /* can be in another place */ 928 929 for (i = 0; i < mgr->num_cards; i++) { 930 struct snd_kcontrol_new temp; 931 chip = mgr->chip[i]; 932 933 if (chip->nb_streams_play) { 934 /* analog output level control */ 935 temp = pcxhr_control_analog_level; 936 temp.name = "Master Playback Volume"; 937 temp.private_value = 0; /* playback */ 938 temp.tlv.p = db_scale_analog_playback; 939 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0) 940 return err; 941 /* output mute controls */ 942 if ((err = snd_ctl_add(chip->card, 943 snd_ctl_new1(&pcxhr_control_output_switch, 944 chip))) < 0) 945 return err; 946 947 temp = snd_pcxhr_pcm_vol; 948 temp.name = "PCM Playback Volume"; 949 temp.count = PCXHR_PLAYBACK_STREAMS; 950 temp.private_value = 0; /* playback */ 951 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0) 952 return err; 953 954 if ((err = snd_ctl_add(chip->card, 955 snd_ctl_new1(&pcxhr_control_pcm_switch, 956 chip))) < 0) 957 return err; 958 959 /* IEC958 controls */ 960 if ((err = snd_ctl_add(chip->card, 961 snd_ctl_new1(&pcxhr_control_playback_iec958_mask, 962 chip))) < 0) 963 return err; 964 if ((err = snd_ctl_add(chip->card, 965 snd_ctl_new1(&pcxhr_control_playback_iec958, 966 chip))) < 0) 967 return err; 968 } 969 if (chip->nb_streams_capt) { 970 /* analog input level control only on first two chips !*/ 971 temp = pcxhr_control_analog_level; 972 temp.name = "Master Capture Volume"; 973 temp.private_value = 1; /* capture */ 974 temp.tlv.p = db_scale_analog_capture; 975 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0) 976 return err; 977 978 temp = snd_pcxhr_pcm_vol; 979 temp.name = "PCM Capture Volume"; 980 temp.count = 1; 981 temp.private_value = 1; /* capture */ 982 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0) 983 return err; 984 /* Audio source */ 985 if ((err = snd_ctl_add(chip->card, 986 snd_ctl_new1(&pcxhr_control_audio_src, 987 chip))) < 0) 988 return err; 989 /* IEC958 controls */ 990 if ((err = snd_ctl_add(chip->card, 991 snd_ctl_new1(&pcxhr_control_capture_iec958_mask, 992 chip))) < 0) 993 return err; 994 if ((err = snd_ctl_add(chip->card, 995 snd_ctl_new1(&pcxhr_control_capture_iec958, 996 chip))) < 0) 997 return err; 998 } 999 /* monitoring only if playback and capture device available */ 1000 if (chip->nb_streams_capt > 0 && chip->nb_streams_play > 0) { 1001 /* monitoring */ 1002 if ((err = snd_ctl_add(chip->card, 1003 snd_ctl_new1(&pcxhr_control_monitor_vol, 1004 chip))) < 0) 1005 return err; 1006 if ((err = snd_ctl_add(chip->card, 1007 snd_ctl_new1(&pcxhr_control_monitor_sw, 1008 chip))) < 0) 1009 return err; 1010 } 1011 1012 if (i == 0) { 1013 /* clock mode only one control per pcxhr */ 1014 if ((err = snd_ctl_add(chip->card, 1015 snd_ctl_new1(&pcxhr_control_clock_type, 1016 mgr))) < 0) 1017 return err; 1018 /* non standard control used to scan the external clock presence/frequencies */ 1019 if ((err = snd_ctl_add(chip->card, 1020 snd_ctl_new1(&pcxhr_control_clock_rate, 1021 mgr))) < 0) 1022 return err; 1023 } 1024 1025 /* init values for the mixer data */ 1026 pcxhr_init_audio_levels(chip); 1027 } 1028 1029 return 0; 1030 } 1031