Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pcxhr_mixer.c
Go to the documentation of this file.
1 #define __NO_VERSION__
2 /*
3  * Driver for Digigram pcxhr compatible soundcards
4  *
5  * mixer callbacks
6  *
7  * Copyright (c) 2004 by Digigram <[email protected]>
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 }
Generated on Thu Jan 10 2013 15:07:01 for Linux Kernel by   doxygen 1.8.2