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