This source file includes following definitions.
- pss_dspwrite
- pss_setaddr
- pss_setint
- pss_setdma
- pss_testirq
- pss_testdma
- pss_reset_dsp
- pss_download_dsp
- wss_dump_regs
- pss_dump_regs
- pssprobe
- spprobe
- mpuprobe
- pcdprobe
- pssattach
- spattach
- mpuattach
- pcdattach
- pss_set_master_gain
- pss_set_master_mode
- pss_set_treble
- pss_set_bass
- pss_get_master_gain
- pss_get_master_mode
- pss_get_treble
- pss_get_bass
- pss_speaker_ctl
- pssintr
- mpuintr
- pss_getdev
- pss_mixer_set_port
- pss_mixer_get_port
- pss_query_devinfo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54 #include <sys/param.h>
55 #include <sys/systm.h>
56 #include <sys/errno.h>
57 #include <sys/ioctl.h>
58 #include <sys/syslog.h>
59 #include <sys/device.h>
60 #include <sys/proc.h>
61 #include <sys/buf.h>
62
63 #include <machine/cpu.h>
64 #include <machine/intr.h>
65 #include <machine/bus.h>
66
67 #include <sys/audioio.h>
68 #include <dev/audio_if.h>
69
70 #include <dev/isa/isavar.h>
71 #include <dev/isa/isadmavar.h>
72
73 #include <dev/isa/ad1848var.h>
74 #include <dev/isa/wssreg.h>
75 #include <dev/isa/pssreg.h>
76
77
78 #define WSS_BASE_ADDRESS 0x0530
79
80
81
82
83 #define PSS_MIC_IN_LVL 0
84 #define PSS_LINE_IN_LVL 1
85 #define PSS_DAC_LVL 2
86 #define PSS_REC_LVL 3
87 #define PSS_MON_LVL 4
88 #define PSS_MASTER_VOL 5
89 #define PSS_MASTER_TREBLE 6
90 #define PSS_MASTER_BASS 7
91 #define PSS_MIC_IN_MUTE 8
92 #define PSS_LINE_IN_MUTE 9
93 #define PSS_DAC_MUTE 10
94
95 #define PSS_OUTPUT_MODE 11
96 #define PSS_SPKR_MONO 0
97 #define PSS_SPKR_STEREO 1
98 #define PSS_SPKR_PSEUDO 2
99 #define PSS_SPKR_SPATIAL 3
100
101 #define PSS_RECORD_SOURCE 12
102
103
104 #define PSS_INPUT_CLASS 13
105 #define PSS_RECORD_CLASS 14
106 #define PSS_MONITOR_CLASS 15
107 #define PSS_OUTPUT_CLASS 16
108
109
110 struct pss_softc {
111 struct device sc_dev;
112 void *sc_ih;
113
114 int sc_iobase;
115 int sc_drq;
116
117 struct ad1848_softc *ad1848_sc;
118
119 int out_port;
120
121 struct ad1848_volume master_volume;
122 int master_mode;
123
124 int monitor_treble;
125 int monitor_bass;
126
127 int mic_mute, cd_mute, dac_mute;
128 };
129
130 #ifdef notyet
131 struct mpu_softc {
132 struct device sc_dev;
133 void *sc_ih;
134
135 int sc_iobase;
136 int sc_irq;
137 };
138
139 struct pcd_softc {
140 struct device sc_dev;
141 void *sc_ih;
142
143 int sc_iobase;
144 int sc_irq;
145 };
146 #endif
147
148 #ifdef AUDIO_DEBUG
149 #define DPRINTF(x) if (pssdebug) printf x
150 int pssdebug = 0;
151 #else
152 #define DPRINTF(x)
153 #endif
154
155 int pssprobe(struct device *, void *, void *);
156 void pssattach(struct device *, struct device *, void *);
157
158 int spprobe(struct device *, void *, void *);
159 void spattach(struct device *, struct device *, void *);
160
161 #ifdef notyet
162 int mpuprobe(struct device *, void *, void *);
163 void mpuattach(struct device *, struct device *, void *);
164
165 int pcdprobe(struct device *, void *, void *);
166 void pcdattach(struct device *, struct device *, void *);
167 #endif
168
169 int pssintr(void *);
170 #ifdef notyet
171 int mpuintr(void *);
172 #endif
173
174 int pss_speaker_ctl(void *, int);
175
176 int pss_getdev(void *, struct audio_device *);
177
178 int pss_mixer_set_port(void *, mixer_ctrl_t *);
179 int pss_mixer_get_port(void *, mixer_ctrl_t *);
180 int pss_query_devinfo(void *, mixer_devinfo_t *);
181
182 #ifdef PSS_DSP
183 void pss_dspwrite(struct pss_softc *, int);
184 #endif
185 void pss_setaddr(int, int);
186 int pss_setint(int, int);
187 int pss_setdma(int, int);
188 int pss_testirq(struct pss_softc *, int);
189 int pss_testdma(struct pss_softc *, int);
190 #ifdef notyet
191 int pss_reset_dsp(struct pss_softc *);
192 int pss_download_dsp(struct pss_softc *, u_char *, int);
193 #endif
194 #ifdef AUDIO_DEBUG
195 void pss_dump_regs(struct pss_softc *);
196 #endif
197 int pss_set_master_gain(struct pss_softc *, struct ad1848_volume *);
198 int pss_set_master_mode(struct pss_softc *, int);
199 int pss_set_treble(struct pss_softc *, u_int);
200 int pss_set_bass(struct pss_softc *, u_int);
201 int pss_get_master_gain(struct pss_softc *, struct ad1848_volume *);
202 int pss_get_master_mode(struct pss_softc *, u_int *);
203 int pss_get_treble(struct pss_softc *, u_char *);
204 int pss_get_bass(struct pss_softc *, u_char *);
205
206 #ifdef AUDIO_DEBUG
207 void wss_dump_regs(struct ad1848_softc *);
208 #endif
209
210
211
212
213
214 struct audio_hw_if pss_audio_if = {
215 ad1848_open,
216 ad1848_close,
217 NULL,
218 ad1848_query_encoding,
219 ad1848_set_params,
220 ad1848_round_blocksize,
221 ad1848_commit_settings,
222 ad1848_dma_init_output,
223 ad1848_dma_init_input,
224 ad1848_dma_output,
225 ad1848_dma_input,
226 ad1848_halt_out_dma,
227 ad1848_halt_in_dma,
228 pss_speaker_ctl,
229 pss_getdev,
230 NULL,
231 pss_mixer_set_port,
232 pss_mixer_get_port,
233 pss_query_devinfo,
234 ad1848_malloc,
235 ad1848_free,
236 ad1848_round,
237 ad1848_mappage,
238 ad1848_get_props,
239 NULL,
240 NULL
241 };
242
243
244
245 static u_char wss_interrupt_bits[16] = {
246 0xff, 0xff, 0xff, 0xff,
247 0xff, 0xff, 0xff, 0x08,
248 0xff, 0x10, 0x18, 0x20,
249 0xff, 0xff, 0xff, 0xff
250 };
251
252 static u_char wss_dma_bits[4] = {1, 2, 0, 3};
253
254 struct cfattach pss_ca = {
255 sizeof(struct pss_softc), pssprobe, pssattach
256 };
257
258 struct cfdriver pss_cd = {
259 NULL, "pss", DV_DULL, 1
260 };
261
262 struct cfattach sp_ca = {
263 sizeof(struct ad1848_softc), spprobe, spattach
264 };
265
266 struct cfdriver sp_cd = {
267 NULL, "sp", DV_DULL
268 };
269
270 #ifdef notyet
271 struct cfattach mpu_ca = {
272 sizeof(struct mpu_softc), mpuprobe, mpuattach
273 };
274
275 struct cfdriver mpu_cd = {
276 NULL, "mpu", DV_DULL
277 };
278
279 struct cfattach pcd_ca = {
280 sizeof(struct pcd_softc), pcdprobe, pcdattach
281 };
282
283 struct cfdriver pcd_cd = {
284 NULL, "pcd", DV_DULL
285 };
286 #endif
287
288 struct audio_device pss_device = {
289 "pss,ad1848",
290 "",
291 "PSS"
292 };
293
294 #ifdef PSS_DSP
295 void
296 pss_dspwrite(sc, data)
297 struct pss_softc *sc;
298 int data;
299 {
300 int i;
301 int pss_base = sc->sc_iobase;
302
303
304
305
306
307
308
309
310 for (i = 0; i < 5000000; i++) {
311 if (inw(pss_base+PSS_STATUS) & PSS_WRITE_EMPTY) {
312 outw(pss_base+PSS_DATA, data);
313 return;
314 }
315 }
316 printf ("pss: DSP Command (%04x) Timeout.\n", data);
317 }
318 #endif
319
320 void
321 pss_setaddr(addr, configAddr)
322 int addr;
323 int configAddr;
324 {
325 int val;
326
327 val = inw(configAddr);
328 val &= ADDR_MASK;
329 val |= (addr << 4);
330 outw(configAddr,val);
331 }
332
333
334
335
336
337
338 int
339 pss_setint(intNum, configAddress)
340 int intNum;
341 int configAddress;
342 {
343 int val;
344
345 switch(intNum) {
346 case 3:
347 val = inw(configAddress);
348 val &= INT_MASK;
349 val |= INT_3_BITS;
350 break;
351 case 5:
352 val = inw(configAddress);
353 val &= INT_MASK;
354 val |= INT_5_BITS;
355 break;
356 case 7:
357 val = inw(configAddress);
358 val &= INT_MASK;
359 val |= INT_7_BITS;
360 break;
361 case 9:
362 val = inw(configAddress);
363 val &= INT_MASK;
364 val |= INT_9_BITS;
365 break;
366 case 10:
367 val = inw(configAddress);
368 val &= INT_MASK;
369 val |= INT_10_BITS;
370 break;
371 case 11:
372 val = inw(configAddress);
373 val &= INT_MASK;
374 val |= INT_11_BITS;
375 break;
376 case 12:
377 val = inw(configAddress);
378 val &= INT_MASK;
379 val |= INT_12_BITS;
380 break;
381 default:
382 DPRINTF(("pss_setint: invalid irq (%d)\n", intNum));
383 return 1;
384 }
385 outw(configAddress,val);
386 return 0;
387 }
388
389 int
390 pss_setdma(dmaNum, configAddress)
391 int dmaNum;
392 int configAddress;
393 {
394 int val;
395
396 switch(dmaNum) {
397 case 0:
398 val = inw(configAddress);
399 val &= DMA_MASK;
400 val |= DMA_0_BITS;
401 break;
402 case 1:
403 val = inw(configAddress);
404 val &= DMA_MASK;
405 val |= DMA_1_BITS;
406 break;
407 case 3:
408 val = inw(configAddress);
409 val &= DMA_MASK;
410 val |= DMA_3_BITS;
411 break;
412 case 5:
413 val = inw(configAddress);
414 val &= DMA_MASK;
415 val |= DMA_5_BITS;
416 break;
417 case 6:
418 val = inw(configAddress);
419 val &= DMA_MASK;
420 val |= DMA_6_BITS;
421 break;
422 case 7:
423 val = inw(configAddress);
424 val &= DMA_MASK;
425 val |= DMA_7_BITS;
426 break;
427 default:
428 DPRINTF(("pss_setdma: invalid drq (%d)\n", dmaNum));
429 return 1;
430 }
431 outw(configAddress, val);
432 return 0;
433 }
434
435
436
437
438
439
440
441 int
442 pss_testirq(struct pss_softc *sc, int intNum)
443 {
444 int config = sc->sc_iobase + PSS_CONFIG;
445 int val;
446 int ret;
447 int i;
448
449
450 switch(intNum) {
451 case 3:
452 val = inw(config);
453 val &= INT_MASK;
454 break;
455 case 5:
456 val = inw(config);
457 val &= INT_MASK;
458 val |= INT_TEST_BIT | INT_5_BITS;
459 break;
460 case 7:
461 val = inw(config);
462 val &= INT_MASK;
463 val |= INT_TEST_BIT | INT_7_BITS;
464 break;
465 case 9:
466 val = inw(config);
467 val &= INT_MASK;
468 val |= INT_TEST_BIT | INT_9_BITS;
469 break;
470 case 10:
471 val = inw(config);
472 val &= INT_MASK;
473 val |= INT_TEST_BIT | INT_10_BITS;
474 break;
475 case 11:
476 val = inw(config);
477 val &= INT_MASK;
478 val |= INT_TEST_BIT | INT_11_BITS;
479 break;
480 case 12:
481 val = inw(config);
482 val &= INT_MASK;
483 val |= INT_TEST_BIT | INT_12_BITS;
484 break;
485 default:
486 DPRINTF(("pss_testirq: invalid irq (%d)\n", intNum));
487 return 0;
488 }
489 outw(config, val);
490
491
492
493 ret = 0;
494 for (i = 0; i < 5; i++) {
495 val = inw(config);
496 if (val & INT_TEST_PASS) {
497 ret = 1;
498 break;
499 }
500 }
501
502
503 val = inw(config);
504 val &= INT_TEST_BIT_MASK & INT_MASK;
505 outw(config, val);
506 return(ret);
507 }
508
509
510
511
512
513
514
515 int
516 pss_testdma(sc, dmaNum)
517 struct pss_softc *sc;
518 int dmaNum;
519 {
520 int config = sc->sc_iobase + PSS_CONFIG;
521 int val;
522 int i, ret;
523
524 switch (dmaNum) {
525 case 0:
526 val = inw(config);
527 val &= DMA_MASK;
528 val |= DMA_TEST_BIT | DMA_0_BITS;
529 break;
530 case 1:
531 val = inw(config);
532 val &= DMA_MASK;
533 val |= DMA_TEST_BIT | DMA_1_BITS;
534 break;
535 case 3:
536 val = inw(config);
537 val &= DMA_MASK;
538 val |= DMA_TEST_BIT | DMA_3_BITS;
539 break;
540 case 5:
541 val = inw(config);
542 val &= DMA_MASK;
543 val |= DMA_TEST_BIT | DMA_5_BITS;
544 break;
545 case 6:
546 val = inw(config);
547 val &= DMA_MASK;
548 val |= DMA_TEST_BIT | DMA_6_BITS;
549 break;
550 case 7:
551 val = inw(config);
552 val &= DMA_MASK;
553 val |= DMA_TEST_BIT | DMA_7_BITS;
554 break;
555 default:
556 DPRINTF(("pss_testdma: invalid drq (%d)\n", dmaNum));
557 return 0;
558 }
559 outw(config, val);
560
561
562
563 ret = 0;
564 for (i = 0; i < 3; i++) {
565 val = inw(config);
566 if (val & DMA_TEST_PASS) {
567 ret = 1;
568 break;
569 }
570 }
571
572
573 val = inw(config);
574 val &= DMA_TEST_BIT_MASK & DMA_MASK;
575 outw(config, val);
576 return(ret);
577 }
578
579 #ifdef notyet
580 int
581 pss_reset_dsp(sc)
582 struct pss_softc *sc;
583 {
584 u_long i;
585 int pss_base = sc->sc_iobase;
586
587 outw(pss_base+PSS_CONTROL, PSS_RESET);
588
589 for (i = 0; i < 32768; i++)
590 inw(pss_base+PSS_CONTROL);
591
592 outw(pss_base+PSS_CONTROL, 0);
593
594 return 1;
595 }
596
597
598
599
600
601
602
603
604
605
606
607
608 int
609 pss_download_dsp(sc, block, size)
610 struct pss_softc *sc;
611 u_char *block;
612 int size;
613 {
614 int i, val, count;
615 int pss_base = sc->sc_iobase;
616
617 DPRINTF(("pss: downloading boot code..."));
618
619
620 outw(pss_base+PSS_DATA, 0x00fe);
621
622 for (i = 0; i < 32768; i++)
623 if (inw(pss_base+PSS_DATA) == 0x5500)
624 break;
625 outw(pss_base+PSS_DATA, *block++);
626
627 pss_reset_dsp(sc);
628
629 DPRINTF(("start "));
630
631 count = 1;
632 while(1) {
633 int j;
634 for (j=0; j<327670; j++) {
635
636 if (inw(pss_base+PSS_STATUS) & PSS_FLAG3)
637 break;
638 }
639
640 if (j==327670) {
641
642 if (count >= size)
643 break;
644 else {
645 printf("\npss: DownLoad timeout problems, byte %d=%d\n",
646 count, size);
647 return 0;
648 }
649 }
650
651 outw(pss_base+PSS_DATA, *block++);
652 count++;
653 }
654
655 outw(pss_base+PSS_DATA, 0);
656 for (i = 0; i < 32768; i++)
657 (void) inw(pss_base+PSS_STATUS);
658
659 DPRINTF(("downloaded\n"));
660
661 for (i = 0; i < 32768; i++) {
662 val = inw(pss_base+PSS_STATUS);
663 if (val & PSS_READ_FULL)
664 break;
665 }
666
667
668 for (i = 0; i < 32000; i++) {
669 val = inw(pss_base+PSS_STATUS);
670 if (val & PSS_READ_FULL)
671 break;
672 }
673 if (i == 32000)
674 return 0;
675
676 (void) inw(pss_base+PSS_DATA);
677
678 return 1;
679 }
680 #endif
681
682 #ifdef AUDIO_DEBUG
683 void
684 wss_dump_regs(sc)
685 struct ad1848_softc *sc;
686 {
687
688 printf("WSS reg: status=%02x\n",
689 (u_char)inb(sc->sc_iobase-WSS_CODEC+WSS_STATUS));
690 }
691
692 void
693 pss_dump_regs(sc)
694 struct pss_softc *sc;
695 {
696
697 printf("PSS regs: status=%04x vers=%04x ",
698 (u_short)inw(sc->sc_iobase+PSS_STATUS),
699 (u_short)inw(sc->sc_iobase+PSS_ID_VERS));
700
701 printf("config=%04x wss_config=%04x\n",
702 (u_short)inw(sc->sc_iobase+PSS_CONFIG),
703 (u_short)inw(sc->sc_iobase+PSS_WSS_CONFIG));
704 }
705 #endif
706
707
708
709
710 int
711 pssprobe(parent, self, aux)
712 struct device *parent;
713 void *self;
714 void *aux;
715 {
716 struct pss_softc *sc = self;
717 struct isa_attach_args *ia = aux;
718 int iobase = ia->ia_iobase;
719
720 if (!PSS_BASE_VALID(iobase)) {
721 DPRINTF(("pss: configured iobase %x invalid\n", iobase));
722 return 0;
723 }
724
725
726 if (iobase == IOBASEUNK) {
727
728 iobase = 0x220;
729 if ((inw(iobase+PSS_ID_VERS) & 0xff00) == 0x4500)
730 goto pss_found;
731
732 iobase = 0x240;
733 if ((inw(iobase+PSS_ID_VERS) & 0xff00) == 0x4500)
734 goto pss_found;
735
736 DPRINTF(("pss: no PSS found (at 0x220 or 0x240)\n"));
737 return 0;
738 }
739 else if ((inw(iobase+PSS_ID_VERS) & 0xff00) != 0x4500) {
740 DPRINTF(("pss: not a PSS - %x\n", inw(iobase+PSS_ID_VERS)));
741 return 0;
742 }
743
744 pss_found:
745 sc->sc_iobase = iobase;
746
747
748 pss_setaddr(WSS_BASE_ADDRESS, sc->sc_iobase+PSS_WSS_CONFIG);
749 outb(WSS_BASE_ADDRESS+WSS_CONFIG, 0);
750
751
752 outw(sc->sc_iobase+PSS_CONFIG, 0);
753 outw(sc->sc_iobase+PSS_WSS_CONFIG, 0);
754 outw(sc->sc_iobase+SB_CONFIG, 0);
755 outw(sc->sc_iobase+MIDI_CONFIG, 0);
756 outw(sc->sc_iobase+CD_CONFIG, 0);
757
758 if (ia->ia_irq == IRQUNK) {
759 int i;
760 for (i = 0; i < 16; i++) {
761 if (pss_testirq(sc, i) != 0)
762 break;
763 }
764 if (i == 16) {
765 DPRINTF(("pss: unable to locate free IRQ channel\n"));
766 return 0;
767 }
768 else {
769 ia->ia_irq = i;
770 DPRINTF(("pss: found IRQ %d free\n", i));
771 }
772 }
773 else {
774 if (pss_testirq(sc, ia->ia_irq) == 0) {
775 DPRINTF(("pss: configured IRQ unavailable (%d)\n", ia->ia_irq));
776 return 0;
777 }
778 }
779
780
781 if (pss_testdma(sc, ia->ia_drq) == 0) {
782 DPRINTF(("pss: configured DMA channel unavailable (%d)\n", ia->ia_drq));
783 return 0;
784 }
785
786 ia->ia_iosize = PSS_NPORT;
787
788
789 pss_setint(ia->ia_irq, sc->sc_iobase+PSS_CONFIG);
790 pss_setdma(sc->sc_drq, sc->sc_iobase+PSS_CONFIG);
791
792 #ifdef notyet
793
794 #ifdef PSS_GAMEPORT
795 DPRINTF(("Turning Game Port On.\n"));
796 outw(sc->sc_iobase+PSS_STATUS, inw(sc->sc_iobase+PSS_STATUS) | GAME_BIT);
797 #else
798 outw(sc->sc_iobase+PSS_STATUS, inw(sc->sc_iobase+PSS_STATUS) & GAME_BIT_MASK);
799 #endif
800
801
802 pss_reset_dsp(sc);
803 #endif
804
805 return 1;
806 }
807
808
809
810
811 int
812 spprobe(parent, match, aux)
813 struct device *parent;
814 void *match, *aux;
815 {
816 struct ad1848_softc *sc = match;
817 struct pss_softc *pc = (void *) parent;
818 struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
819 struct isa_attach_args *ia = aux;
820 u_char bits;
821 int i;
822
823 sc->sc_iot = ia->ia_iot;
824 sc->sc_iobase = cf->cf_iobase + WSS_CODEC;
825
826
827 pss_setaddr(cf->cf_iobase, pc->sc_iobase+PSS_WSS_CONFIG);
828
829
830 if (ad1848_probe(sc) == 0) {
831 DPRINTF(("sp: no ad1848 ? iobase=%x\n", sc->sc_iobase));
832 return 0;
833 }
834
835
836 if (cf->cf_irq == IRQUNK) {
837
838
839 for (i = 0; i < 12; i++) {
840 if (wss_interrupt_bits[i] != 0xff) {
841 if (pss_testirq(pc, i))
842 break;
843 }
844 }
845 if (i == 12) {
846 DPRINTF(("sp: unable to locate free IRQ for WSS\n"));
847 return 0;
848 }
849 else {
850 cf->cf_irq = i;
851 sc->sc_irq = i;
852 DPRINTF(("sp: found IRQ %d free\n", i));
853 }
854 }
855 else {
856 sc->sc_irq = cf->cf_irq;
857 if (pss_testirq(pc, sc->sc_irq) == 0) {
858 DPRINTF(("sp: configured IRQ unavailable (%d)\n", sc->sc_irq));
859 return 0;
860 }
861 }
862
863 if (cf->cf_drq == DRQUNK) {
864
865 for (i = 0; i < 4; i++) {
866 if (wss_dma_bits[i]) {
867 if (pss_testdma(pc, i))
868 break;
869 }
870 }
871 if (i == 4) {
872 DPRINTF(("sp: unable to locate free DMA channel for WSS\n"));
873 return 0;
874 }
875 else {
876 sc->sc_drq = cf->cf_drq = i;
877 DPRINTF(("sp: found DMA %d free\n", i));
878 }
879 }
880 else {
881 if (pss_testdma(pc, sc->sc_drq) == 0) {
882 DPRINTF(("sp: configured DMA channel unavailable (%d)\n", sc->sc_drq));
883 return 0;
884 }
885 sc->sc_drq = cf->cf_drq;
886 }
887 sc->sc_recdrq = sc->sc_drq;
888
889
890 if ((bits = wss_interrupt_bits[sc->sc_irq]) == 0xff) {
891 DPRINTF(("sp: invalid interrupt configuration (irq=%d)\n", sc->sc_irq));
892 return 0;
893 }
894
895 outb(sc->sc_iobase+WSS_CONFIG, (bits | 0x40));
896 if ((inb(sc->sc_iobase+WSS_STATUS) & 0x40) == 0)
897 DPRINTF(("sp: IRQ %x\n", inb(sc->sc_iobase+WSS_STATUS)));
898
899 outb(sc->sc_iobase+WSS_CONFIG, (bits | wss_dma_bits[sc->sc_drq]));
900
901 pc->ad1848_sc = sc;
902 sc->parent = pc;
903
904 return 1;
905 }
906
907 #ifdef notyet
908 int
909 mpuprobe(parent, match, aux)
910 struct device *parent;
911 void *match, *aux;
912 {
913 struct mpu_softc *sc = match;
914 struct pss_softc *pc = (void *) parent;
915 struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
916
917
918 sc->sc_iobase = cf->cf_iobase;
919
920 if (cf->cf_irq == IRQUNK) {
921 int i;
922 for (i = 0; i < 16; i++) {
923 if (pss_testirq(pc, i) != 0)
924 break;
925 }
926 if (i == 16) {
927 printf("mpu: unable to locate free IRQ channel for MIDI\n");
928 return 0;
929 }
930 else {
931 cf->cf_irq = i;
932 sc->sc_irq = i;
933 DPRINTF(("mpu: found IRQ %d free\n", i));
934 }
935 }
936 else {
937 sc->sc_irq = cf->cf_irq;
938
939 if (pss_testirq(pc, sc->sc_irq) == 0) {
940 printf("pss: configured MIDI IRQ unavailable (%d)\n", sc->sc_irq);
941 return 0;
942 }
943 }
944
945 outw(pc->sc_iobase+MIDI_CONFIG,0);
946 DPRINTF(("pss: mpu port 0x%x irq %d\n", sc->sc_iobase, sc->sc_irq));
947 pss_setaddr(sc->sc_iobase, pc->sc_iobase+MIDI_CONFIG);
948 pss_setint(sc->sc_irq, pc->sc_iobase+MIDI_CONFIG);
949
950 return 1;
951 }
952
953 int
954 pcdprobe(parent, match, aux)
955 struct device *parent;
956 void *match, *aux;
957 {
958 struct pcd_softc *sc = match;
959 struct pss_softc *pc = (void *) parent;
960 struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
961 u_short val;
962
963 sc->sc_iobase = cf->cf_iobase;
964
965 pss_setaddr(sc->sc_iobase, pc->sc_iobase+CD_CONFIG);
966
967
968 val = inw(pc->sc_iobase+CD_CONFIG);
969 outw(pc->sc_iobase+CD_CONFIG, 0);
970 val &= CD_POL_MASK;
971 val |= CD_POL_BIT;
972 outw(pc->sc_iobase+CD_CONFIG, val);
973
974 if (cf->cf_irq == IRQUNK) {
975 int i;
976 for (i = 0; i < 16; i++) {
977 if (pss_testirq(pc, i) != 0)
978 break;
979 }
980 if (i == 16) {
981 printf("pcd: unable to locate free IRQ channel for CD\n");
982 return 0;
983 }
984 else {
985 cf->cf_irq = i;
986 sc->sc_irq = i;
987 DPRINTF(("pcd: found IRQ %d free\n", i));
988 }
989 }
990 else {
991 sc->sc_irq = cf->cf_irq;
992
993 if (pss_testirq(pc, sc->sc_irq) == 0) {
994 printf("pcd: configured CD IRQ unavailable (%d)\n", sc->sc_irq);
995 return 0;
996 }
997 return 1;
998 }
999 pss_setint(sc->sc_irq, pc->sc_iobase+CD_CONFIG);
1000
1001 return 1;
1002 }
1003 #endif
1004
1005
1006
1007
1008
1009 void
1010 pssattach(parent, self, aux)
1011 struct device *parent, *self;
1012 void *aux;
1013 {
1014 struct pss_softc *sc = (struct pss_softc *)self;
1015 struct isa_attach_args *ia = (struct isa_attach_args *)aux;
1016 int iobase = ia->ia_iobase;
1017 u_char vers;
1018 struct ad1848_volume vol = {150, 150};
1019
1020 sc->sc_iobase = iobase;
1021 sc->sc_drq = ia->ia_drq;
1022
1023
1024 sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE, IPL_AUDIO,
1025 pssintr, sc, sc->sc_dev.dv_xname);
1026
1027 vers = (inw(sc->sc_iobase+PSS_ID_VERS)&0xff) - 1;
1028 printf(": ESC614%c\n", (vers > 0)?'A'+vers:' ');
1029
1030 (void)config_found(self, ia->ia_ic, NULL);
1031
1032 sc->out_port = PSS_MASTER_VOL;
1033
1034 (void)pss_set_master_mode(sc, PSS_SPKR_STEREO);
1035 (void)pss_set_master_gain(sc, &vol);
1036 (void)pss_set_treble(sc, AUDIO_MAX_GAIN/2);
1037 (void)pss_set_bass(sc, AUDIO_MAX_GAIN/2);
1038
1039 audio_attach_mi(&pss_audio_if, sc->ad1848_sc, &sc->ad1848_sc->sc_dev);
1040 }
1041
1042 void
1043 spattach(parent, self, aux)
1044 struct device *parent, *self;
1045 void *aux;
1046 {
1047 struct ad1848_softc *sc = (struct ad1848_softc *)self;
1048 struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
1049 isa_chipset_tag_t ic = aux;
1050 int iobase = cf->cf_iobase;
1051
1052 sc->sc_iobase = iobase;
1053 sc->sc_drq = cf->cf_drq;
1054
1055 sc->sc_ih = isa_intr_establish(ic, cf->cf_irq, IST_EDGE, IPL_AUDIO,
1056 ad1848_intr, sc, sc->sc_dev.dv_xname);
1057
1058 sc->sc_isa = parent->dv_parent;
1059
1060 ad1848_attach(sc);
1061
1062 printf("\n");
1063 }
1064
1065 #ifdef notyet
1066 void
1067 mpuattach(parent, self, aux)
1068 struct device *parent, *self;
1069 void *aux;
1070 {
1071 struct mpu_softc *sc = (struct mpu_softc *)self;
1072 struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
1073 isa_chipset_tag_t ic = aux;
1074 int iobase = cf->cf_iobase;
1075
1076 sc->sc_iobase = iobase;
1077
1078 sc->sc_ih = isa_intr_establish(ic, cf->cf_irq, IST_EDGE, IPL_AUDIO,
1079 mpuintr, sc, sc->sc_dev.dv_xname);
1080
1081
1082 printf(" port 0x%x/%d irq %d\n",
1083 sc->sc_iobase, MIDI_NPORT, cf->cf_irq);
1084 }
1085
1086 void
1087 pcdattach(parent, self, aux)
1088 struct device *parent, *self;
1089 void *aux;
1090 {
1091 struct pcd_softc *sc = (struct pcd_softc *)self;
1092 struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
1093 int iobase = cf->cf_iobase;
1094
1095
1096
1097
1098
1099
1100 sc->sc_iobase = iobase;
1101
1102
1103 printf(" port 0x%x/%d irq %d\n",
1104 sc->sc_iobase, 2, cf->cf_irq);
1105 }
1106 #endif
1107
1108
1109 int
1110 pss_set_master_gain(sc, gp)
1111 struct pss_softc *sc;
1112 struct ad1848_volume *gp;
1113 {
1114 DPRINTF(("pss_set_master_gain: %d:%d\n", gp->left, gp->right));
1115
1116 #ifdef PSS_DSP
1117 if (gp->left > PHILLIPS_VOL_MAX)
1118 gp->left = PHILLIPS_VOL_MAX;
1119 if (gp->left < PHILLIPS_VOL_MIN)
1120 gp->left = PHILLIPS_VOL_MIN;
1121 if (gp->right > PHILLIPS_VOL_MAX)
1122 gp->right = PHILLIPS_VOL_MAX;
1123 if (gp->right < PHILLIPS_VOL_MIN)
1124 gp->right = PHILLIPS_VOL_MIN;
1125
1126 pss_dspwrite(sc, SET_MASTER_COMMAND);
1127 pss_dspwrite(sc, MASTER_VOLUME_LEFT|(PHILLIPS_VOL_CONSTANT + gp->left / PHILLIPS_VOL_STEP));
1128 pss_dspwrite(sc, SET_MASTER_COMMAND);
1129 pss_dspwrite(sc, MASTER_VOLUME_RIGHT|(PHILLIPS_VOL_CONSTANT + gp->right / PHILLIPS_VOL_STEP));
1130 #endif
1131
1132 sc->master_volume = *gp;
1133 return(0);
1134 }
1135
1136 int
1137 pss_set_master_mode(sc, mode)
1138 struct pss_softc *sc;
1139 int mode;
1140 {
1141 short phillips_mode;
1142
1143 DPRINTF(("pss_set_master_mode: %d\n", mode));
1144
1145 if (mode == PSS_SPKR_STEREO)
1146 phillips_mode = PSS_STEREO;
1147 else if (mode == PSS_SPKR_PSEUDO)
1148 phillips_mode = PSS_PSEUDO;
1149 else if (mode == PSS_SPKR_SPATIAL)
1150 phillips_mode = PSS_SPATIAL;
1151 else if (mode == PSS_SPKR_MONO)
1152 phillips_mode = PSS_MONO;
1153 else
1154 return (EINVAL);
1155
1156 #ifdef PSS_DSP
1157 pss_dspwrite(sc, SET_MASTER_COMMAND);
1158 pss_dspwrite(sc, MASTER_SWITCH | mode);
1159 #endif
1160
1161 sc->master_mode = mode;
1162
1163 return(0);
1164 }
1165
1166 int
1167 pss_set_treble(sc, treb)
1168 struct pss_softc *sc;
1169 u_int treb;
1170 {
1171 DPRINTF(("pss_set_treble: %d\n", treb));
1172
1173 #ifdef PSS_DSP
1174 if (treb > PHILLIPS_TREBLE_MAX)
1175 treb = PHILLIPS_TREBLE_MAX;
1176 if (treb < PHILLIPS_TREBLE_MIN)
1177 treb = PHILLIPS_TREBLE_MIN;
1178 pss_dspwrite(sc, SET_MASTER_COMMAND);
1179 pss_dspwrite(sc, MASTER_TREBLE|(PHILLIPS_TREBLE_CONSTANT + treb / PHILLIPS_TREBLE_STEP));
1180 #endif
1181
1182 sc->monitor_treble = treb;
1183
1184 return(0);
1185 }
1186
1187 int
1188 pss_set_bass(sc, bass)
1189 struct pss_softc *sc;
1190 u_int bass;
1191 {
1192 DPRINTF(("pss_set_bass: %d\n", bass));
1193
1194 #ifdef PSS_DSP
1195 if (bass > PHILLIPS_BASS_MAX)
1196 bass = PHILLIPS_BASS_MAX;
1197 if (bass < PHILLIPS_BASS_MIN)
1198 bass = PHILLIPS_BASS_MIN;
1199 pss_dspwrite(sc, SET_MASTER_COMMAND);
1200 pss_dspwrite(sc, MASTER_BASS|(PHILLIPS_BASS_CONSTANT + bass / PHILLIPS_BASS_STEP));
1201 #endif
1202
1203 sc->monitor_bass = bass;
1204
1205 return(0);
1206 }
1207
1208 int
1209 pss_get_master_gain(sc, gp)
1210 struct pss_softc *sc;
1211 struct ad1848_volume *gp;
1212 {
1213 *gp = sc->master_volume;
1214 return(0);
1215 }
1216
1217 int
1218 pss_get_master_mode(sc, mode)
1219 struct pss_softc *sc;
1220 u_int *mode;
1221 {
1222 *mode = sc->master_mode;
1223 return(0);
1224 }
1225
1226 int
1227 pss_get_treble(sc, tp)
1228 struct pss_softc *sc;
1229 u_char *tp;
1230 {
1231 *tp = sc->monitor_treble;
1232 return(0);
1233 }
1234
1235 int
1236 pss_get_bass(sc, bp)
1237 struct pss_softc *sc;
1238 u_char *bp;
1239 {
1240 *bp = sc->monitor_bass;
1241 return(0);
1242 }
1243
1244 int
1245 pss_speaker_ctl(addr, newstate)
1246 void *addr;
1247 int newstate;
1248 {
1249 return(0);
1250 }
1251
1252 int
1253 pssintr(arg)
1254 void *arg;
1255 {
1256 struct pss_softc *sc = arg;
1257 u_short sr;
1258
1259 sr = inw(sc->sc_iobase+PSS_STATUS);
1260
1261 DPRINTF(("pssintr: sc=%p st=%x\n", sc, sr));
1262
1263
1264 outw(sc->sc_iobase+PSS_IRQ_ACK, 0);
1265
1266
1267 if (sr & (PSS_WRITE_EMPTY|PSS_READ_FULL|PSS_IRQ|PSS_DMQ_TC)) {
1268
1269 return 1;
1270 }
1271
1272 return 0;
1273 }
1274
1275 #ifdef notyet
1276 int
1277 mpuintr(arg)
1278 void *arg;
1279 {
1280 struct mpu_softc *sc = arg;
1281 u_char sr;
1282
1283 sr = inb(sc->sc_iobase+MIDI_STATUS_REG);
1284
1285 printf("mpuintr: sc=%p sr=%x\n", sc, sr);
1286
1287
1288 return 1;
1289 }
1290 #endif
1291
1292 int
1293 pss_getdev(addr, retp)
1294 void *addr;
1295 struct audio_device *retp;
1296 {
1297 DPRINTF(("pss_getdev: retp=%p\n", retp));
1298
1299 *retp = pss_device;
1300 return 0;
1301 }
1302
1303 static ad1848_devmap_t mappings[] = {
1304 { PSS_MIC_IN_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL },
1305 { PSS_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL },
1306 { PSS_DAC_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL },
1307 { PSS_MON_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL },
1308 { PSS_MIC_IN_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL },
1309 { PSS_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL },
1310 { PSS_DAC_MUTE, AD1848_KIND_MUTE, AD1848_DAC_CHANNEL },
1311 { PSS_REC_LVL, AD1848_KIND_RECORDGAIN, -1 },
1312 { PSS_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1}
1313 };
1314
1315 static int nummap = sizeof(mappings) / sizeof(mappings[0]);
1316
1317 int
1318 pss_mixer_set_port(addr, cp)
1319 void *addr;
1320 mixer_ctrl_t *cp;
1321 {
1322 struct ad1848_softc *ac = addr;
1323 struct pss_softc *sc = ac->parent;
1324 struct ad1848_volume vol;
1325 int error = ad1848_mixer_set_port(ac, mappings, nummap, cp);
1326
1327 if (error != ENXIO)
1328 return (error);
1329
1330 switch (cp->dev) {
1331 case PSS_MASTER_VOL:
1332 if (cp->type == AUDIO_MIXER_VALUE) {
1333 if (ad1848_to_vol(cp, &vol))
1334 error = pss_set_master_gain(sc, &vol);
1335 }
1336 break;
1337
1338 case PSS_OUTPUT_MODE:
1339 if (cp->type == AUDIO_MIXER_ENUM)
1340 error = pss_set_master_mode(sc, cp->un.ord);
1341 break;
1342
1343 case PSS_MASTER_TREBLE:
1344 if (cp->type == AUDIO_MIXER_VALUE && cp->un.value.num_channels == 1)
1345 error = pss_set_treble(sc, (u_char)cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
1346 break;
1347
1348 case PSS_MASTER_BASS:
1349 if (cp->type == AUDIO_MIXER_VALUE && cp->un.value.num_channels == 1)
1350 error = pss_set_bass(sc, (u_char)cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
1351 break;
1352
1353 default:
1354 return ENXIO;
1355
1356 }
1357
1358 return 0;
1359 }
1360
1361 int
1362 pss_mixer_get_port(addr, cp)
1363 void *addr;
1364 mixer_ctrl_t *cp;
1365 {
1366 struct ad1848_softc *ac = addr;
1367 struct pss_softc *sc = ac->parent;
1368 struct ad1848_volume vol;
1369 u_char eq;
1370 int error = ad1848_mixer_get_port(ac, mappings, nummap, cp);
1371
1372 if (error != ENXIO)
1373 return (error);
1374
1375 error = EINVAL;
1376
1377 switch (cp->dev) {
1378 case PSS_MASTER_VOL:
1379 if (cp->type == AUDIO_MIXER_VALUE) {
1380 error = pss_get_master_gain(sc, &vol);
1381 if (!error)
1382 ad1848_from_vol(cp, &vol);
1383 }
1384 break;
1385
1386 case PSS_MASTER_TREBLE:
1387 if (cp->type == AUDIO_MIXER_VALUE && cp->un.value.num_channels == 1) {
1388 error = pss_get_treble(sc, &eq);
1389 if (!error)
1390 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = eq;
1391 }
1392 break;
1393
1394 case PSS_MASTER_BASS:
1395 if (cp->type == AUDIO_MIXER_VALUE && cp->un.value.num_channels == 1) {
1396 error = pss_get_bass(sc, &eq);
1397 if (!error)
1398 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = eq;
1399 }
1400 break;
1401
1402 case PSS_OUTPUT_MODE:
1403 if (cp->type == AUDIO_MIXER_ENUM)
1404 error = pss_get_master_mode(sc, &cp->un.ord);
1405 break;
1406
1407 default:
1408 error = ENXIO;
1409 break;
1410 }
1411
1412 return(error);
1413 }
1414
1415 int
1416 pss_query_devinfo(addr, dip)
1417 void *addr;
1418 mixer_devinfo_t *dip;
1419 {
1420 DPRINTF(("pss_query_devinfo: index=%d\n", dip->index));
1421
1422 switch(dip->index) {
1423 case PSS_MIC_IN_LVL:
1424 dip->type = AUDIO_MIXER_VALUE;
1425 dip->mixer_class = PSS_INPUT_CLASS;
1426 dip->prev = AUDIO_MIXER_LAST;
1427 dip->next = PSS_MIC_IN_MUTE;
1428 strlcpy(dip->label.name, AudioNmicrophone, sizeof dip->label.name);
1429 dip->un.v.num_channels = 2;
1430 strlcpy(dip->un.v.units.name, AudioNvolume,
1431 sizeof dip->un.v.units.name);
1432 break;
1433
1434 case PSS_LINE_IN_LVL:
1435 dip->type = AUDIO_MIXER_VALUE;
1436 dip->mixer_class = PSS_INPUT_CLASS;
1437 dip->prev = AUDIO_MIXER_LAST;
1438 dip->next = PSS_LINE_IN_MUTE;
1439 strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
1440 dip->un.v.num_channels = 2;
1441 strlcpy(dip->un.v.units.name, AudioNvolume,
1442 sizeof dip->un.v.units.name);
1443 break;
1444
1445 case PSS_DAC_LVL:
1446 dip->type = AUDIO_MIXER_VALUE;
1447 dip->mixer_class = PSS_INPUT_CLASS;
1448 dip->prev = AUDIO_MIXER_LAST;
1449 dip->next = PSS_DAC_MUTE;
1450 strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
1451 dip->un.v.num_channels = 2;
1452 strlcpy(dip->un.v.units.name, AudioNvolume,
1453 sizeof dip->un.v.units.name);
1454 break;
1455
1456 case PSS_REC_LVL:
1457 dip->type = AUDIO_MIXER_VALUE;
1458 dip->mixer_class = PSS_RECORD_CLASS;
1459 dip->prev = AUDIO_MIXER_LAST;
1460 dip->next = PSS_RECORD_SOURCE;
1461 strlcpy(dip->label.name, AudioNrecord, sizeof dip->label.name);
1462 dip->un.v.num_channels = 2;
1463 strlcpy(dip->un.v.units.name, AudioNvolume,
1464 sizeof dip->un.v.units.name);
1465 break;
1466
1467 case PSS_MON_LVL:
1468 dip->type = AUDIO_MIXER_VALUE;
1469 dip->mixer_class = PSS_MONITOR_CLASS;
1470 dip->next = dip->prev = AUDIO_MIXER_LAST;
1471 strlcpy(dip->label.name, AudioNmonitor, sizeof dip->label.name);
1472 dip->un.v.num_channels = 1;
1473 strlcpy(dip->un.v.units.name, AudioNvolume,
1474 sizeof dip->un.v.units.name);
1475 break;
1476
1477 case PSS_MASTER_VOL:
1478 dip->type = AUDIO_MIXER_VALUE;
1479 dip->mixer_class = PSS_OUTPUT_CLASS;
1480 dip->prev = AUDIO_MIXER_LAST;
1481 dip->next = PSS_OUTPUT_MODE;
1482 strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
1483 dip->un.v.num_channels = 2;
1484 strlcpy(dip->un.v.units.name, AudioNvolume,
1485 sizeof dip->un.v.units.name);
1486 break;
1487
1488 case PSS_MASTER_TREBLE:
1489 dip->type = AUDIO_MIXER_VALUE;
1490 dip->mixer_class = PSS_OUTPUT_CLASS;
1491 dip->next = dip->prev = AUDIO_MIXER_LAST;
1492 strlcpy(dip->label.name, AudioNtreble, sizeof dip->label.name);
1493 dip->un.v.num_channels = 1;
1494 strlcpy(dip->un.v.units.name, AudioNtreble,
1495 sizeof dip->un.v.units.name);
1496 break;
1497
1498 case PSS_MASTER_BASS:
1499 dip->type = AUDIO_MIXER_VALUE;
1500 dip->mixer_class = PSS_OUTPUT_CLASS;
1501 dip->next = dip->prev = AUDIO_MIXER_LAST;
1502 strlcpy(dip->label.name, AudioNbass, sizeof dip->label.name);
1503 dip->un.v.num_channels = 1;
1504 strlcpy(dip->un.v.units.name, AudioNbass, sizeof dip->un.v.units.name);
1505 break;
1506
1507 case PSS_OUTPUT_CLASS:
1508 dip->type = AUDIO_MIXER_CLASS;
1509 dip->mixer_class = PSS_OUTPUT_CLASS;
1510 dip->next = dip->prev = AUDIO_MIXER_LAST;
1511 strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
1512 break;
1513
1514 case PSS_INPUT_CLASS:
1515 dip->type = AUDIO_MIXER_CLASS;
1516 dip->mixer_class = PSS_INPUT_CLASS;
1517 dip->next = dip->prev = AUDIO_MIXER_LAST;
1518 strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
1519 break;
1520
1521 case PSS_MONITOR_CLASS:
1522 dip->type = AUDIO_MIXER_CLASS;
1523 dip->mixer_class = PSS_MONITOR_CLASS;
1524 dip->next = dip->prev = AUDIO_MIXER_LAST;
1525 strlcpy(dip->label.name, AudioCmonitor, sizeof dip->label.name);
1526 break;
1527
1528 case PSS_RECORD_CLASS:
1529 dip->type = AUDIO_MIXER_CLASS;
1530 dip->mixer_class = PSS_RECORD_CLASS;
1531 dip->next = dip->prev = AUDIO_MIXER_LAST;
1532 strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
1533 break;
1534
1535 case PSS_MIC_IN_MUTE:
1536 dip->mixer_class = PSS_INPUT_CLASS;
1537 dip->type = AUDIO_MIXER_ENUM;
1538 dip->prev = PSS_MIC_IN_LVL;
1539 dip->next = AUDIO_MIXER_LAST;
1540 goto mute;
1541
1542 case PSS_LINE_IN_MUTE:
1543 dip->mixer_class = PSS_INPUT_CLASS;
1544 dip->type = AUDIO_MIXER_ENUM;
1545 dip->prev = PSS_LINE_IN_LVL;
1546 dip->next = AUDIO_MIXER_LAST;
1547 goto mute;
1548
1549 case PSS_DAC_MUTE:
1550 dip->mixer_class = PSS_INPUT_CLASS;
1551 dip->type = AUDIO_MIXER_ENUM;
1552 dip->prev = PSS_DAC_LVL;
1553 dip->next = AUDIO_MIXER_LAST;
1554 mute:
1555 strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
1556 dip->un.e.num_mem = 2;
1557 strlcpy(dip->un.e.member[0].label.name, AudioNoff,
1558 sizeof dip->un.e.member[0].label.name);
1559 dip->un.e.member[0].ord = 0;
1560 strlcpy(dip->un.e.member[1].label.name, AudioNon,
1561 sizeof dip->un.e.member[1].label.name);
1562 dip->un.e.member[1].ord = 1;
1563 break;
1564
1565 case PSS_OUTPUT_MODE:
1566 dip->mixer_class = PSS_OUTPUT_CLASS;
1567 dip->type = AUDIO_MIXER_ENUM;
1568 dip->prev = PSS_MASTER_VOL;
1569 dip->next = AUDIO_MIXER_LAST;
1570 strlcpy(dip->label.name, AudioNmode, sizeof dip->label.name);
1571 dip->un.e.num_mem = 4;
1572 strlcpy(dip->un.e.member[0].label.name, AudioNmono,
1573 sizeof dip->un.e.member[0].label.name);
1574 dip->un.e.member[0].ord = PSS_SPKR_MONO;
1575 strlcpy(dip->un.e.member[1].label.name, AudioNstereo,
1576 sizeof dip->un.e.member[1].label.name);
1577 dip->un.e.member[1].ord = PSS_SPKR_STEREO;
1578 strlcpy(dip->un.e.member[2].label.name, AudioNpseudo,
1579 sizeof dip->un.e.member[2].label.name);
1580 dip->un.e.member[2].ord = PSS_SPKR_PSEUDO;
1581 strlcpy(dip->un.e.member[3].label.name, AudioNspatial,
1582 sizeof dip->un.e.member[3].label.name);
1583 dip->un.e.member[3].ord = PSS_SPKR_SPATIAL;
1584 break;
1585
1586 case PSS_RECORD_SOURCE:
1587 dip->mixer_class = PSS_RECORD_CLASS;
1588 dip->type = AUDIO_MIXER_ENUM;
1589 dip->prev = PSS_REC_LVL;
1590 dip->next = AUDIO_MIXER_LAST;
1591 strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
1592 dip->un.e.num_mem = 3;
1593 strlcpy(dip->un.e.member[0].label.name, AudioNmicrophone,
1594 sizeof dip->un.e.member[0].label.name);
1595 dip->un.e.member[0].ord = PSS_MIC_IN_LVL;
1596 strlcpy(dip->un.e.member[1].label.name, AudioNcd,
1597 sizeof dip->un.e.member[1].label.name);
1598 dip->un.e.member[1].ord = PSS_LINE_IN_LVL;
1599 strlcpy(dip->un.e.member[2].label.name, AudioNdac,
1600 sizeof dip->un.e.member[2].label.name);
1601 dip->un.e.member[2].ord = PSS_DAC_LVL;
1602 break;
1603
1604 default:
1605 return ENXIO;
1606
1607 }
1608 DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name));
1609
1610 return 0;
1611 }