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