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