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