1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <sound/driver.h>
24#include <linux/delay.h>
25#include <linux/device.h>
26#include <linux/firmware.h>
27#include <linux/mutex.h>
28
29#include <sound/core.h>
30#include <sound/control.h>
31#include <sound/tlv.h>
32#include <asm/io.h>
33#include "vx222.h"
34
35
36static int vx2_reg_offset[VX_REG_MAX] = {
37 [VX_ICR] = 0x00,
38 [VX_CVR] = 0x04,
39 [VX_ISR] = 0x08,
40 [VX_IVR] = 0x0c,
41 [VX_RXH] = 0x14,
42 [VX_RXM] = 0x18,
43 [VX_RXL] = 0x1c,
44 [VX_DMA] = 0x10,
45 [VX_CDSP] = 0x20,
46 [VX_CFG] = 0x24,
47 [VX_RUER] = 0x28,
48 [VX_DATA] = 0x2c,
49 [VX_STATUS] = 0x30,
50 [VX_LOFREQ] = 0x34,
51 [VX_HIFREQ] = 0x38,
52 [VX_CSUER] = 0x3c,
53 [VX_SELMIC] = 0x40,
54 [VX_COMPOT] = 0x44,
55 [VX_SCOMPR] = 0x48,
56 [VX_GLIMIT] = 0x4c,
57 [VX_INTCSR] = 0x4c,
58 [VX_CNTRL] = 0x50,
59 [VX_GPIOC] = 0x54,
60};
61
62static int vx2_reg_index[VX_REG_MAX] = {
63 [VX_ICR] = 1,
64 [VX_CVR] = 1,
65 [VX_ISR] = 1,
66 [VX_IVR] = 1,
67 [VX_RXH] = 1,
68 [VX_RXM] = 1,
69 [VX_RXL] = 1,
70 [VX_DMA] = 1,
71 [VX_CDSP] = 1,
72 [VX_CFG] = 1,
73 [VX_RUER] = 1,
74 [VX_DATA] = 1,
75 [VX_STATUS] = 1,
76 [VX_LOFREQ] = 1,
77 [VX_HIFREQ] = 1,
78 [VX_CSUER] = 1,
79 [VX_SELMIC] = 1,
80 [VX_COMPOT] = 1,
81 [VX_SCOMPR] = 1,
82 [VX_GLIMIT] = 1,
83 [VX_INTCSR] = 0,
84 [VX_CNTRL] = 0,
85 [VX_GPIOC] = 0,
86};
87
88static inline unsigned long vx2_reg_addr(struct vx_core *_chip, int reg)
89{
90 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
91 return chip->port[vx2_reg_index[reg]] + vx2_reg_offset[reg];
92}
93
94
95
96
97
98static unsigned char vx2_inb(struct vx_core *chip, int offset)
99{
100 return inb(vx2_reg_addr(chip, offset));
101}
102
103
104
105
106
107
108static void vx2_outb(struct vx_core *chip, int offset, unsigned char val)
109{
110 outb(val, vx2_reg_addr(chip, offset));
111
112}
113
114
115
116
117
118static unsigned int vx2_inl(struct vx_core *chip, int offset)
119{
120 return inl(vx2_reg_addr(chip, offset));
121}
122
123
124
125
126
127
128static void vx2_outl(struct vx_core *chip, int offset, unsigned int val)
129{
130
131 outl(val, vx2_reg_addr(chip, offset));
132}
133
134
135
136
137#undef vx_inb
138#define vx_inb(chip,reg) vx2_inb((struct vx_core*)(chip), VX_##reg)
139#undef vx_outb
140#define vx_outb(chip,reg,val) vx2_outb((struct vx_core*)(chip), VX_##reg, val)
141#undef vx_inl
142#define vx_inl(chip,reg) vx2_inl((struct vx_core*)(chip), VX_##reg)
143#undef vx_outl
144#define vx_outl(chip,reg,val) vx2_outl((struct vx_core*)(chip), VX_##reg, val)
145
146
147
148
149
150
151#define XX_DSP_RESET_WAIT_TIME 2
152
153static void vx2_reset_dsp(struct vx_core *_chip)
154{
155 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
156
157
158 vx_outl(chip, CDSP, chip->regCDSP & ~VX_CDSP_DSP_RESET_MASK);
159
160 mdelay(XX_DSP_RESET_WAIT_TIME);
161
162 chip->regCDSP |= VX_CDSP_DSP_RESET_MASK;
163
164 vx_outl(chip, CDSP, chip->regCDSP);
165}
166
167
168static int vx2_test_xilinx(struct vx_core *_chip)
169{
170 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
171 unsigned int data;
172
173 snd_printdd("testing xilinx...\n");
174
175
176
177
178
179 vx_outl(chip, CDSP, chip->regCDSP | VX_CDSP_TEST0_MASK);
180 vx_inl(chip, ISR);
181 data = vx_inl(chip, STATUS);
182 if ((data & VX_STATUS_VAL_TEST0_MASK) == VX_STATUS_VAL_TEST0_MASK) {
183 snd_printdd("bad!\n");
184 return -ENODEV;
185 }
186
187
188 vx_outl(chip, CDSP, chip->regCDSP & ~VX_CDSP_TEST0_MASK);
189 vx_inl(chip, ISR);
190 data = vx_inl(chip, STATUS);
191 if (! (data & VX_STATUS_VAL_TEST0_MASK)) {
192 snd_printdd("bad! #2\n");
193 return -ENODEV;
194 }
195
196 if (_chip->type == VX_TYPE_BOARD) {
197
198
199 vx_outl(chip, CDSP, chip->regCDSP | VX_CDSP_TEST1_MASK);
200 vx_inl(chip, ISR);
201 data = vx_inl(chip, STATUS);
202 if ((data & VX_STATUS_VAL_TEST1_MASK) == VX_STATUS_VAL_TEST1_MASK) {
203 snd_printdd("bad! #3\n");
204 return -ENODEV;
205 }
206
207
208 vx_outl(chip, CDSP, chip->regCDSP & ~VX_CDSP_TEST1_MASK);
209 vx_inl(chip, ISR);
210 data = vx_inl(chip, STATUS);
211 if (! (data & VX_STATUS_VAL_TEST1_MASK)) {
212 snd_printdd("bad! #4\n");
213 return -ENODEV;
214 }
215 }
216 snd_printdd("ok, xilinx fine.\n");
217 return 0;
218}
219
220
221
222
223
224
225static void vx2_setup_pseudo_dma(struct vx_core *chip, int do_write)
226{
227
228
229
230 vx_outl(chip, ICR, do_write ? ICR_TREQ : ICR_RREQ);
231
232
233
234
235 vx_outl(chip, RESET_DMA, 0);
236}
237
238
239
240
241static inline void vx2_release_pseudo_dma(struct vx_core *chip)
242{
243
244 vx_outl(chip, ICR, 0);
245}
246
247
248
249
250static void vx2_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime,
251 struct vx_pipe *pipe, int count)
252{
253 unsigned long port = vx2_reg_addr(chip, VX_DMA);
254 int offset = pipe->hw_ptr;
255 u32 *addr = (u32 *)(runtime->dma_area + offset);
256
257 snd_assert(count % 4 == 0, return);
258
259 vx2_setup_pseudo_dma(chip, 1);
260
261
262
263 if (offset + count > pipe->buffer_bytes) {
264 int length = pipe->buffer_bytes - offset;
265 count -= length;
266 length >>= 2;
267
268 while (length-- > 0) {
269 outl(cpu_to_le32(*addr), port);
270 addr++;
271 }
272 addr = (u32 *)runtime->dma_area;
273 pipe->hw_ptr = 0;
274 }
275 pipe->hw_ptr += count;
276 count >>= 2;
277
278 while (count-- > 0) {
279 outl(cpu_to_le32(*addr), port);
280 addr++;
281 }
282
283 vx2_release_pseudo_dma(chip);
284}
285
286
287
288static void vx2_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime,
289 struct vx_pipe *pipe, int count)
290{
291 int offset = pipe->hw_ptr;
292 u32 *addr = (u32 *)(runtime->dma_area + offset);
293 unsigned long port = vx2_reg_addr(chip, VX_DMA);
294
295 snd_assert(count % 4 == 0, return);
296
297 vx2_setup_pseudo_dma(chip, 0);
298
299
300 if (offset + count > pipe->buffer_bytes) {
301 int length = pipe->buffer_bytes - offset;
302 count -= length;
303 length >>= 2;
304
305 while (length-- > 0)
306 *addr++ = le32_to_cpu(inl(port));
307 addr = (u32 *)runtime->dma_area;
308 pipe->hw_ptr = 0;
309 }
310 pipe->hw_ptr += count;
311 count >>= 2;
312
313 while (count-- > 0)
314 *addr++ = le32_to_cpu(inl(port));
315
316 vx2_release_pseudo_dma(chip);
317}
318
319#define VX_XILINX_RESET_MASK 0x40000000
320#define VX_USERBIT0_MASK 0x00000004
321#define VX_USERBIT1_MASK 0x00000020
322#define VX_CNTRL_REGISTER_VALUE 0x00172012
323
324
325
326
327static int put_xilinx_data(struct vx_core *chip, unsigned int port, unsigned int counts, unsigned char data)
328{
329 unsigned int i;
330
331 for (i = 0; i < counts; i++) {
332 unsigned int val;
333
334
335 val = VX_CNTRL_REGISTER_VALUE & ~VX_USERBIT0_MASK;
336 vx2_outl(chip, port, val);
337 vx2_inl(chip, port);
338 udelay(1);
339
340 if (data & (1 << i))
341 val |= VX_USERBIT1_MASK;
342 else
343 val &= ~VX_USERBIT1_MASK;
344 vx2_outl(chip, port, val);
345 vx2_inl(chip, port);
346
347
348 val |= VX_USERBIT0_MASK;
349 vx2_outl(chip, port, val);
350 vx2_inl(chip, port);
351 udelay(1);
352 }
353 return 0;
354}
355
356
357
358
359static int vx2_load_xilinx_binary(struct vx_core *chip, const struct firmware *xilinx)
360{
361 unsigned int i;
362 unsigned int port;
363 unsigned char *image;
364
365
366 vx_outl(chip, CNTRL, VX_CNTRL_REGISTER_VALUE | VX_XILINX_RESET_MASK);
367 vx_inl(chip, CNTRL);
368 msleep(10);
369 vx_outl(chip, CNTRL, VX_CNTRL_REGISTER_VALUE);
370 vx_inl(chip, CNTRL);
371 msleep(10);
372
373 if (chip->type == VX_TYPE_BOARD)
374 port = VX_CNTRL;
375 else
376 port = VX_GPIOC;
377
378 image = xilinx->data;
379 for (i = 0; i < xilinx->size; i++, image++) {
380 if (put_xilinx_data(chip, port, 8, *image) < 0)
381 return -EINVAL;
382
383 cond_resched();
384 }
385 put_xilinx_data(chip, port, 4, 0xff);
386
387 msleep(200);
388
389
390 if (chip->type != VX_TYPE_BOARD) {
391
392 i = vx_inl(chip, GPIOC);
393 if (i & 0x0100)
394 return 0;
395 snd_printk(KERN_ERR "vx222: xilinx test failed after load, GPIOC=0x%x\n", i);
396 return -EINVAL;
397 }
398
399 return 0;
400}
401
402
403
404
405
406static int vx2_load_dsp(struct vx_core *vx, int index, const struct firmware *dsp)
407{
408 int err;
409
410 switch (index) {
411 case 1:
412
413 if ((err = vx2_load_xilinx_binary(vx, dsp)) < 0)
414 return err;
415 if ((err = vx2_test_xilinx(vx)) < 0)
416 return err;
417 return 0;
418 case 2:
419
420 return snd_vx_dsp_boot(vx, dsp);
421 case 3:
422
423 return snd_vx_dsp_load(vx, dsp);
424 default:
425 snd_BUG();
426 return -EINVAL;
427 }
428}
429
430
431
432
433
434
435
436
437
438static int vx2_test_and_ack(struct vx_core *chip)
439{
440
441 if (! (chip->chip_status & VX_STAT_XILINX_LOADED))
442 return -ENXIO;
443
444 if (! (vx_inl(chip, STATUS) & VX_STATUS_MEMIRQ_MASK))
445 return -EIO;
446
447
448
449 vx_outl(chip, STATUS, 0);
450
451
452
453 vx_inl(chip, STATUS);
454
455 vx_outl(chip, STATUS, VX_STATUS_MEMIRQ_MASK);
456
457
458 vx_inl(chip, STATUS);
459
460 vx_outl(chip, STATUS, 0);
461
462 return 0;
463}
464
465
466
467
468
469static void vx2_validate_irq(struct vx_core *_chip, int enable)
470{
471 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
472
473
474 if (enable) {
475
476 vx_outl(chip, INTCSR, VX_INTCSR_VALUE|VX_PCI_INTERRUPT_MASK);
477 chip->regCDSP |= VX_CDSP_VALID_IRQ_MASK;
478 } else {
479
480 vx_outl(chip, INTCSR, VX_INTCSR_VALUE&~VX_PCI_INTERRUPT_MASK);
481 chip->regCDSP &= ~VX_CDSP_VALID_IRQ_MASK;
482 }
483 vx_outl(chip, CDSP, chip->regCDSP);
484}
485
486
487
488
489
490static void vx2_write_codec_reg(struct vx_core *chip, unsigned int data)
491{
492 unsigned int i;
493
494 vx_inl(chip, HIFREQ);
495
496
497 for (i = 0; i < 24; i++, data <<= 1)
498 vx_outl(chip, DATA, ((data & 0x800000) ? VX_DATA_CODEC_MASK : 0));
499
500 vx_inl(chip, RUER);
501}
502
503
504#define AKM_CODEC_POWER_CONTROL_CMD 0xA007
505#define AKM_CODEC_RESET_ON_CMD 0xA100
506#define AKM_CODEC_RESET_OFF_CMD 0xA103
507#define AKM_CODEC_CLOCK_FORMAT_CMD 0xA240
508#define AKM_CODEC_MUTE_CMD 0xA38D
509#define AKM_CODEC_UNMUTE_CMD 0xA30D
510#define AKM_CODEC_LEFT_LEVEL_CMD 0xA400
511#define AKM_CODEC_RIGHT_LEVEL_CMD 0xA500
512
513static const u8 vx2_akm_gains_lut[VX2_AKM_LEVEL_MAX+1] = {
514 0x7f,
515 0x7d,
516 0x7c,
517 0x7a,
518 0x79,
519 0x77,
520 0x76,
521 0x75,
522 0x73,
523 0x72,
524 0x71,
525 0x70,
526 0x6f,
527 0x6d,
528 0x6c,
529 0x6a,
530 0x69,
531 0x67,
532 0x66,
533 0x65,
534 0x64,
535 0x62,
536 0x61,
537 0x60,
538 0x5f,
539 0x5e,
540 0x5c,
541 0x5b,
542 0x59,
543 0x58,
544 0x56,
545 0x55,
546 0x54,
547 0x53,
548 0x52,
549 0x51,
550 0x50,
551 0x4e,
552 0x4d,
553 0x4b,
554 0x4a,
555 0x48,
556 0x47,
557 0x46,
558 0x44,
559 0x43,
560 0x42,
561 0x41,
562 0x40,
563 0x3f,
564 0x3e,
565 0x3c,
566 0x3b,
567 0x39,
568 0x38,
569 0x37,
570 0x36,
571 0x34,
572 0x33,
573 0x32,
574 0x31,
575 0x31,
576 0x30,
577 0x2e,
578 0x2d,
579 0x2b,
580 0x2a,
581 0x29,
582 0x28,
583 0x27,
584 0x25,
585 0x24,
586 0x24,
587 0x23,
588 0x22,
589 0x21,
590 0x20,
591 0x1f,
592 0x1e,
593 0x1d,
594 0x1c,
595 0x1b,
596 0x1a,
597 0x19,
598 0x18,
599 0x17,
600 0x16,
601 0x15,
602 0x14,
603 0x14,
604 0x13,
605 0x12,
606 0x12,
607 0x11,
608 0x11,
609 0x10,
610 0x10,
611 0x0f,
612 0x0e,
613 0x0d,
614 0x0d,
615 0x0c,
616 0x0b,
617 0x0b,
618 0x0a,
619 0x0a,
620 0x09,
621 0x09,
622 0x08,
623 0x08,
624 0x07,
625 0x07,
626 0x06,
627 0x06,
628 0x06,
629 0x05,
630 0x05,
631 0x05,
632 0x05,
633 0x04,
634 0x04,
635 0x04,
636 0x04,
637 0x03,
638 0x03,
639 0x03,
640 0x03,
641 0x03,
642 0x03,
643 0x02,
644 0x02,
645 0x02,
646 0x02,
647 0x02,
648 0x02,
649 0x02,
650 0x02,
651 0x02,
652 0x02,
653 0x01,
654 0x01,
655 0x01,
656 0x01,
657 0x01,
658 0x01,
659 0x01,
660 0x01,
661 0x00};
662
663
664
665
666static void vx2_write_akm(struct vx_core *chip, int reg, unsigned int data)
667{
668 unsigned int val;
669
670 if (reg == XX_CODEC_DAC_CONTROL_REGISTER) {
671 vx2_write_codec_reg(chip, data ? AKM_CODEC_MUTE_CMD : AKM_CODEC_UNMUTE_CMD);
672 return;
673 }
674
675
676
677
678
679 snd_assert(data < sizeof(vx2_akm_gains_lut), return);
680
681 switch (reg) {
682 case XX_CODEC_LEVEL_LEFT_REGISTER:
683 val = AKM_CODEC_LEFT_LEVEL_CMD;
684 break;
685 case XX_CODEC_LEVEL_RIGHT_REGISTER:
686 val = AKM_CODEC_RIGHT_LEVEL_CMD;
687 break;
688 default:
689 snd_BUG();
690 return;
691 }
692 val |= vx2_akm_gains_lut[data];
693
694 vx2_write_codec_reg(chip, val);
695}
696
697
698
699
700
701static void vx2_old_write_codec_bit(struct vx_core *chip, int codec, unsigned int data)
702{
703 int i;
704
705
706 vx_inl(chip, HIFREQ);
707
708 for (i = 0; i < 24; i++, data <<= 1)
709 vx_outl(chip, DATA, ((data & 0x800000) ? VX_DATA_CODEC_MASK : 0));
710
711
712 vx_inl(chip, RUER);
713}
714
715
716
717
718
719static void vx2_reset_codec(struct vx_core *_chip)
720{
721 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
722
723
724 vx_outl(chip, CDSP, chip->regCDSP &~ VX_CDSP_CODEC_RESET_MASK);
725 vx_inl(chip, CDSP);
726 msleep(10);
727
728 chip->regCDSP |= VX_CDSP_CODEC_RESET_MASK;
729 vx_outl(chip, CDSP, chip->regCDSP);
730 vx_inl(chip, CDSP);
731 if (_chip->type == VX_TYPE_BOARD) {
732 msleep(1);
733 return;
734 }
735
736 msleep(5);
737
738 vx2_write_codec_reg(_chip, AKM_CODEC_POWER_CONTROL_CMD);
739
740 vx2_write_codec_reg(_chip, AKM_CODEC_CLOCK_FORMAT_CMD);
741 vx2_write_codec_reg(_chip, AKM_CODEC_MUTE_CMD);
742 vx2_write_codec_reg(_chip, AKM_CODEC_RESET_OFF_CMD);
743
744 if (_chip->type == VX_TYPE_MIC) {
745
746 chip->regSELMIC = MICRO_SELECT_INPUT_NORM |
747 MICRO_SELECT_PREAMPLI_G_0 |
748 MICRO_SELECT_NOISE_T_52DB;
749
750
751 chip->regSELMIC &= ~MICRO_SELECT_PHANTOM_ALIM;
752
753 vx_outl(_chip, SELMIC, chip->regSELMIC);
754 }
755}
756
757
758
759
760
761static void vx2_change_audio_source(struct vx_core *_chip, int src)
762{
763 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
764
765 switch (src) {
766 case VX_AUDIO_SRC_DIGITAL:
767 chip->regCFG |= VX_CFG_DATAIN_SEL_MASK;
768 break;
769 default:
770 chip->regCFG &= ~VX_CFG_DATAIN_SEL_MASK;
771 break;
772 }
773 vx_outl(chip, CFG, chip->regCFG);
774}
775
776
777
778
779
780static void vx2_set_clock_source(struct vx_core *_chip, int source)
781{
782 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
783
784 if (source == INTERNAL_QUARTZ)
785 chip->regCFG &= ~VX_CFG_CLOCKIN_SEL_MASK;
786 else
787 chip->regCFG |= VX_CFG_CLOCKIN_SEL_MASK;
788 vx_outl(chip, CFG, chip->regCFG);
789}
790
791
792
793
794static void vx2_reset_board(struct vx_core *_chip, int cold_reset)
795{
796 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
797
798
799 chip->regCDSP = VX_CDSP_CODEC_RESET_MASK | VX_CDSP_DSP_RESET_MASK ;
800 chip->regCFG = 0;
801}
802
803
804
805
806
807
808
809
810
811
812
813#define V2_MICRO_LEVEL_RANGE (318 - 255)
814
815static void vx2_set_input_level(struct snd_vx222 *chip)
816{
817 int i, miclevel, preamp;
818 unsigned int data;
819
820 miclevel = chip->mic_level;
821 miclevel += V2_MICRO_LEVEL_RANGE;
822 preamp = 0;
823 while (miclevel > 210) {
824 preamp++;
825 miclevel -= (18 * 2);
826 }
827 snd_assert(preamp < 4, return);
828
829
830 chip->regSELMIC &= ~MICRO_SELECT_PREAMPLI_MASK;
831 chip->regSELMIC |= (preamp << MICRO_SELECT_PREAMPLI_OFFSET) & MICRO_SELECT_PREAMPLI_MASK;
832 vx_outl(chip, SELMIC, chip->regSELMIC);
833
834 data = (unsigned int)miclevel << 16 |
835 (unsigned int)chip->input_level[1] << 8 |
836 (unsigned int)chip->input_level[0];
837 vx_inl(chip, DATA);
838
839
840 for (i = 0; i < 32; i++, data <<= 1)
841 vx_outl(chip, DATA, ((data & 0x80000000) ? VX_DATA_CODEC_MASK : 0));
842
843 vx_inl(chip, RUER);
844}
845
846
847#define MIC_LEVEL_MAX 0xff
848
849static const DECLARE_TLV_DB_SCALE(db_scale_mic, -6450, 50, 0);
850
851
852
853
854
855
856static int vx_input_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
857{
858 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
859 uinfo->count = 2;
860 uinfo->value.integer.min = 0;
861 uinfo->value.integer.max = MIC_LEVEL_MAX;
862 return 0;
863}
864
865static int vx_input_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
866{
867 struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
868 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
869 mutex_lock(&_chip->mixer_mutex);
870 ucontrol->value.integer.value[0] = chip->input_level[0];
871 ucontrol->value.integer.value[1] = chip->input_level[1];
872 mutex_unlock(&_chip->mixer_mutex);
873 return 0;
874}
875
876static int vx_input_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
877{
878 struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
879 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
880 mutex_lock(&_chip->mixer_mutex);
881 if (chip->input_level[0] != ucontrol->value.integer.value[0] ||
882 chip->input_level[1] != ucontrol->value.integer.value[1]) {
883 chip->input_level[0] = ucontrol->value.integer.value[0];
884 chip->input_level[1] = ucontrol->value.integer.value[1];
885 vx2_set_input_level(chip);
886 mutex_unlock(&_chip->mixer_mutex);
887 return 1;
888 }
889 mutex_unlock(&_chip->mixer_mutex);
890 return 0;
891}
892
893
894static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
895{
896 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
897 uinfo->count = 1;
898 uinfo->value.integer.min = 0;
899 uinfo->value.integer.max = MIC_LEVEL_MAX;
900 return 0;
901}
902
903static int vx_mic_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
904{
905 struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
906 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
907 ucontrol->value.integer.value[0] = chip->mic_level;
908 return 0;
909}
910
911static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
912{
913 struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
914 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
915 mutex_lock(&_chip->mixer_mutex);
916 if (chip->mic_level != ucontrol->value.integer.value[0]) {
917 chip->mic_level = ucontrol->value.integer.value[0];
918 vx2_set_input_level(chip);
919 mutex_unlock(&_chip->mixer_mutex);
920 return 1;
921 }
922 mutex_unlock(&_chip->mixer_mutex);
923 return 0;
924}
925
926static struct snd_kcontrol_new vx_control_input_level = {
927 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
928 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
929 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
930 .name = "Capture Volume",
931 .info = vx_input_level_info,
932 .get = vx_input_level_get,
933 .put = vx_input_level_put,
934 .tlv = { .p = db_scale_mic },
935};
936
937static struct snd_kcontrol_new vx_control_mic_level = {
938 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
939 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
940 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
941 .name = "Mic Capture Volume",
942 .info = vx_mic_level_info,
943 .get = vx_mic_level_get,
944 .put = vx_mic_level_put,
945 .tlv = { .p = db_scale_mic },
946};
947
948
949
950
951
952static int vx2_add_mic_controls(struct vx_core *_chip)
953{
954 struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
955 int err;
956
957 if (_chip->type != VX_TYPE_MIC)
958 return 0;
959
960
961 chip->input_level[0] = chip->input_level[1] = 0;
962 chip->mic_level = 0;
963 vx2_set_input_level(chip);
964
965
966 if ((err = snd_ctl_add(_chip->card, snd_ctl_new1(&vx_control_input_level, chip))) < 0)
967 return err;
968 if ((err = snd_ctl_add(_chip->card, snd_ctl_new1(&vx_control_mic_level, chip))) < 0)
969 return err;
970
971 return 0;
972}
973
974
975
976
977
978struct snd_vx_ops vx222_ops = {
979 .in8 = vx2_inb,
980 .in32 = vx2_inl,
981 .out8 = vx2_outb,
982 .out32 = vx2_outl,
983 .test_and_ack = vx2_test_and_ack,
984 .validate_irq = vx2_validate_irq,
985 .akm_write = vx2_write_akm,
986 .reset_codec = vx2_reset_codec,
987 .change_audio_source = vx2_change_audio_source,
988 .set_clock_source = vx2_set_clock_source,
989 .load_dsp = vx2_load_dsp,
990 .reset_dsp = vx2_reset_dsp,
991 .reset_board = vx2_reset_board,
992 .dma_write = vx2_dma_write,
993 .dma_read = vx2_dma_read,
994 .add_controls = vx2_add_mic_controls,
995};
996
997
998struct snd_vx_ops vx222_old_ops = {
999 .in8 = vx2_inb,
1000 .in32 = vx2_inl,
1001 .out8 = vx2_outb,
1002 .out32 = vx2_outl,
1003 .test_and_ack = vx2_test_and_ack,
1004 .validate_irq = vx2_validate_irq,
1005 .write_codec = vx2_old_write_codec_bit,
1006 .reset_codec = vx2_reset_codec,
1007 .change_audio_source = vx2_change_audio_source,
1008 .set_clock_source = vx2_set_clock_source,
1009 .load_dsp = vx2_load_dsp,
1010 .reset_dsp = vx2_reset_dsp,
1011 .reset_board = vx2_reset_board,
1012 .dma_write = vx2_dma_write,
1013 .dma_read = vx2_dma_read,
1014};
1015
1016