1247 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2#define __NO_VERSION__3/*4 * Driver for Digigram pcxhr compatible soundcards5 *6 * mixer callbacks7 *8 * Copyright (c) 2004 by Digigram <alsa@digigram.com>9 */10 11#include <linux/time.h>12#include <linux/interrupt.h>13#include <linux/init.h>14#include <linux/mutex.h>15#include <sound/core.h>16#include "pcxhr.h"17#include "pcxhr_hwdep.h"18#include "pcxhr_core.h"19#include <sound/control.h>20#include <sound/tlv.h>21#include <sound/asoundef.h>22#include "pcxhr_mixer.h"23#include "pcxhr_mix22.h"24 25#define PCXHR_LINE_CAPTURE_LEVEL_MIN 0 /* -112.0 dB */26#define PCXHR_LINE_CAPTURE_LEVEL_MAX 255 /* +15.5 dB */27#define PCXHR_LINE_CAPTURE_ZERO_LEVEL 224 /* 0.0 dB ( 0 dBu -> 0 dBFS ) */28 29#define PCXHR_LINE_PLAYBACK_LEVEL_MIN 0 /* -104.0 dB */30#define PCXHR_LINE_PLAYBACK_LEVEL_MAX 128 /* +24.0 dB */31#define PCXHR_LINE_PLAYBACK_ZERO_LEVEL 104 /* 0.0 dB ( 0 dBFS -> 0 dBu ) */32 33static const DECLARE_TLV_DB_SCALE(db_scale_analog_capture, -11200, 50, 1550);34static const DECLARE_TLV_DB_SCALE(db_scale_analog_playback, -10400, 100, 2400);35 36static const DECLARE_TLV_DB_SCALE(db_scale_a_hr222_capture, -11150, 50, 1600);37static const DECLARE_TLV_DB_SCALE(db_scale_a_hr222_playback, -2550, 50, 2400);38 39static int pcxhr_update_analog_audio_level(struct snd_pcxhr *chip,40 int is_capture, int channel)41{42 int err, vol;43 struct pcxhr_rmh rmh;44 45 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);46 if (is_capture) {47 rmh.cmd[0] |= IO_NUM_REG_IN_ANA_LEVEL;48 rmh.cmd[2] = chip->analog_capture_volume[channel];49 } else {50 rmh.cmd[0] |= IO_NUM_REG_OUT_ANA_LEVEL;51 if (chip->analog_playback_active[channel])52 vol = chip->analog_playback_volume[channel];53 else54 vol = PCXHR_LINE_PLAYBACK_LEVEL_MIN;55 /* playback analog levels are inversed */56 rmh.cmd[2] = PCXHR_LINE_PLAYBACK_LEVEL_MAX - vol;57 }58 rmh.cmd[1] = 1 << ((2 * chip->chip_idx) + channel); /* audio mask */59 rmh.cmd_len = 3;60 err = pcxhr_send_msg(chip->mgr, &rmh);61 if (err < 0) {62 dev_dbg(chip->card->dev,63 "error update_analog_audio_level card(%d)"64 " is_capture(%d) err(%x)\n",65 chip->chip_idx, is_capture, err);66 return -EINVAL;67 }68 return 0;69}70 71/*72 * analog level control73 */74static int pcxhr_analog_vol_info(struct snd_kcontrol *kcontrol,75 struct snd_ctl_elem_info *uinfo)76{77 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);78 79 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;80 uinfo->count = 2;81 if (kcontrol->private_value == 0) { /* playback */82 if (chip->mgr->is_hr_stereo) {83 uinfo->value.integer.min =84 HR222_LINE_PLAYBACK_LEVEL_MIN; /* -25 dB */85 uinfo->value.integer.max =86 HR222_LINE_PLAYBACK_LEVEL_MAX; /* +24 dB */87 } else {88 uinfo->value.integer.min =89 PCXHR_LINE_PLAYBACK_LEVEL_MIN; /*-104 dB */90 uinfo->value.integer.max =91 PCXHR_LINE_PLAYBACK_LEVEL_MAX; /* +24 dB */92 }93 } else { /* capture */94 if (chip->mgr->is_hr_stereo) {95 uinfo->value.integer.min =96 HR222_LINE_CAPTURE_LEVEL_MIN; /*-112 dB */97 uinfo->value.integer.max =98 HR222_LINE_CAPTURE_LEVEL_MAX; /* +15.5 dB */99 } else {100 uinfo->value.integer.min =101 PCXHR_LINE_CAPTURE_LEVEL_MIN; /*-112 dB */102 uinfo->value.integer.max =103 PCXHR_LINE_CAPTURE_LEVEL_MAX; /* +15.5 dB */104 }105 }106 return 0;107}108 109static int pcxhr_analog_vol_get(struct snd_kcontrol *kcontrol,110 struct snd_ctl_elem_value *ucontrol)111{112 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);113 mutex_lock(&chip->mgr->mixer_mutex);114 if (kcontrol->private_value == 0) { /* playback */115 ucontrol->value.integer.value[0] = chip->analog_playback_volume[0];116 ucontrol->value.integer.value[1] = chip->analog_playback_volume[1];117 } else { /* capture */118 ucontrol->value.integer.value[0] = chip->analog_capture_volume[0];119 ucontrol->value.integer.value[1] = chip->analog_capture_volume[1];120 }121 mutex_unlock(&chip->mgr->mixer_mutex);122 return 0;123}124 125static int pcxhr_analog_vol_put(struct snd_kcontrol *kcontrol,126 struct snd_ctl_elem_value *ucontrol)127{128 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);129 int changed = 0;130 int is_capture, i;131 132 mutex_lock(&chip->mgr->mixer_mutex);133 is_capture = (kcontrol->private_value != 0);134 for (i = 0; i < 2; i++) {135 int new_volume = ucontrol->value.integer.value[i];136 int *stored_volume = is_capture ?137 &chip->analog_capture_volume[i] :138 &chip->analog_playback_volume[i];139 if (is_capture) {140 if (chip->mgr->is_hr_stereo) {141 if (new_volume < HR222_LINE_CAPTURE_LEVEL_MIN ||142 new_volume > HR222_LINE_CAPTURE_LEVEL_MAX)143 continue;144 } else {145 if (new_volume < PCXHR_LINE_CAPTURE_LEVEL_MIN ||146 new_volume > PCXHR_LINE_CAPTURE_LEVEL_MAX)147 continue;148 }149 } else {150 if (chip->mgr->is_hr_stereo) {151 if (new_volume < HR222_LINE_PLAYBACK_LEVEL_MIN ||152 new_volume > HR222_LINE_PLAYBACK_LEVEL_MAX)153 continue;154 } else {155 if (new_volume < PCXHR_LINE_PLAYBACK_LEVEL_MIN ||156 new_volume > PCXHR_LINE_PLAYBACK_LEVEL_MAX)157 continue;158 }159 }160 if (*stored_volume != new_volume) {161 *stored_volume = new_volume;162 changed = 1;163 if (chip->mgr->is_hr_stereo)164 hr222_update_analog_audio_level(chip,165 is_capture, i);166 else167 pcxhr_update_analog_audio_level(chip,168 is_capture, i);169 }170 }171 mutex_unlock(&chip->mgr->mixer_mutex);172 return changed;173}174 175static const struct snd_kcontrol_new pcxhr_control_analog_level = {176 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,177 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |178 SNDRV_CTL_ELEM_ACCESS_TLV_READ),179 /* name will be filled later */180 .info = pcxhr_analog_vol_info,181 .get = pcxhr_analog_vol_get,182 .put = pcxhr_analog_vol_put,183 /* tlv will be filled later */184};185 186/* shared */187 188#define pcxhr_sw_info snd_ctl_boolean_stereo_info189 190static int pcxhr_audio_sw_get(struct snd_kcontrol *kcontrol,191 struct snd_ctl_elem_value *ucontrol)192{193 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);194 195 mutex_lock(&chip->mgr->mixer_mutex);196 ucontrol->value.integer.value[0] = chip->analog_playback_active[0];197 ucontrol->value.integer.value[1] = chip->analog_playback_active[1];198 mutex_unlock(&chip->mgr->mixer_mutex);199 return 0;200}201 202static int pcxhr_audio_sw_put(struct snd_kcontrol *kcontrol,203 struct snd_ctl_elem_value *ucontrol)204{205 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);206 int i, changed = 0;207 mutex_lock(&chip->mgr->mixer_mutex);208 for(i = 0; i < 2; i++) {209 if (chip->analog_playback_active[i] !=210 ucontrol->value.integer.value[i]) {211 chip->analog_playback_active[i] =212 !!ucontrol->value.integer.value[i];213 changed = 1;214 /* update playback levels */215 if (chip->mgr->is_hr_stereo)216 hr222_update_analog_audio_level(chip, 0, i);217 else218 pcxhr_update_analog_audio_level(chip, 0, i);219 }220 }221 mutex_unlock(&chip->mgr->mixer_mutex);222 return changed;223}224 225static const struct snd_kcontrol_new pcxhr_control_output_switch = {226 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,227 .name = "Master Playback Switch",228 .info = pcxhr_sw_info, /* shared */229 .get = pcxhr_audio_sw_get,230 .put = pcxhr_audio_sw_put231};232 233 234#define PCXHR_DIGITAL_LEVEL_MIN 0x000 /* -110 dB */235#define PCXHR_DIGITAL_LEVEL_MAX 0x1ff /* +18 dB */236#define PCXHR_DIGITAL_ZERO_LEVEL 0x1b7 /* 0 dB */237 238static const DECLARE_TLV_DB_SCALE(db_scale_digital, -10975, 25, 1800);239 240#define MORE_THAN_ONE_STREAM_LEVEL 0x000001241#define VALID_STREAM_PAN_LEVEL_MASK 0x800000242#define VALID_STREAM_LEVEL_MASK 0x400000243#define VALID_STREAM_LEVEL_1_MASK 0x200000244#define VALID_STREAM_LEVEL_2_MASK 0x100000245 246static int pcxhr_update_playback_stream_level(struct snd_pcxhr* chip, int idx)247{248 int err;249 struct pcxhr_rmh rmh;250 struct pcxhr_pipe *pipe = &chip->playback_pipe;251 int left, right;252 253 if (chip->digital_playback_active[idx][0])254 left = chip->digital_playback_volume[idx][0];255 else256 left = PCXHR_DIGITAL_LEVEL_MIN;257 if (chip->digital_playback_active[idx][1])258 right = chip->digital_playback_volume[idx][1];259 else260 right = PCXHR_DIGITAL_LEVEL_MIN;261 262 pcxhr_init_rmh(&rmh, CMD_STREAM_OUT_LEVEL_ADJUST);263 /* add pipe and stream mask */264 pcxhr_set_pipe_cmd_params(&rmh, 0, pipe->first_audio, 0, 1<<idx);265 /* volume left->left / right->right panoramic level */266 rmh.cmd[0] |= MORE_THAN_ONE_STREAM_LEVEL;267 rmh.cmd[2] = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_1_MASK;268 rmh.cmd[2] |= (left << 10);269 rmh.cmd[3] = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_2_MASK;270 rmh.cmd[3] |= right;271 rmh.cmd_len = 4;272 273 err = pcxhr_send_msg(chip->mgr, &rmh);274 if (err < 0) {275 dev_dbg(chip->card->dev, "error update_playback_stream_level "276 "card(%d) err(%x)\n", chip->chip_idx, err);277 return -EINVAL;278 }279 return 0;280}281 282#define AUDIO_IO_HAS_MUTE_LEVEL 0x400000283#define AUDIO_IO_HAS_MUTE_MONITOR_1 0x200000284#define VALID_AUDIO_IO_DIGITAL_LEVEL 0x000001285#define VALID_AUDIO_IO_MONITOR_LEVEL 0x000002286#define VALID_AUDIO_IO_MUTE_LEVEL 0x000004287#define VALID_AUDIO_IO_MUTE_MONITOR_1 0x000008288 289static int pcxhr_update_audio_pipe_level(struct snd_pcxhr *chip,290 int capture, int channel)291{292 int err;293 struct pcxhr_rmh rmh;294 struct pcxhr_pipe *pipe;295 296 if (capture)297 pipe = &chip->capture_pipe[0];298 else299 pipe = &chip->playback_pipe;300 301 pcxhr_init_rmh(&rmh, CMD_AUDIO_LEVEL_ADJUST);302 /* add channel mask */303 pcxhr_set_pipe_cmd_params(&rmh, capture, 0, 0,304 1 << (channel + pipe->first_audio));305 /* TODO : if mask (3 << pipe->first_audio) is used, left and right306 * channel will be programmed to the same params */307 if (capture) {308 rmh.cmd[0] |= VALID_AUDIO_IO_DIGITAL_LEVEL;309 /* VALID_AUDIO_IO_MUTE_LEVEL not yet handled310 * (capture pipe level) */311 rmh.cmd[2] = chip->digital_capture_volume[channel];312 } else {313 rmh.cmd[0] |= VALID_AUDIO_IO_MONITOR_LEVEL |314 VALID_AUDIO_IO_MUTE_MONITOR_1;315 /* VALID_AUDIO_IO_DIGITAL_LEVEL and VALID_AUDIO_IO_MUTE_LEVEL316 * not yet handled (playback pipe level)317 */318 rmh.cmd[2] = chip->monitoring_volume[channel] << 10;319 if (chip->monitoring_active[channel] == 0)320 rmh.cmd[2] |= AUDIO_IO_HAS_MUTE_MONITOR_1;321 }322 rmh.cmd_len = 3;323 324 err = pcxhr_send_msg(chip->mgr, &rmh);325 if (err < 0) {326 dev_dbg(chip->card->dev,327 "error update_audio_level(%d) err=%x\n",328 chip->chip_idx, err);329 return -EINVAL;330 }331 return 0;332}333 334 335/* shared */336static int pcxhr_digital_vol_info(struct snd_kcontrol *kcontrol,337 struct snd_ctl_elem_info *uinfo)338{339 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;340 uinfo->count = 2;341 uinfo->value.integer.min = PCXHR_DIGITAL_LEVEL_MIN; /* -109.5 dB */342 uinfo->value.integer.max = PCXHR_DIGITAL_LEVEL_MAX; /* 18.0 dB */343 return 0;344}345 346 347static int pcxhr_pcm_vol_get(struct snd_kcontrol *kcontrol,348 struct snd_ctl_elem_value *ucontrol)349{350 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);351 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */352 int *stored_volume;353 int is_capture = kcontrol->private_value;354 355 mutex_lock(&chip->mgr->mixer_mutex);356 if (is_capture) /* digital capture */357 stored_volume = chip->digital_capture_volume;358 else /* digital playback */359 stored_volume = chip->digital_playback_volume[idx];360 ucontrol->value.integer.value[0] = stored_volume[0];361 ucontrol->value.integer.value[1] = stored_volume[1];362 mutex_unlock(&chip->mgr->mixer_mutex);363 return 0;364}365 366static int pcxhr_pcm_vol_put(struct snd_kcontrol *kcontrol,367 struct snd_ctl_elem_value *ucontrol)368{369 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);370 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */371 int changed = 0;372 int is_capture = kcontrol->private_value;373 int *stored_volume;374 int i;375 376 mutex_lock(&chip->mgr->mixer_mutex);377 if (is_capture) /* digital capture */378 stored_volume = chip->digital_capture_volume;379 else /* digital playback */380 stored_volume = chip->digital_playback_volume[idx];381 for (i = 0; i < 2; i++) {382 int vol = ucontrol->value.integer.value[i];383 if (vol < PCXHR_DIGITAL_LEVEL_MIN ||384 vol > PCXHR_DIGITAL_LEVEL_MAX)385 continue;386 if (stored_volume[i] != vol) {387 stored_volume[i] = vol;388 changed = 1;389 if (is_capture) /* update capture volume */390 pcxhr_update_audio_pipe_level(chip, 1, i);391 }392 }393 if (!is_capture && changed) /* update playback volume */394 pcxhr_update_playback_stream_level(chip, idx);395 mutex_unlock(&chip->mgr->mixer_mutex);396 return changed;397}398 399static const struct snd_kcontrol_new snd_pcxhr_pcm_vol =400{401 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,402 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |403 SNDRV_CTL_ELEM_ACCESS_TLV_READ),404 /* name will be filled later */405 /* count will be filled later */406 .info = pcxhr_digital_vol_info, /* shared */407 .get = pcxhr_pcm_vol_get,408 .put = pcxhr_pcm_vol_put,409 .tlv = { .p = db_scale_digital },410};411 412 413static int pcxhr_pcm_sw_get(struct snd_kcontrol *kcontrol,414 struct snd_ctl_elem_value *ucontrol)415{416 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);417 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */418 419 mutex_lock(&chip->mgr->mixer_mutex);420 ucontrol->value.integer.value[0] = chip->digital_playback_active[idx][0];421 ucontrol->value.integer.value[1] = chip->digital_playback_active[idx][1];422 mutex_unlock(&chip->mgr->mixer_mutex);423 return 0;424}425 426static int pcxhr_pcm_sw_put(struct snd_kcontrol *kcontrol,427 struct snd_ctl_elem_value *ucontrol)428{429 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);430 int changed = 0;431 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */432 int i, j;433 434 mutex_lock(&chip->mgr->mixer_mutex);435 j = idx;436 for (i = 0; i < 2; i++) {437 if (chip->digital_playback_active[j][i] !=438 ucontrol->value.integer.value[i]) {439 chip->digital_playback_active[j][i] =440 !!ucontrol->value.integer.value[i];441 changed = 1;442 }443 }444 if (changed)445 pcxhr_update_playback_stream_level(chip, idx);446 mutex_unlock(&chip->mgr->mixer_mutex);447 return changed;448}449 450static const struct snd_kcontrol_new pcxhr_control_pcm_switch = {451 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,452 .name = "PCM Playback Switch",453 .count = PCXHR_PLAYBACK_STREAMS,454 .info = pcxhr_sw_info, /* shared */455 .get = pcxhr_pcm_sw_get,456 .put = pcxhr_pcm_sw_put457};458 459 460/*461 * monitoring level control462 */463 464static int pcxhr_monitor_vol_get(struct snd_kcontrol *kcontrol,465 struct snd_ctl_elem_value *ucontrol)466{467 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);468 mutex_lock(&chip->mgr->mixer_mutex);469 ucontrol->value.integer.value[0] = chip->monitoring_volume[0];470 ucontrol->value.integer.value[1] = chip->monitoring_volume[1];471 mutex_unlock(&chip->mgr->mixer_mutex);472 return 0;473}474 475static int pcxhr_monitor_vol_put(struct snd_kcontrol *kcontrol,476 struct snd_ctl_elem_value *ucontrol)477{478 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);479 int changed = 0;480 int i;481 482 mutex_lock(&chip->mgr->mixer_mutex);483 for (i = 0; i < 2; i++) {484 if (chip->monitoring_volume[i] !=485 ucontrol->value.integer.value[i]) {486 chip->monitoring_volume[i] =487 ucontrol->value.integer.value[i];488 if (chip->monitoring_active[i])489 /* update monitoring volume and mute */490 /* do only when monitoring is unmuted */491 pcxhr_update_audio_pipe_level(chip, 0, i);492 changed = 1;493 }494 }495 mutex_unlock(&chip->mgr->mixer_mutex);496 return changed;497}498 499static const struct snd_kcontrol_new pcxhr_control_monitor_vol = {500 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,501 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |502 SNDRV_CTL_ELEM_ACCESS_TLV_READ),503 .name = "Monitoring Playback Volume",504 .info = pcxhr_digital_vol_info, /* shared */505 .get = pcxhr_monitor_vol_get,506 .put = pcxhr_monitor_vol_put,507 .tlv = { .p = db_scale_digital },508};509 510/*511 * monitoring switch control512 */513 514static int pcxhr_monitor_sw_get(struct snd_kcontrol *kcontrol,515 struct snd_ctl_elem_value *ucontrol)516{517 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);518 mutex_lock(&chip->mgr->mixer_mutex);519 ucontrol->value.integer.value[0] = chip->monitoring_active[0];520 ucontrol->value.integer.value[1] = chip->monitoring_active[1];521 mutex_unlock(&chip->mgr->mixer_mutex);522 return 0;523}524 525static int pcxhr_monitor_sw_put(struct snd_kcontrol *kcontrol,526 struct snd_ctl_elem_value *ucontrol)527{528 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);529 int changed = 0;530 int i;531 532 mutex_lock(&chip->mgr->mixer_mutex);533 for (i = 0; i < 2; i++) {534 if (chip->monitoring_active[i] !=535 ucontrol->value.integer.value[i]) {536 chip->monitoring_active[i] =537 !!ucontrol->value.integer.value[i];538 changed |= (1<<i); /* mask 0x01 and 0x02 */539 }540 }541 if (changed & 0x01)542 /* update left monitoring volume and mute */543 pcxhr_update_audio_pipe_level(chip, 0, 0);544 if (changed & 0x02)545 /* update right monitoring volume and mute */546 pcxhr_update_audio_pipe_level(chip, 0, 1);547 548 mutex_unlock(&chip->mgr->mixer_mutex);549 return (changed != 0);550}551 552static const struct snd_kcontrol_new pcxhr_control_monitor_sw = {553 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,554 .name = "Monitoring Playback Switch",555 .info = pcxhr_sw_info, /* shared */556 .get = pcxhr_monitor_sw_get,557 .put = pcxhr_monitor_sw_put558};559 560 561 562/*563 * audio source select564 */565#define PCXHR_SOURCE_AUDIO01_UER 0x000100566#define PCXHR_SOURCE_AUDIO01_SYNC 0x000200567#define PCXHR_SOURCE_AUDIO23_UER 0x000400568#define PCXHR_SOURCE_AUDIO45_UER 0x001000569#define PCXHR_SOURCE_AUDIO67_UER 0x040000570 571static int pcxhr_set_audio_source(struct snd_pcxhr* chip)572{573 struct pcxhr_rmh rmh;574 unsigned int mask, reg;575 unsigned int codec;576 int err, changed;577 578 switch (chip->chip_idx) {579 case 0 : mask = PCXHR_SOURCE_AUDIO01_UER; codec = CS8420_01_CS; break;580 case 1 : mask = PCXHR_SOURCE_AUDIO23_UER; codec = CS8420_23_CS; break;581 case 2 : mask = PCXHR_SOURCE_AUDIO45_UER; codec = CS8420_45_CS; break;582 case 3 : mask = PCXHR_SOURCE_AUDIO67_UER; codec = CS8420_67_CS; break;583 default: return -EINVAL;584 }585 if (chip->audio_capture_source != 0) {586 reg = mask; /* audio source from digital plug */587 } else {588 reg = 0; /* audio source from analog plug */589 }590 /* set the input source */591 pcxhr_write_io_num_reg_cont(chip->mgr, mask, reg, &changed);592 /* resync them (otherwise channel inversion possible) */593 if (changed) {594 pcxhr_init_rmh(&rmh, CMD_RESYNC_AUDIO_INPUTS);595 rmh.cmd[0] |= (1 << chip->chip_idx);596 err = pcxhr_send_msg(chip->mgr, &rmh);597 if (err)598 return err;599 }600 if (chip->mgr->board_aes_in_192k) {601 int i;602 unsigned int src_config = 0xC0;603 /* update all src configs with one call */604 for (i = 0; (i < 4) && (i < chip->mgr->capture_chips); i++) {605 if (chip->mgr->chip[i]->audio_capture_source == 2)606 src_config |= (1 << (3 - i));607 }608 /* set codec SRC on off */609 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);610 rmh.cmd_len = 2;611 rmh.cmd[0] |= IO_NUM_REG_CONFIG_SRC;612 rmh.cmd[1] = src_config;613 err = pcxhr_send_msg(chip->mgr, &rmh);614 } else {615 int use_src = 0;616 if (chip->audio_capture_source == 2)617 use_src = 1;618 /* set codec SRC on off */619 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);620 rmh.cmd_len = 3;621 rmh.cmd[0] |= IO_NUM_UER_CHIP_REG;622 rmh.cmd[1] = codec;623 rmh.cmd[2] = ((CS8420_DATA_FLOW_CTL & CHIP_SIG_AND_MAP_SPI) |624 (use_src ? 0x41 : 0x54));625 err = pcxhr_send_msg(chip->mgr, &rmh);626 if (err)627 return err;628 rmh.cmd[2] = ((CS8420_CLOCK_SRC_CTL & CHIP_SIG_AND_MAP_SPI) |629 (use_src ? 0x41 : 0x49));630 err = pcxhr_send_msg(chip->mgr, &rmh);631 }632 return err;633}634 635static int pcxhr_audio_src_info(struct snd_kcontrol *kcontrol,636 struct snd_ctl_elem_info *uinfo)637{638 static const char *texts[5] = {639 "Line", "Digital", "Digi+SRC", "Mic", "Line+Mic"640 };641 int i;642 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);643 644 i = 2; /* no SRC, no Mic available */645 if (chip->mgr->board_has_aes1) {646 i = 3; /* SRC available */647 if (chip->mgr->board_has_mic)648 i = 5; /* Mic and MicroMix available */649 }650 return snd_ctl_enum_info(uinfo, 1, i, texts);651}652 653static int pcxhr_audio_src_get(struct snd_kcontrol *kcontrol,654 struct snd_ctl_elem_value *ucontrol)655{656 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);657 ucontrol->value.enumerated.item[0] = chip->audio_capture_source;658 return 0;659}660 661static int pcxhr_audio_src_put(struct snd_kcontrol *kcontrol,662 struct snd_ctl_elem_value *ucontrol)663{664 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);665 int ret = 0;666 int i = 2; /* no SRC, no Mic available */667 if (chip->mgr->board_has_aes1) {668 i = 3; /* SRC available */669 if (chip->mgr->board_has_mic)670 i = 5; /* Mic and MicroMix available */671 }672 if (ucontrol->value.enumerated.item[0] >= i)673 return -EINVAL;674 mutex_lock(&chip->mgr->mixer_mutex);675 if (chip->audio_capture_source != ucontrol->value.enumerated.item[0]) {676 chip->audio_capture_source = ucontrol->value.enumerated.item[0];677 if (chip->mgr->is_hr_stereo)678 hr222_set_audio_source(chip);679 else680 pcxhr_set_audio_source(chip);681 ret = 1;682 }683 mutex_unlock(&chip->mgr->mixer_mutex);684 return ret;685}686 687static const struct snd_kcontrol_new pcxhr_control_audio_src = {688 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,689 .name = "Capture Source",690 .info = pcxhr_audio_src_info,691 .get = pcxhr_audio_src_get,692 .put = pcxhr_audio_src_put,693};694 695 696/*697 * clock type selection698 * enum pcxhr_clock_type {699 * PCXHR_CLOCK_TYPE_INTERNAL = 0,700 * PCXHR_CLOCK_TYPE_WORD_CLOCK,701 * PCXHR_CLOCK_TYPE_AES_SYNC,702 * PCXHR_CLOCK_TYPE_AES_1,703 * PCXHR_CLOCK_TYPE_AES_2,704 * PCXHR_CLOCK_TYPE_AES_3,705 * PCXHR_CLOCK_TYPE_AES_4,706 * PCXHR_CLOCK_TYPE_MAX = PCXHR_CLOCK_TYPE_AES_4,707 * HR22_CLOCK_TYPE_INTERNAL = PCXHR_CLOCK_TYPE_INTERNAL,708 * HR22_CLOCK_TYPE_AES_SYNC,709 * HR22_CLOCK_TYPE_AES_1,710 * HR22_CLOCK_TYPE_MAX = HR22_CLOCK_TYPE_AES_1,711 * };712 */713 714static int pcxhr_clock_type_info(struct snd_kcontrol *kcontrol,715 struct snd_ctl_elem_info *uinfo)716{717 static const char *textsPCXHR[7] = {718 "Internal", "WordClock", "AES Sync",719 "AES 1", "AES 2", "AES 3", "AES 4"720 };721 static const char *textsHR22[3] = {722 "Internal", "AES Sync", "AES 1"723 };724 const char **texts;725 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);726 int clock_items = 2; /* at least Internal and AES Sync clock */727 if (mgr->board_has_aes1) {728 clock_items += mgr->capture_chips; /* add AES x */729 if (!mgr->is_hr_stereo)730 clock_items += 1; /* add word clock */731 }732 if (mgr->is_hr_stereo) {733 texts = textsHR22;734 snd_BUG_ON(clock_items > (HR22_CLOCK_TYPE_MAX+1));735 } else {736 texts = textsPCXHR;737 snd_BUG_ON(clock_items > (PCXHR_CLOCK_TYPE_MAX+1));738 }739 return snd_ctl_enum_info(uinfo, 1, clock_items, texts);740}741 742static int pcxhr_clock_type_get(struct snd_kcontrol *kcontrol,743 struct snd_ctl_elem_value *ucontrol)744{745 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);746 ucontrol->value.enumerated.item[0] = mgr->use_clock_type;747 return 0;748}749 750static int pcxhr_clock_type_put(struct snd_kcontrol *kcontrol,751 struct snd_ctl_elem_value *ucontrol)752{753 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);754 int rate, ret = 0;755 unsigned int clock_items = 2; /* at least Internal and AES Sync clock */756 if (mgr->board_has_aes1) {757 clock_items += mgr->capture_chips; /* add AES x */758 if (!mgr->is_hr_stereo)759 clock_items += 1; /* add word clock */760 }761 if (ucontrol->value.enumerated.item[0] >= clock_items)762 return -EINVAL;763 mutex_lock(&mgr->mixer_mutex);764 if (mgr->use_clock_type != ucontrol->value.enumerated.item[0]) {765 mutex_lock(&mgr->setup_mutex);766 mgr->use_clock_type = ucontrol->value.enumerated.item[0];767 rate = 0;768 if (mgr->use_clock_type != PCXHR_CLOCK_TYPE_INTERNAL) {769 pcxhr_get_external_clock(mgr, mgr->use_clock_type,770 &rate);771 } else {772 rate = mgr->sample_rate;773 if (!rate)774 rate = 48000;775 }776 if (rate) {777 pcxhr_set_clock(mgr, rate);778 if (mgr->sample_rate)779 mgr->sample_rate = rate;780 }781 mutex_unlock(&mgr->setup_mutex);782 ret = 1; /* return 1 even if the set was not done. ok ? */783 }784 mutex_unlock(&mgr->mixer_mutex);785 return ret;786}787 788static const struct snd_kcontrol_new pcxhr_control_clock_type = {789 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,790 .name = "Clock Mode",791 .info = pcxhr_clock_type_info,792 .get = pcxhr_clock_type_get,793 .put = pcxhr_clock_type_put,794};795 796/*797 * clock rate control798 * specific control that scans the sample rates on the external plugs799 */800static int pcxhr_clock_rate_info(struct snd_kcontrol *kcontrol,801 struct snd_ctl_elem_info *uinfo)802{803 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);804 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;805 uinfo->count = 3 + mgr->capture_chips;806 uinfo->value.integer.min = 0; /* clock not present */807 uinfo->value.integer.max = 192000; /* max sample rate 192 kHz */808 return 0;809}810 811static int pcxhr_clock_rate_get(struct snd_kcontrol *kcontrol,812 struct snd_ctl_elem_value *ucontrol)813{814 struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);815 int i, err, rate;816 817 mutex_lock(&mgr->mixer_mutex);818 for(i = 0; i < 3 + mgr->capture_chips; i++) {819 if (i == PCXHR_CLOCK_TYPE_INTERNAL)820 rate = mgr->sample_rate_real;821 else {822 err = pcxhr_get_external_clock(mgr, i, &rate);823 if (err)824 break;825 }826 ucontrol->value.integer.value[i] = rate;827 }828 mutex_unlock(&mgr->mixer_mutex);829 return 0;830}831 832static const struct snd_kcontrol_new pcxhr_control_clock_rate = {833 .access = SNDRV_CTL_ELEM_ACCESS_READ,834 .iface = SNDRV_CTL_ELEM_IFACE_CARD,835 .name = "Clock Rates",836 .info = pcxhr_clock_rate_info,837 .get = pcxhr_clock_rate_get,838};839 840/*841 * IEC958 status bits842 */843static int pcxhr_iec958_info(struct snd_kcontrol *kcontrol,844 struct snd_ctl_elem_info *uinfo)845{846 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;847 uinfo->count = 1;848 return 0;849}850 851static int pcxhr_iec958_capture_byte(struct snd_pcxhr *chip,852 int aes_idx, unsigned char *aes_bits)853{854 int i, err;855 unsigned char temp;856 struct pcxhr_rmh rmh;857 858 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ);859 rmh.cmd[0] |= IO_NUM_UER_CHIP_REG;860 switch (chip->chip_idx) {861 /* instead of CS8420_01_CS use CS8416_01_CS for AES SYNC plug */862 case 0: rmh.cmd[1] = CS8420_01_CS; break;863 case 1: rmh.cmd[1] = CS8420_23_CS; break;864 case 2: rmh.cmd[1] = CS8420_45_CS; break;865 case 3: rmh.cmd[1] = CS8420_67_CS; break;866 default: return -EINVAL;867 }868 if (chip->mgr->board_aes_in_192k) {869 switch (aes_idx) {870 case 0: rmh.cmd[2] = CS8416_CSB0; break;871 case 1: rmh.cmd[2] = CS8416_CSB1; break;872 case 2: rmh.cmd[2] = CS8416_CSB2; break;873 case 3: rmh.cmd[2] = CS8416_CSB3; break;874 case 4: rmh.cmd[2] = CS8416_CSB4; break;875 default: return -EINVAL;876 }877 } else {878 switch (aes_idx) {879 /* instead of CS8420_CSB0 use CS8416_CSBx for AES SYNC plug */880 case 0: rmh.cmd[2] = CS8420_CSB0; break;881 case 1: rmh.cmd[2] = CS8420_CSB1; break;882 case 2: rmh.cmd[2] = CS8420_CSB2; break;883 case 3: rmh.cmd[2] = CS8420_CSB3; break;884 case 4: rmh.cmd[2] = CS8420_CSB4; break;885 default: return -EINVAL;886 }887 }888 /* size and code the chip id for the fpga */889 rmh.cmd[1] &= 0x0fffff;890 /* chip signature + map for spi read */891 rmh.cmd[2] &= CHIP_SIG_AND_MAP_SPI;892 rmh.cmd_len = 3;893 err = pcxhr_send_msg(chip->mgr, &rmh);894 if (err)895 return err;896 897 if (chip->mgr->board_aes_in_192k) {898 temp = (unsigned char)rmh.stat[1];899 } else {900 temp = 0;901 /* reversed bit order (not with CS8416_01_CS) */902 for (i = 0; i < 8; i++) {903 temp <<= 1;904 if (rmh.stat[1] & (1 << i))905 temp |= 1;906 }907 }908 dev_dbg(chip->card->dev, "read iec958 AES %d byte %d = 0x%x\n",909 chip->chip_idx, aes_idx, temp);910 *aes_bits = temp;911 return 0;912}913 914static int pcxhr_iec958_get(struct snd_kcontrol *kcontrol,915 struct snd_ctl_elem_value *ucontrol)916{917 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);918 unsigned char aes_bits;919 int i, err;920 921 mutex_lock(&chip->mgr->mixer_mutex);922 for(i = 0; i < 5; i++) {923 if (kcontrol->private_value == 0) /* playback */924 aes_bits = chip->aes_bits[i];925 else { /* capture */926 if (chip->mgr->is_hr_stereo)927 err = hr222_iec958_capture_byte(chip, i,928 &aes_bits);929 else930 err = pcxhr_iec958_capture_byte(chip, i,931 &aes_bits);932 if (err)933 break;934 }935 ucontrol->value.iec958.status[i] = aes_bits;936 }937 mutex_unlock(&chip->mgr->mixer_mutex);938 return 0;939}940 941static int pcxhr_iec958_mask_get(struct snd_kcontrol *kcontrol,942 struct snd_ctl_elem_value *ucontrol)943{944 int i;945 for (i = 0; i < 5; i++)946 ucontrol->value.iec958.status[i] = 0xff;947 return 0;948}949 950static int pcxhr_iec958_update_byte(struct snd_pcxhr *chip,951 int aes_idx, unsigned char aes_bits)952{953 int i, err, cmd;954 unsigned char new_bits = aes_bits;955 unsigned char old_bits = chip->aes_bits[aes_idx];956 struct pcxhr_rmh rmh;957 958 for (i = 0; i < 8; i++) {959 if ((old_bits & 0x01) != (new_bits & 0x01)) {960 cmd = chip->chip_idx & 0x03; /* chip index 0..3 */961 if (chip->chip_idx > 3)962 /* new bit used if chip_idx>3 (PCX1222HR) */963 cmd |= 1 << 22;964 cmd |= ((aes_idx << 3) + i) << 2; /* add bit offset */965 cmd |= (new_bits & 0x01) << 23; /* add bit value */966 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);967 rmh.cmd[0] |= IO_NUM_REG_CUER;968 rmh.cmd[1] = cmd;969 rmh.cmd_len = 2;970 dev_dbg(chip->card->dev,971 "write iec958 AES %d byte %d bit %d (cmd %x)\n",972 chip->chip_idx, aes_idx, i, cmd);973 err = pcxhr_send_msg(chip->mgr, &rmh);974 if (err)975 return err;976 }977 old_bits >>= 1;978 new_bits >>= 1;979 }980 chip->aes_bits[aes_idx] = aes_bits;981 return 0;982}983 984static int pcxhr_iec958_put(struct snd_kcontrol *kcontrol,985 struct snd_ctl_elem_value *ucontrol)986{987 struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);988 int i, changed = 0;989 990 /* playback */991 mutex_lock(&chip->mgr->mixer_mutex);992 for (i = 0; i < 5; i++) {993 if (ucontrol->value.iec958.status[i] != chip->aes_bits[i]) {994 if (chip->mgr->is_hr_stereo)995 hr222_iec958_update_byte(chip, i,996 ucontrol->value.iec958.status[i]);997 else998 pcxhr_iec958_update_byte(chip, i,999 ucontrol->value.iec958.status[i]);1000 changed = 1;1001 }1002 }1003 mutex_unlock(&chip->mgr->mixer_mutex);1004 return changed;1005}1006 1007static const struct snd_kcontrol_new pcxhr_control_playback_iec958_mask = {1008 .access = SNDRV_CTL_ELEM_ACCESS_READ,1009 .iface = SNDRV_CTL_ELEM_IFACE_PCM,1010 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),1011 .info = pcxhr_iec958_info,1012 .get = pcxhr_iec958_mask_get1013};1014static const struct snd_kcontrol_new pcxhr_control_playback_iec958 = {1015 .iface = SNDRV_CTL_ELEM_IFACE_PCM,1016 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),1017 .info = pcxhr_iec958_info,1018 .get = pcxhr_iec958_get,1019 .put = pcxhr_iec958_put,1020 .private_value = 0 /* playback */1021};1022 1023static const struct snd_kcontrol_new pcxhr_control_capture_iec958_mask = {1024 .access = SNDRV_CTL_ELEM_ACCESS_READ,1025 .iface = SNDRV_CTL_ELEM_IFACE_PCM,1026 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,MASK),1027 .info = pcxhr_iec958_info,1028 .get = pcxhr_iec958_mask_get1029};1030static const struct snd_kcontrol_new pcxhr_control_capture_iec958 = {1031 .access = SNDRV_CTL_ELEM_ACCESS_READ,1032 .iface = SNDRV_CTL_ELEM_IFACE_PCM,1033 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),1034 .info = pcxhr_iec958_info,1035 .get = pcxhr_iec958_get,1036 .private_value = 1 /* capture */1037};1038 1039static void pcxhr_init_audio_levels(struct snd_pcxhr *chip)1040{1041 int i;1042 1043 for (i = 0; i < 2; i++) {1044 if (chip->nb_streams_play) {1045 int j;1046 /* at boot time the digital volumes are unmuted 0dB */1047 for (j = 0; j < PCXHR_PLAYBACK_STREAMS; j++) {1048 chip->digital_playback_active[j][i] = 1;1049 chip->digital_playback_volume[j][i] =1050 PCXHR_DIGITAL_ZERO_LEVEL;1051 }1052 /* after boot, only two bits are set on the uer1053 * interface1054 */1055 chip->aes_bits[0] = (IEC958_AES0_PROFESSIONAL |1056 IEC958_AES0_PRO_FS_48000);1057#ifdef CONFIG_SND_DEBUG1058 /* analog volumes for playback1059 * (is LEVEL_MIN after boot)1060 */1061 chip->analog_playback_active[i] = 1;1062 if (chip->mgr->is_hr_stereo)1063 chip->analog_playback_volume[i] =1064 HR222_LINE_PLAYBACK_ZERO_LEVEL;1065 else {1066 chip->analog_playback_volume[i] =1067 PCXHR_LINE_PLAYBACK_ZERO_LEVEL;1068 pcxhr_update_analog_audio_level(chip, 0, i);1069 }1070#endif1071 /* stereo cards need to be initialised after boot */1072 if (chip->mgr->is_hr_stereo)1073 hr222_update_analog_audio_level(chip, 0, i);1074 }1075 if (chip->nb_streams_capt) {1076 /* at boot time the digital volumes are unmuted 0dB */1077 chip->digital_capture_volume[i] =1078 PCXHR_DIGITAL_ZERO_LEVEL;1079 chip->analog_capture_active = 1;1080#ifdef CONFIG_SND_DEBUG1081 /* analog volumes for playback1082 * (is LEVEL_MIN after boot)1083 */1084 if (chip->mgr->is_hr_stereo)1085 chip->analog_capture_volume[i] =1086 HR222_LINE_CAPTURE_ZERO_LEVEL;1087 else {1088 chip->analog_capture_volume[i] =1089 PCXHR_LINE_CAPTURE_ZERO_LEVEL;1090 pcxhr_update_analog_audio_level(chip, 1, i);1091 }1092#endif1093 /* stereo cards need to be initialised after boot */1094 if (chip->mgr->is_hr_stereo)1095 hr222_update_analog_audio_level(chip, 1, i);1096 }1097 }1098 1099 return;1100}1101 1102 1103int pcxhr_create_mixer(struct pcxhr_mgr *mgr)1104{1105 struct snd_pcxhr *chip;1106 int err, i;1107 1108 mutex_init(&mgr->mixer_mutex); /* can be in another place */1109 1110 for (i = 0; i < mgr->num_cards; i++) {1111 struct snd_kcontrol_new temp;1112 chip = mgr->chip[i];1113 1114 if (chip->nb_streams_play) {1115 /* analog output level control */1116 temp = pcxhr_control_analog_level;1117 temp.name = "Master Playback Volume";1118 temp.private_value = 0; /* playback */1119 if (mgr->is_hr_stereo)1120 temp.tlv.p = db_scale_a_hr222_playback;1121 else1122 temp.tlv.p = db_scale_analog_playback;1123 err = snd_ctl_add(chip->card,1124 snd_ctl_new1(&temp, chip));1125 if (err < 0)1126 return err;1127 1128 /* output mute controls */1129 err = snd_ctl_add(chip->card,1130 snd_ctl_new1(&pcxhr_control_output_switch,1131 chip));1132 if (err < 0)1133 return err;1134 1135 temp = snd_pcxhr_pcm_vol;1136 temp.name = "PCM Playback Volume";1137 temp.count = PCXHR_PLAYBACK_STREAMS;1138 temp.private_value = 0; /* playback */1139 err = snd_ctl_add(chip->card,1140 snd_ctl_new1(&temp, chip));1141 if (err < 0)1142 return err;1143 1144 err = snd_ctl_add(chip->card,1145 snd_ctl_new1(&pcxhr_control_pcm_switch, chip));1146 if (err < 0)1147 return err;1148 1149 /* IEC958 controls */1150 err = snd_ctl_add(chip->card,1151 snd_ctl_new1(&pcxhr_control_playback_iec958_mask,1152 chip));1153 if (err < 0)1154 return err;1155 1156 err = snd_ctl_add(chip->card,1157 snd_ctl_new1(&pcxhr_control_playback_iec958,1158 chip));1159 if (err < 0)1160 return err;1161 }1162 if (chip->nb_streams_capt) {1163 /* analog input level control */1164 temp = pcxhr_control_analog_level;1165 temp.name = "Line Capture Volume";1166 temp.private_value = 1; /* capture */1167 if (mgr->is_hr_stereo)1168 temp.tlv.p = db_scale_a_hr222_capture;1169 else1170 temp.tlv.p = db_scale_analog_capture;1171 1172 err = snd_ctl_add(chip->card,1173 snd_ctl_new1(&temp, chip));1174 if (err < 0)1175 return err;1176 1177 temp = snd_pcxhr_pcm_vol;1178 temp.name = "PCM Capture Volume";1179 temp.count = 1;1180 temp.private_value = 1; /* capture */1181 1182 err = snd_ctl_add(chip->card,1183 snd_ctl_new1(&temp, chip));1184 if (err < 0)1185 return err;1186 1187 /* Audio source */1188 err = snd_ctl_add(chip->card,1189 snd_ctl_new1(&pcxhr_control_audio_src, chip));1190 if (err < 0)1191 return err;1192 1193 /* IEC958 controls */1194 err = snd_ctl_add(chip->card,1195 snd_ctl_new1(&pcxhr_control_capture_iec958_mask,1196 chip));1197 if (err < 0)1198 return err;1199 1200 err = snd_ctl_add(chip->card,1201 snd_ctl_new1(&pcxhr_control_capture_iec958,1202 chip));1203 if (err < 0)1204 return err;1205 1206 if (mgr->is_hr_stereo) {1207 err = hr222_add_mic_controls(chip);1208 if (err < 0)1209 return err;1210 }1211 }1212 /* monitoring only if playback and capture device available */1213 if (chip->nb_streams_capt > 0 && chip->nb_streams_play > 0) {1214 /* monitoring */1215 err = snd_ctl_add(chip->card,1216 snd_ctl_new1(&pcxhr_control_monitor_vol, chip));1217 if (err < 0)1218 return err;1219 1220 err = snd_ctl_add(chip->card,1221 snd_ctl_new1(&pcxhr_control_monitor_sw, chip));1222 if (err < 0)1223 return err;1224 }1225 1226 if (i == 0) {1227 /* clock mode only one control per pcxhr */1228 err = snd_ctl_add(chip->card,1229 snd_ctl_new1(&pcxhr_control_clock_type, mgr));1230 if (err < 0)1231 return err;1232 /* non standard control used to scan1233 * the external clock presence/frequencies1234 */1235 err = snd_ctl_add(chip->card,1236 snd_ctl_new1(&pcxhr_control_clock_rate, mgr));1237 if (err < 0)1238 return err;1239 }1240 1241 /* init values for the mixer data */1242 pcxhr_init_audio_levels(chip);1243 }1244 1245 return 0;1246}1247