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