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