![[BACK]](/icons/back.gif){kind=icon}
Return to sbdsp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa|
Return to sbdsp.c CVS log | Up to [local] / sys / dev / isa |
1.1 nbrk 1: /* $OpenBSD: sbdsp.c,v 1.25 2006/12/29 13:04:37 pedro Exp $ */
2:
3: /*
4: * Copyright (c) 1991-1993 Regents of the University of California.
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by the Computer Systems
18: * Engineering Group at Lawrence Berkeley Laboratory.
19: * 4. Neither the name of the University nor of the Laboratory may be used
20: * to endorse or promote products derived from this software without
21: * specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: *
35: */
36:
37: /*
38: * SoundBlaster Pro code provided by John Kohl, based on lots of
39: * information he gleaned from Steve Haehnichen <steve@vigra.com>'s
40: * SBlast driver for 386BSD and DOS driver code from Daniel Sachs
41: * <sachs@meibm15.cen.uiuc.edu>.
42: * Lots of rewrites by Lennart Augustsson <augustss@cs.chalmers.se>
43: * with information from SB "Hardware Programming Guide" and the
44: * Linux drivers.
45: */
46:
47: #include "midi.h"
48:
49: #include <sys/param.h>
50: #include <sys/systm.h>
51: #include <sys/errno.h>
52: #include <sys/ioctl.h>
53: #include <sys/syslog.h>
54: #include <sys/device.h>
55: #include <sys/proc.h>
56: #include <sys/buf.h>
57:
58: #include <machine/cpu.h>
59: #include <machine/intr.h>
60: #include <machine/bus.h>
61:
62: #include <sys/audioio.h>
63: #include <dev/audio_if.h>
64: #include <dev/midi_if.h>
65: #include <dev/mulaw.h>
66: #include <dev/auconv.h>
67:
68: #include <dev/isa/isavar.h>
69: #include <dev/isa/isadmavar.h>
70:
71: #include <dev/isa/sbreg.h>
72: #include <dev/isa/sbdspvar.h>
73:
74:
75: #ifdef AUDIO_DEBUG
76: #define DPRINTF(x) if (sbdspdebug) printf x
77: #define DPRINTFN(n,x) if (sbdspdebug >= (n)) printf x
78: int sbdspdebug = 0;
79: #else
80: #define DPRINTF(x)
81: #define DPRINTFN(n,x)
82: #endif
83:
84: #ifndef SBDSP_NPOLL
85: #define SBDSP_NPOLL 3000
86: #endif
87:
88: struct {
89: int wdsp;
90: int rdsp;
91: int wmidi;
92: } sberr;
93:
94: /*
95: * Time constant routines follow. See SBK, section 12.
96: * Although they don't come out and say it (in the docs),
97: * the card clearly uses a 1MHz countdown timer, as the
98: * low-speed formula (p. 12-4) is:
99: * tc = 256 - 10^6 / sr
100: * In high-speed mode, the constant is the upper byte of a 16-bit counter,
101: * and a 256MHz clock is used:
102: * tc = 65536 - 256 * 10^ 6 / sr
103: * Since we can only use the upper byte of the HS TC, the two formulae
104: * are equivalent. (Why didn't they say so?) E.g.,
105: * (65536 - 256 * 10 ^ 6 / x) >> 8 = 256 - 10^6 / x
106: *
107: * The crossover point (from low- to high-speed modes) is different
108: * for the SBPRO and SB20. The table on p. 12-5 gives the following data:
109: *
110: * SBPRO SB20
111: * ----- --------
112: * input ls min 4 KHz 4 KHz
113: * input ls max 23 KHz 13 KHz
114: * input hs max 44.1 KHz 15 KHz
115: * output ls min 4 KHz 4 KHz
116: * output ls max 23 KHz 23 KHz
117: * output hs max 44.1 KHz 44.1 KHz
118: */
119: /* XXX Should we round the tc?
120: #define SB_RATE_TO_TC(x) (((65536 - 256 * 1000000 / (x)) + 128) >> 8)
121: */
122: #define SB_RATE_TO_TC(x) (256 - 1000000 / (x))
123: #define SB_TC_TO_RATE(tc) (1000000 / (256 - (tc)))
124:
125: struct sbmode {
126: short model;
127: u_char channels;
128: u_char precision;
129: u_short lowrate, highrate;
130: u_char cmd;
131: u_char cmdchan;
132: };
133: static struct sbmode sbpmodes[] = {
134: { SB_1, 1, 8, 4000, 22727, SB_DSP_WDMA },
135: { SB_20, 1, 8, 4000, 22727, SB_DSP_WDMA_LOOP },
136: { SB_2x, 1, 8, 4000, 22727, SB_DSP_WDMA_LOOP },
137: { SB_2x, 1, 8, 22727, 45454, SB_DSP_HS_OUTPUT },
138: { SB_PRO, 1, 8, 4000, 22727, SB_DSP_WDMA_LOOP },
139: { SB_PRO, 1, 8, 22727, 45454, SB_DSP_HS_OUTPUT },
140: { SB_PRO, 2, 8, 11025, 22727, SB_DSP_HS_OUTPUT },
141: /* Yes, we write the record mode to set 16-bit playback mode. weird, huh? */
142: { SB_JAZZ, 1, 8, 4000, 22727, SB_DSP_WDMA_LOOP, SB_DSP_RECORD_MONO },
143: { SB_JAZZ, 1, 8, 22727, 45454, SB_DSP_HS_OUTPUT, SB_DSP_RECORD_MONO },
144: { SB_JAZZ, 2, 8, 11025, 22727, SB_DSP_HS_OUTPUT, SB_DSP_RECORD_STEREO },
145: { SB_JAZZ, 1, 16, 4000, 22727, SB_DSP_WDMA_LOOP, JAZZ16_RECORD_MONO },
146: { SB_JAZZ, 1, 16, 22727, 45454, SB_DSP_HS_OUTPUT, JAZZ16_RECORD_MONO },
147: { SB_JAZZ, 2, 16, 11025, 22727, SB_DSP_HS_OUTPUT, JAZZ16_RECORD_STEREO },
148: { SB_16, 1, 8, 5000, 45000, SB_DSP16_WDMA_8 },
149: { SB_16, 2, 8, 5000, 45000, SB_DSP16_WDMA_8 },
150: #define PLAY16 15 /* must be the index of the next entry in the table */
151: { SB_16, 1, 16, 5000, 45000, SB_DSP16_WDMA_16 },
152: { SB_16, 2, 16, 5000, 45000, SB_DSP16_WDMA_16 },
153: { -1 }
154: };
155: static struct sbmode sbrmodes[] = {
156: { SB_1, 1, 8, 4000, 12987, SB_DSP_RDMA },
157: { SB_20, 1, 8, 4000, 12987, SB_DSP_RDMA_LOOP },
158: { SB_2x, 1, 8, 4000, 12987, SB_DSP_RDMA_LOOP },
159: { SB_2x, 1, 8, 12987, 14925, SB_DSP_HS_INPUT },
160: { SB_PRO, 1, 8, 4000, 22727, SB_DSP_RDMA_LOOP, SB_DSP_RECORD_MONO },
161: { SB_PRO, 1, 8, 22727, 45454, SB_DSP_HS_INPUT, SB_DSP_RECORD_MONO },
162: { SB_PRO, 2, 8, 11025, 22727, SB_DSP_HS_INPUT, SB_DSP_RECORD_STEREO },
163: { SB_JAZZ, 1, 8, 4000, 22727, SB_DSP_RDMA_LOOP, SB_DSP_RECORD_MONO },
164: { SB_JAZZ, 1, 8, 22727, 45454, SB_DSP_HS_INPUT, SB_DSP_RECORD_MONO },
165: { SB_JAZZ, 2, 8, 11025, 22727, SB_DSP_HS_INPUT, SB_DSP_RECORD_STEREO },
166: { SB_JAZZ, 1, 16, 4000, 22727, SB_DSP_RDMA_LOOP, JAZZ16_RECORD_MONO },
167: { SB_JAZZ, 1, 16, 22727, 45454, SB_DSP_HS_INPUT, JAZZ16_RECORD_MONO },
168: { SB_JAZZ, 2, 16, 11025, 22727, SB_DSP_HS_INPUT, JAZZ16_RECORD_STEREO },
169: { SB_16, 1, 8, 5000, 45000, SB_DSP16_RDMA_8 },
170: { SB_16, 2, 8, 5000, 45000, SB_DSP16_RDMA_8 },
171: { SB_16, 1, 16, 5000, 45000, SB_DSP16_RDMA_16 },
172: { SB_16, 2, 16, 5000, 45000, SB_DSP16_RDMA_16 },
173: { -1 }
174: };
175:
176: void sbversion(struct sbdsp_softc *);
177: void sbdsp_jazz16_probe(struct sbdsp_softc *);
178: void sbdsp_set_mixer_gain(struct sbdsp_softc *sc, int port);
179: void sbdsp_to(void *);
180: void sbdsp_pause(struct sbdsp_softc *);
181: int sbdsp_set_timeconst(struct sbdsp_softc *, int);
182: int sbdsp16_set_rate(struct sbdsp_softc *, int, int);
183: int sbdsp_set_in_ports(struct sbdsp_softc *, int);
184: void sbdsp_set_ifilter(void *, int);
185: int sbdsp_get_ifilter(void *);
186:
187: int sbdsp_block_output(void *);
188: int sbdsp_block_input(void *);
189: static int sbdsp_adjust(int, int);
190:
191: int sbdsp_midi_intr(void *);
192:
193: #ifdef AUDIO_DEBUG
194: void sb_printsc(struct sbdsp_softc *);
195:
196: void
197: sb_printsc(sc)
198: struct sbdsp_softc *sc;
199: {
200: int i;
201:
202: printf("open %d dmachan %d/%d %d/%d iobase 0x%x irq %d\n",
203: (int)sc->sc_open, sc->sc_i.run, sc->sc_o.run,
204: sc->sc_drq8, sc->sc_drq16,
205: sc->sc_iobase, sc->sc_irq);
206: printf("irate %d itc %x orate %d otc %x\n",
207: sc->sc_i.rate, sc->sc_i.tc,
208: sc->sc_o.rate, sc->sc_o.tc);
209: printf("spkron %u nintr %lu\n",
210: sc->spkr_state, sc->sc_interrupts);
211: printf("intr8 %p arg8 %p\n",
212: sc->sc_intr8, sc->sc_arg16);
213: printf("intr16 %p arg16 %p\n",
214: sc->sc_intr8, sc->sc_arg16);
215: printf("gain:");
216: for (i = 0; i < SB_NDEVS; i++)
217: printf(" %u,%u", sc->gain[i][SB_LEFT], sc->gain[i][SB_RIGHT]);
218: printf("\n");
219: }
220: #endif /* AUDIO_DEBUG */
221:
222: /*
223: * Probe / attach routines.
224: */
225:
226: /*
227: * Probe for the soundblaster hardware.
228: */
229: int
230: sbdsp_probe(sc)
231: struct sbdsp_softc *sc;
232: {
233:
234: if (sbdsp_reset(sc) < 0) {
235: DPRINTF(("sbdsp: couldn't reset card\n"));
236: return 0;
237: }
238: /* if flags set, go and probe the jazz16 stuff */
239: if (sc->sc_dev.dv_cfdata->cf_flags & 1)
240: sbdsp_jazz16_probe(sc);
241: else
242: sbversion(sc);
243: if (sc->sc_model == SB_UNK) {
244: /* Unknown SB model found. */
245: DPRINTF(("sbdsp: unknown SB model found\n"));
246: return 0;
247: }
248: return 1;
249: }
250:
251: /*
252: * Try add-on stuff for Jazz16.
253: */
254: void
255: sbdsp_jazz16_probe(sc)
256: struct sbdsp_softc *sc;
257: {
258: static u_char jazz16_irq_conf[16] = {
259: -1, -1, 0x02, 0x03,
260: -1, 0x01, -1, 0x04,
261: -1, 0x02, 0x05, -1,
262: -1, -1, -1, 0x06};
263: static u_char jazz16_drq_conf[8] = {
264: -1, 0x01, -1, 0x02,
265: -1, 0x03, -1, 0x04};
266:
267: bus_space_tag_t iot = sc->sc_iot;
268: bus_space_handle_t ioh;
269:
270: sbversion(sc);
271:
272: DPRINTF(("jazz16 probe\n"));
273:
274: if (bus_space_map(iot, JAZZ16_CONFIG_PORT, 1, 0, &ioh)) {
275: DPRINTF(("bus map failed\n"));
276: return;
277: }
278:
279: if (jazz16_drq_conf[sc->sc_drq8] == (u_char)-1 ||
280: jazz16_irq_conf[sc->sc_irq] == (u_char)-1) {
281: DPRINTF(("drq/irq check failed\n"));
282: goto done; /* give up, we can't do it. */
283: }
284:
285: bus_space_write_1(iot, ioh, 0, JAZZ16_WAKEUP);
286: delay(10000); /* delay 10 ms */
287: bus_space_write_1(iot, ioh, 0, JAZZ16_SETBASE);
288: bus_space_write_1(iot, ioh, 0, sc->sc_iobase & 0x70);
289:
290: if (sbdsp_reset(sc) < 0) {
291: DPRINTF(("sbdsp_reset check failed\n"));
292: goto done; /* XXX? what else could we do? */
293: }
294:
295: if (sbdsp_wdsp(sc, JAZZ16_READ_VER)) {
296: DPRINTF(("read16 setup failed\n"));
297: goto done;
298: }
299:
300: if (sbdsp_rdsp(sc) != JAZZ16_VER_JAZZ) {
301: DPRINTF(("read16 failed\n"));
302: goto done;
303: }
304:
305: /* XXX set both 8 & 16-bit drq to same channel, it works fine. */
306: sc->sc_drq16 = sc->sc_drq8;
307: if (sbdsp_wdsp(sc, JAZZ16_SET_DMAINTR) ||
308: sbdsp_wdsp(sc, (jazz16_drq_conf[sc->sc_drq16] << 4) |
309: jazz16_drq_conf[sc->sc_drq8]) ||
310: sbdsp_wdsp(sc, jazz16_irq_conf[sc->sc_irq])) {
311: DPRINTF(("sbdsp: can't write jazz16 probe stuff\n"));
312: } else {
313: DPRINTF(("jazz16 detected!\n"));
314: sc->sc_model = SB_JAZZ;
315: sc->sc_mixer_model = SBM_CT1345; /* XXX really? */
316: }
317:
318: done:
319: bus_space_unmap(iot, ioh, 1);
320: }
321:
322: /*
323: * Attach hardware to driver, attach hardware driver to audio
324: * pseudo-device driver .
325: */
326: void
327: sbdsp_attach(sc)
328: struct sbdsp_softc *sc;
329: {
330: struct audio_params pparams, rparams;
331: int i;
332: u_int v;
333:
334: /*
335: * Create our DMA maps.
336: */
337: if (sc->sc_drq8 != -1) {
338: if (isa_dmamap_create(sc->sc_isa, sc->sc_drq8,
339: MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
340: printf("%s: can't create map for drq %d\n",
341: sc->sc_dev.dv_xname, sc->sc_drq8);
342: return;
343: }
344: }
345: if (sc->sc_drq16 != -1 && sc->sc_drq16 != sc->sc_drq8) {
346: if (isa_dmamap_create(sc->sc_isa, sc->sc_drq16,
347: MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
348: printf("%s: can't create map for drq %d\n",
349: sc->sc_dev.dv_xname, sc->sc_drq16);
350: return;
351: }
352: }
353:
354: pparams = audio_default;
355: rparams = audio_default;
356: sbdsp_set_params(sc, AUMODE_RECORD|AUMODE_PLAY, 0, &pparams, &rparams);
357:
358: sbdsp_set_in_ports(sc, 1 << SB_MIC_VOL);
359:
360: if (sc->sc_mixer_model != SBM_NONE) {
361: /* Reset the mixer.*/
362: sbdsp_mix_write(sc, SBP_MIX_RESET, SBP_MIX_RESET);
363: /* And set our own default values */
364: for (i = 0; i < SB_NDEVS; i++) {
365: switch(i) {
366: case SB_MIC_VOL:
367: case SB_LINE_IN_VOL:
368: v = 0;
369: break;
370: case SB_BASS:
371: case SB_TREBLE:
372: v = SB_ADJUST_GAIN(sc, AUDIO_MAX_GAIN/2);
373: break;
374: case SB_CD_IN_MUTE:
375: case SB_MIC_IN_MUTE:
376: case SB_LINE_IN_MUTE:
377: case SB_MIDI_IN_MUTE:
378: case SB_CD_SWAP:
379: case SB_MIC_SWAP:
380: case SB_LINE_SWAP:
381: case SB_MIDI_SWAP:
382: case SB_CD_OUT_MUTE:
383: case SB_MIC_OUT_MUTE:
384: case SB_LINE_OUT_MUTE:
385: v = 0;
386: break;
387: default:
388: v = SB_ADJUST_GAIN(sc, AUDIO_MAX_GAIN / 2);
389: break;
390: }
391: sc->gain[i][SB_LEFT] = sc->gain[i][SB_RIGHT] = v;
392: sbdsp_set_mixer_gain(sc, i);
393: }
394: sc->in_filter = 0; /* no filters turned on, please */
395: }
396:
397: printf(": dsp v%d.%02d%s\n",
398: SBVER_MAJOR(sc->sc_version), SBVER_MINOR(sc->sc_version),
399: sc->sc_model == SB_JAZZ ? ": <Jazz16>" : "");
400:
401: timeout_set(&sc->sc_tmo, sbdsp_to, sbdsp_to);
402: sc->sc_fullduplex = ISSB16CLASS(sc) &&
403: sc->sc_drq8 != -1 && sc->sc_drq16 != -1 &&
404: sc->sc_drq8 != sc->sc_drq16;
405: }
406:
407: void
408: sbdsp_mix_write(sc, mixerport, val)
409: struct sbdsp_softc *sc;
410: int mixerport;
411: int val;
412: {
413: bus_space_tag_t iot = sc->sc_iot;
414: bus_space_handle_t ioh = sc->sc_ioh;
415: int s;
416:
417: s = splaudio();
418: bus_space_write_1(iot, ioh, SBP_MIXER_ADDR, mixerport);
419: delay(20);
420: bus_space_write_1(iot, ioh, SBP_MIXER_DATA, val);
421: delay(30);
422: splx(s);
423: }
424:
425: int
426: sbdsp_mix_read(sc, mixerport)
427: struct sbdsp_softc *sc;
428: int mixerport;
429: {
430: bus_space_tag_t iot = sc->sc_iot;
431: bus_space_handle_t ioh = sc->sc_ioh;
432: int val;
433: int s;
434:
435: s = splaudio();
436: bus_space_write_1(iot, ioh, SBP_MIXER_ADDR, mixerport);
437: delay(20);
438: val = bus_space_read_1(iot, ioh, SBP_MIXER_DATA);
439: delay(30);
440: splx(s);
441: return val;
442: }
443:
444: /*
445: * Various routines to interface to higher level audio driver
446: */
447:
448: int
449: sbdsp_query_encoding(addr, fp)
450: void *addr;
451: struct audio_encoding *fp;
452: {
453: struct sbdsp_softc *sc = addr;
454: int emul;
455:
456: emul = ISSB16CLASS(sc) ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
457:
458: switch (fp->index) {
459: case 0:
460: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
461: fp->encoding = AUDIO_ENCODING_ULINEAR;
462: fp->precision = 8;
463: fp->flags = 0;
464: return 0;
465: case 1:
466: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
467: fp->encoding = AUDIO_ENCODING_ULAW;
468: fp->precision = 8;
469: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
470: return 0;
471: case 2:
472: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
473: fp->encoding = AUDIO_ENCODING_ALAW;
474: fp->precision = 8;
475: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
476: return 0;
477: case 3:
478: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
479: fp->encoding = AUDIO_ENCODING_SLINEAR;
480: fp->precision = 8;
481: fp->flags = emul;
482: return 0;
483: }
484: if (!ISSB16CLASS(sc) && sc->sc_model != SB_JAZZ)
485: return EINVAL;
486:
487: switch(fp->index) {
488: case 4:
489: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
490: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
491: fp->precision = 16;
492: fp->flags = 0;
493: return 0;
494: case 5:
495: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
496: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
497: fp->precision = 16;
498: fp->flags = emul;
499: return 0;
500: case 6:
501: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
502: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
503: fp->precision = 16;
504: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
505: return 0;
506: case 7:
507: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
508: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
509: fp->precision = 16;
510: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
511: return 0;
512: default:
513: return EINVAL;
514: }
515: return 0;
516: }
517:
518: int
519: sbdsp_set_params(addr, setmode, usemode, play, rec)
520: void *addr;
521: int setmode, usemode;
522: struct audio_params *play, *rec;
523: {
524: struct sbdsp_softc *sc = addr;
525: struct sbmode *m;
526: u_int rate, tc, bmode;
527: void (*swcode)(void *, u_char *buf, int cnt);
528: int factor;
529: int model;
530: int chan;
531: struct audio_params *p;
532: int mode;
533:
534: if (sc->sc_open == SB_OPEN_MIDI)
535: return EBUSY;
536:
537: model = sc->sc_model;
538: if (model > SB_16)
539: model = SB_16; /* later models work like SB16 */
540:
541: /*
542: * Prior to the SB16, we have only one clock, so make the sample
543: * rates match.
544: */
545: if (!ISSB16CLASS(sc) &&
546: play->sample_rate != rec->sample_rate &&
547: usemode == (AUMODE_PLAY | AUMODE_RECORD)) {
548: if (setmode == AUMODE_PLAY) {
549: rec->sample_rate = play->sample_rate;
550: setmode |= AUMODE_RECORD;
551: } else if (setmode == AUMODE_RECORD) {
552: play->sample_rate = rec->sample_rate;
553: setmode |= AUMODE_PLAY;
554: } else
555: return (EINVAL);
556: }
557:
558: /* Set first record info, then play info */
559: for (mode = AUMODE_RECORD; mode != -1;
560: mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
561: if ((setmode & mode) == 0)
562: continue;
563:
564: p = mode == AUMODE_PLAY ? play : rec;
565: /* Locate proper commands */
566: for(m = mode == AUMODE_PLAY ? sbpmodes : sbrmodes;
567: m->model != -1; m++) {
568: if (model == m->model &&
569: p->channels == m->channels &&
570: p->precision == m->precision &&
571: p->sample_rate >= m->lowrate &&
572: p->sample_rate <= m->highrate)
573: break;
574: }
575: if (m->model == -1)
576: return EINVAL;
577: rate = p->sample_rate;
578: swcode = 0;
579: factor = 1;
580: tc = 1;
581: bmode = -1;
582: if (model == SB_16) {
583: switch (p->encoding) {
584: case AUDIO_ENCODING_SLINEAR_BE:
585: if (p->precision == 16)
586: swcode = swap_bytes;
587: /* fall into */
588: case AUDIO_ENCODING_SLINEAR_LE:
589: bmode = SB_BMODE_SIGNED;
590: break;
591: case AUDIO_ENCODING_ULINEAR_BE:
592: if (p->precision == 16)
593: swcode = swap_bytes;
594: /* fall into */
595: case AUDIO_ENCODING_ULINEAR_LE:
596: bmode = SB_BMODE_UNSIGNED;
597: break;
598: case AUDIO_ENCODING_ULAW:
599: if (mode == AUMODE_PLAY) {
600: swcode = mulaw_to_ulinear16;
601: factor = 2;
602: m = &sbpmodes[PLAY16];
603: } else
604: swcode = ulinear8_to_mulaw;
605: bmode = SB_BMODE_UNSIGNED;
606: break;
607: case AUDIO_ENCODING_ALAW:
608: if (mode == AUMODE_PLAY) {
609: swcode = alaw_to_ulinear16;
610: factor = 2;
611: m = &sbpmodes[PLAY16];
612: } else
613: swcode = ulinear8_to_alaw;
614: bmode = SB_BMODE_UNSIGNED;
615: break;
616: default:
617: return EINVAL;
618: }
619: if (p->channels == 2)
620: bmode |= SB_BMODE_STEREO;
621: } else if (m->model == SB_JAZZ && m->precision == 16) {
622: switch (p->encoding) {
623: case AUDIO_ENCODING_SLINEAR_LE:
624: break;
625: case AUDIO_ENCODING_ULINEAR_LE:
626: swcode = change_sign16;
627: break;
628: case AUDIO_ENCODING_SLINEAR_BE:
629: swcode = swap_bytes;
630: break;
631: case AUDIO_ENCODING_ULINEAR_BE:
632: swcode = mode == AUMODE_PLAY ?
633: swap_bytes_change_sign16 : change_sign16_swap_bytes;
634: break;
635: case AUDIO_ENCODING_ULAW:
636: swcode = mode == AUMODE_PLAY ?
637: mulaw_to_ulinear8 : ulinear8_to_mulaw;
638: break;
639: case AUDIO_ENCODING_ALAW:
640: swcode = mode == AUMODE_PLAY ?
641: alaw_to_ulinear8 : ulinear8_to_alaw;
642: break;
643: default:
644: return EINVAL;
645: }
646: tc = SB_RATE_TO_TC(p->sample_rate * p->channels);
647: p->sample_rate = SB_TC_TO_RATE(tc) / p->channels;
648: } else {
649: switch (p->encoding) {
650: case AUDIO_ENCODING_SLINEAR_BE:
651: case AUDIO_ENCODING_SLINEAR_LE:
652: swcode = change_sign8;
653: break;
654: case AUDIO_ENCODING_ULINEAR_BE:
655: case AUDIO_ENCODING_ULINEAR_LE:
656: break;
657: case AUDIO_ENCODING_ULAW:
658: swcode = mode == AUMODE_PLAY ?
659: mulaw_to_ulinear8 : ulinear8_to_mulaw;
660: break;
661: case AUDIO_ENCODING_ALAW:
662: swcode = mode == AUMODE_PLAY ?
663: alaw_to_ulinear8 : ulinear8_to_alaw;
664: break;
665: default:
666: return EINVAL;
667: }
668: tc = SB_RATE_TO_TC(p->sample_rate * p->channels);
669: p->sample_rate = SB_TC_TO_RATE(tc) / p->channels;
670: }
671:
672: chan = m->precision == 16 ? sc->sc_drq16 : sc->sc_drq8;
673: if (mode == AUMODE_PLAY) {
674: sc->sc_o.rate = rate;
675: sc->sc_o.tc = tc;
676: sc->sc_o.modep = m;
677: sc->sc_o.bmode = bmode;
678: sc->sc_o.dmachan = chan;
679: } else {
680: sc->sc_i.rate = rate;
681: sc->sc_i.tc = tc;
682: sc->sc_i.modep = m;
683: sc->sc_i.bmode = bmode;
684: sc->sc_i.dmachan = chan;
685: }
686:
687: p->sw_code = swcode;
688: p->factor = factor;
689: DPRINTF(("sbdsp_set_params: model=%d, mode=%d, rate=%ld, prec=%d, chan=%d, enc=%d -> tc=%02x, cmd=%02x, bmode=%02x, cmdchan=%02x, swcode=%p, factor=%d\n",
690: sc->sc_model, mode, p->sample_rate, p->precision, p->channels,
691: p->encoding, tc, m->cmd, bmode, m->cmdchan, swcode, factor));
692:
693: }
694:
695: /*
696: * XXX
697: * Should wait for chip to be idle.
698: */
699: sc->sc_i.run = SB_NOTRUNNING;
700: sc->sc_o.run = SB_NOTRUNNING;
701:
702: if (sc->sc_fullduplex &&
703: usemode == (AUMODE_PLAY | AUMODE_RECORD) &&
704: sc->sc_i.dmachan == sc->sc_o.dmachan) {
705: DPRINTF(("sbdsp_set_params: fd=%d, usemode=%d, idma=%d, odma=%d\n", sc->sc_fullduplex, usemode, sc->sc_i.dmachan, sc->sc_o.dmachan));
706: if (sc->sc_o.dmachan == sc->sc_drq8) {
707: /* Use 16 bit DMA for playing by expanding the samples. */
708: play->sw_code = linear8_to_linear16;
709: play->factor = 2;
710: sc->sc_o.modep = &sbpmodes[PLAY16];
711: sc->sc_o.dmachan = sc->sc_drq16;
712: } else {
713: return EINVAL;
714: }
715: }
716: DPRINTF(("sbdsp_set_params ichan=%d, ochan=%d\n",
717: sc->sc_i.dmachan, sc->sc_o.dmachan));
718:
719: return 0;
720: }
721:
722: void
723: sbdsp_set_ifilter(addr, which)
724: void *addr;
725: int which;
726: {
727: struct sbdsp_softc *sc = addr;
728: int mixval;
729:
730: mixval = sbdsp_mix_read(sc, SBP_INFILTER) & ~SBP_IFILTER_MASK;
731: switch (which) {
732: case 0:
733: mixval |= SBP_FILTER_OFF;
734: break;
735: case SB_TREBLE:
736: mixval |= SBP_FILTER_ON | SBP_IFILTER_HIGH;
737: break;
738: case SB_BASS:
739: mixval |= SBP_FILTER_ON | SBP_IFILTER_LOW;
740: break;
741: default:
742: return;
743: }
744: sc->in_filter = mixval & SBP_IFILTER_MASK;
745: sbdsp_mix_write(sc, SBP_INFILTER, mixval);
746: }
747:
748: int
749: sbdsp_get_ifilter(addr)
750: void *addr;
751: {
752: struct sbdsp_softc *sc = addr;
753:
754: sc->in_filter =
755: sbdsp_mix_read(sc, SBP_INFILTER) & SBP_IFILTER_MASK;
756: switch (sc->in_filter) {
757: case SBP_FILTER_ON|SBP_IFILTER_HIGH:
758: return SB_TREBLE;
759: case SBP_FILTER_ON|SBP_IFILTER_LOW:
760: return SB_BASS;
761: default:
762: return 0;
763: }
764: }
765:
766: int
767: sbdsp_set_in_ports(sc, mask)
768: struct sbdsp_softc *sc;
769: int mask;
770: {
771: int bitsl, bitsr;
772: int sbport;
773:
774: if (sc->sc_open == SB_OPEN_MIDI)
775: return EBUSY;
776:
777: DPRINTF(("sbdsp_set_in_ports: model=%d, mask=%x\n",
778: sc->sc_mixer_model, mask));
779:
780: switch(sc->sc_mixer_model) {
781: case SBM_NONE:
782: return EINVAL;
783: case SBM_CT1335:
784: if (mask != (1 << SB_MIC_VOL))
785: return EINVAL;
786: break;
787: case SBM_CT1345:
788: switch (mask) {
789: case 1 << SB_MIC_VOL:
790: sbport = SBP_FROM_MIC;
791: break;
792: case 1 << SB_LINE_IN_VOL:
793: sbport = SBP_FROM_LINE;
794: break;
795: case 1 << SB_CD_VOL:
796: sbport = SBP_FROM_CD;
797: break;
798: default:
799: return (EINVAL);
800: }
801: sbdsp_mix_write(sc, SBP_RECORD_SOURCE, sbport | sc->in_filter);
802: break;
803: case SBM_CT1XX5:
804: case SBM_CT1745:
805: if (mask & ~((1<<SB_MIDI_VOL) | (1<<SB_LINE_IN_VOL) |
806: (1<<SB_CD_VOL) | (1<<SB_MIC_VOL)))
807: return EINVAL;
808: bitsr = 0;
809: if (mask & (1<<SB_MIDI_VOL)) bitsr |= SBP_MIDI_SRC_R;
810: if (mask & (1<<SB_LINE_IN_VOL)) bitsr |= SBP_LINE_SRC_R;
811: if (mask & (1<<SB_CD_VOL)) bitsr |= SBP_CD_SRC_R;
812: bitsl = SB_SRC_R_TO_L(bitsr);
813: if (mask & (1<<SB_MIC_VOL)) {
814: bitsl |= SBP_MIC_SRC;
815: bitsr |= SBP_MIC_SRC;
816: }
817: sbdsp_mix_write(sc, SBP_RECORD_SOURCE_L, bitsl);
818: sbdsp_mix_write(sc, SBP_RECORD_SOURCE_R, bitsr);
819: break;
820: }
821: sc->in_mask = mask;
822:
823: return 0;
824: }
825:
826: int
827: sbdsp_speaker_ctl(addr, newstate)
828: void *addr;
829: int newstate;
830: {
831: struct sbdsp_softc *sc = addr;
832:
833: if (sc->sc_open == SB_OPEN_MIDI)
834: return EBUSY;
835:
836: if ((newstate == SPKR_ON) &&
837: (sc->spkr_state == SPKR_OFF)) {
838: sbdsp_spkron(sc);
839: sc->spkr_state = SPKR_ON;
840: }
841: if ((newstate == SPKR_OFF) &&
842: (sc->spkr_state == SPKR_ON)) {
843: sbdsp_spkroff(sc);
844: sc->spkr_state = SPKR_OFF;
845: }
846: return 0;
847: }
848:
849: int
850: sbdsp_round_blocksize(addr, blk)
851: void *addr;
852: int blk;
853: {
854: return (blk + 3) & -4; /* round to biggest sample size */
855: }
856:
857: int
858: sbdsp_open(addr, flags)
859: void *addr;
860: int flags;
861: {
862: struct sbdsp_softc *sc = addr;
863:
864: DPRINTF(("sbdsp_open: sc=%p\n", sc));
865:
866: if (sc->sc_open != SB_CLOSED)
867: return EBUSY;
868: if (sbdsp_reset(sc) != 0)
869: return EIO;
870:
871: sc->sc_open = SB_OPEN_AUDIO;
872: sc->sc_openflags = flags;
873: sc->sc_intrm = 0;
874: if (ISSBPRO(sc) &&
875: sbdsp_wdsp(sc, SB_DSP_RECORD_MONO) < 0) {
876: DPRINTF(("sbdsp_open: can't set mono mode\n"));
877: /* we'll readjust when it's time for DMA. */
878: }
879:
880: /*
881: * Leave most things as they were; users must change things if
882: * the previous process didn't leave it they way they wanted.
883: * Looked at another way, it's easy to set up a configuration
884: * in one program and leave it for another to inherit.
885: */
886: DPRINTF(("sbdsp_open: opened\n"));
887:
888: return 0;
889: }
890:
891: void
892: sbdsp_close(addr)
893: void *addr;
894: {
895: struct sbdsp_softc *sc = addr;
896:
897: DPRINTF(("sbdsp_close: sc=%p\n", sc));
898:
899: sc->sc_open = SB_CLOSED;
900: sbdsp_spkroff(sc);
901: sc->spkr_state = SPKR_OFF;
902: sc->sc_intr8 = 0;
903: sc->sc_intr16 = 0;
904: sc->sc_intrm = 0;
905: sbdsp_haltdma(sc);
906:
907: DPRINTF(("sbdsp_close: closed\n"));
908: }
909:
910: /*
911: * Lower-level routines
912: */
913:
914: /*
915: * Reset the card.
916: * Return non-zero if the card isn't detected.
917: */
918: int
919: sbdsp_reset(sc)
920: struct sbdsp_softc *sc;
921: {
922: bus_space_tag_t iot = sc->sc_iot;
923: bus_space_handle_t ioh = sc->sc_ioh;
924:
925: sc->sc_intr8 = 0;
926: sc->sc_intr16 = 0;
927: if (sc->sc_i.run != SB_NOTRUNNING) {
928: isa_dmaabort(sc->sc_isa, sc->sc_i.dmachan);
929: sc->sc_i.run = SB_NOTRUNNING;
930: }
931: if (sc->sc_o.run != SB_NOTRUNNING) {
932: isa_dmaabort(sc->sc_isa, sc->sc_o.dmachan);
933: sc->sc_o.run = SB_NOTRUNNING;
934: }
935:
936: /*
937: * See SBK, section 11.3.
938: * We pulse a reset signal into the card.
939: * Gee, what a brilliant hardware design.
940: */
941: bus_space_write_1(iot, ioh, SBP_DSP_RESET, 1);
942: delay(10);
943: bus_space_write_1(iot, ioh, SBP_DSP_RESET, 0);
944: delay(30);
945: if (sbdsp_rdsp(sc) != SB_MAGIC)
946: return -1;
947:
948: return 0;
949: }
950:
951: /*
952: * Write a byte to the dsp.
953: * We are at the mercy of the card as we use a
954: * polling loop and wait until it can take the byte.
955: */
956: int
957: sbdsp_wdsp(sc, v)
958: struct sbdsp_softc *sc;
959: int v;
960: {
961: bus_space_tag_t iot = sc->sc_iot;
962: bus_space_handle_t ioh = sc->sc_ioh;
963: int i;
964: u_char x;
965:
966: for (i = SBDSP_NPOLL; --i >= 0; ) {
967: x = bus_space_read_1(iot, ioh, SBP_DSP_WSTAT);
968: delay(10);
969: if ((x & SB_DSP_BUSY) == 0) {
970: bus_space_write_1(iot, ioh, SBP_DSP_WRITE, v);
971: delay(10);
972: return 0;
973: }
974: }
975: ++sberr.wdsp;
976: return -1;
977: }
978:
979: /*
980: * Read a byte from the DSP, using polling.
981: */
982: int
983: sbdsp_rdsp(sc)
984: struct sbdsp_softc *sc;
985: {
986: bus_space_tag_t iot = sc->sc_iot;
987: bus_space_handle_t ioh = sc->sc_ioh;
988: int i;
989: u_char x;
990:
991: for (i = SBDSP_NPOLL; --i >= 0; ) {
992: x = bus_space_read_1(iot, ioh, SBP_DSP_RSTAT);
993: delay(10);
994: if (x & SB_DSP_READY) {
995: x = bus_space_read_1(iot, ioh, SBP_DSP_READ);
996: delay(10);
997: return x;
998: }
999: }
1000: ++sberr.rdsp;
1001: return -1;
1002: }
1003:
1004: /*
1005: * Doing certain things (like toggling the speaker) make
1006: * the SB hardware go away for a while, so pause a little.
1007: */
1008: void
1009: sbdsp_to(arg)
1010: void *arg;
1011: {
1012: wakeup(arg);
1013: }
1014:
1015: void
1016: sbdsp_pause(sc)
1017: struct sbdsp_softc *sc;
1018: {
1019: extern int hz;
1020:
1021: timeout_add(&sc->sc_tmo, hz/8);
1022: (void)tsleep(sbdsp_to, PWAIT, "sbpause", 0);
1023: }
1024:
1025: /*
1026: * Turn on the speaker. The SBK documention says this operation
1027: * can take up to 1/10 of a second. Higher level layers should
1028: * probably let the task sleep for this amount of time after
1029: * calling here. Otherwise, things might not work (because
1030: * sbdsp_wdsp() and sbdsp_rdsp() will probably timeout.)
1031: *
1032: * These engineers had their heads up their ass when
1033: * they designed this card.
1034: */
1035: void
1036: sbdsp_spkron(sc)
1037: struct sbdsp_softc *sc;
1038: {
1039: (void)sbdsp_wdsp(sc, SB_DSP_SPKR_ON);
1040: sbdsp_pause(sc);
1041: }
1042:
1043: /*
1044: * Turn off the speaker; see comment above.
1045: */
1046: void
1047: sbdsp_spkroff(sc)
1048: struct sbdsp_softc *sc;
1049: {
1050: (void)sbdsp_wdsp(sc, SB_DSP_SPKR_OFF);
1051: sbdsp_pause(sc);
1052: }
1053:
1054: /*
1055: * Read the version number out of the card.
1056: * Store version information in the softc.
1057: */
1058: void
1059: sbversion(sc)
1060: struct sbdsp_softc *sc;
1061: {
1062: int v;
1063:
1064: sc->sc_model = SB_UNK;
1065: sc->sc_version = 0;
1066: if (sbdsp_wdsp(sc, SB_DSP_VERSION) < 0)
1067: return;
1068: v = sbdsp_rdsp(sc) << 8;
1069: v |= sbdsp_rdsp(sc);
1070: if (v < 0)
1071: return;
1072: sc->sc_version = v;
1073: switch(SBVER_MAJOR(v)) {
1074: case 1:
1075: sc->sc_mixer_model = SBM_NONE;
1076: sc->sc_model = SB_1;
1077: break;
1078: case 2:
1079: /* Some SB2 have a mixer, some don't. */
1080: sbdsp_mix_write(sc, SBP_1335_MASTER_VOL, 0x04);
1081: sbdsp_mix_write(sc, SBP_1335_MIDI_VOL, 0x06);
1082: /* Check if we can read back the mixer values. */
1083: if ((sbdsp_mix_read(sc, SBP_1335_MASTER_VOL) & 0x0e) == 0x04 &&
1084: (sbdsp_mix_read(sc, SBP_1335_MIDI_VOL) & 0x0e) == 0x06)
1085: sc->sc_mixer_model = SBM_CT1335;
1086: else
1087: sc->sc_mixer_model = SBM_NONE;
1088: if (SBVER_MINOR(v) == 0)
1089: sc->sc_model = SB_20;
1090: else
1091: sc->sc_model = SB_2x;
1092: break;
1093: case 3:
1094: sc->sc_mixer_model = SBM_CT1345;
1095: sc->sc_model = SB_PRO;
1096: break;
1097: case 4:
1098: #if 0
1099: /* XXX This does not work */
1100: /* Most SB16 have a tone controls, but some don't. */
1101: sbdsp_mix_write(sc, SB16P_TREBLE_L, 0x80);
1102: /* Check if we can read back the mixer value. */
1103: if ((sbdsp_mix_read(sc, SB16P_TREBLE_L) & 0xf0) == 0x80)
1104: sc->sc_mixer_model = SBM_CT1745;
1105: else
1106: sc->sc_mixer_model = SBM_CT1XX5;
1107: #else
1108: sc->sc_mixer_model = SBM_CT1745;
1109: #endif
1110: #if 0
1111: /* XXX figure out a good way of determining the model */
1112: /* XXX what about SB_32 */
1113: if (SBVER_MINOR(v) == 16)
1114: sc->sc_model = SB_64;
1115: else
1116: #endif
1117: sc->sc_model = SB_16;
1118: break;
1119: }
1120: }
1121:
1122: /*
1123: * Halt a DMA in progress.
1124: */
1125: int
1126: sbdsp_haltdma(addr)
1127: void *addr;
1128: {
1129: struct sbdsp_softc *sc = addr;
1130:
1131: DPRINTF(("sbdsp_haltdma: sc=%p\n", sc));
1132:
1133: sbdsp_reset(sc);
1134: return 0;
1135: }
1136:
1137: int
1138: sbdsp_set_timeconst(sc, tc)
1139: struct sbdsp_softc *sc;
1140: int tc;
1141: {
1142: DPRINTF(("sbdsp_set_timeconst: sc=%p tc=%d\n", sc, tc));
1143:
1144: if (sbdsp_wdsp(sc, SB_DSP_TIMECONST) < 0 ||
1145: sbdsp_wdsp(sc, tc) < 0)
1146: return EIO;
1147:
1148: return 0;
1149: }
1150:
1151: int
1152: sbdsp16_set_rate(sc, cmd, rate)
1153: struct sbdsp_softc *sc;
1154: int cmd, rate;
1155: {
1156: DPRINTF(("sbdsp16_set_rate: sc=%p cmd=0x%02x rate=%d\n", sc, cmd, rate));
1157:
1158: if (sbdsp_wdsp(sc, cmd) < 0 ||
1159: sbdsp_wdsp(sc, rate >> 8) < 0 ||
1160: sbdsp_wdsp(sc, rate) < 0)
1161: return EIO;
1162: return 0;
1163: }
1164:
1165: int
1166: sbdsp_trigger_input(addr, start, end, blksize, intr, arg, param)
1167: void *addr;
1168: void *start, *end;
1169: int blksize;
1170: void (*intr)(void *);
1171: void *arg;
1172: struct audio_params *param;
1173: {
1174: struct sbdsp_softc *sc = addr;
1175: int stereo = param->channels == 2;
1176: int width = param->precision * param->factor;
1177: int filter;
1178:
1179: #ifdef DIAGNOSTIC
1180: if (stereo && (blksize & 1)) {
1181: DPRINTF(("stereo record odd bytes (%d)\n", blksize));
1182: return (EIO);
1183: }
1184: #endif
1185:
1186: sc->sc_intrr = intr;
1187: sc->sc_argr = arg;
1188:
1189: if (width == 8) {
1190: #ifdef DIAGNOSTIC
1191: if (sc->sc_i.dmachan != sc->sc_drq8) {
1192: printf("sbdsp_trigger_input: width=%d bad chan %d\n",
1193: width, sc->sc_i.dmachan);
1194: return (EIO);
1195: }
1196: #endif
1197: sc->sc_intr8 = sbdsp_block_input;
1198: sc->sc_arg8 = addr;
1199: } else {
1200: #ifdef DIAGNOSTIC
1201: if (sc->sc_i.dmachan != sc->sc_drq16) {
1202: printf("sbdsp_trigger_input: width=%d bad chan %d\n",
1203: width, sc->sc_i.dmachan);
1204: return (EIO);
1205: }
1206: #endif
1207: sc->sc_intr16 = sbdsp_block_input;
1208: sc->sc_arg16 = addr;
1209: }
1210:
1211: if ((sc->sc_model == SB_JAZZ) ? (sc->sc_i.dmachan > 3) : (width == 16))
1212: blksize >>= 1;
1213: --blksize;
1214: sc->sc_i.blksize = blksize;
1215:
1216: if (ISSBPRO(sc)) {
1217: if (sbdsp_wdsp(sc, sc->sc_i.modep->cmdchan) < 0)
1218: return (EIO);
1219: filter = stereo ? SBP_FILTER_OFF : sc->in_filter;
1220: sbdsp_mix_write(sc, SBP_INFILTER,
1221: (sbdsp_mix_read(sc, SBP_INFILTER) & ~SBP_IFILTER_MASK) |
1222: filter);
1223: }
1224:
1225: if (ISSB16CLASS(sc)) {
1226: if (sbdsp16_set_rate(sc, SB_DSP16_INPUTRATE, sc->sc_i.rate)) {
1227: DPRINTF(("sbdsp_trigger_input: rate=%d set failed\n",
1228: sc->sc_i.rate));
1229: return (EIO);
1230: }
1231: } else {
1232: if (sbdsp_set_timeconst(sc, sc->sc_i.tc)) {
1233: DPRINTF(("sbdsp_trigger_input: tc=%d set failed\n",
1234: sc->sc_i.rate));
1235: return (EIO);
1236: }
1237: }
1238:
1239: DPRINTF(("sbdsp: dma start loop input start=%p end=%p chan=%d\n",
1240: start, end, sc->sc_i.dmachan));
1241: isa_dmastart(sc->sc_isa, sc->sc_i.dmachan, start, (char *)end -
1242: (char *)start, NULL, DMAMODE_READ | DMAMODE_LOOP, BUS_DMA_NOWAIT);
1243:
1244: return sbdsp_block_input(addr);
1245: }
1246:
1247: int
1248: sbdsp_block_input(addr)
1249: void *addr;
1250: {
1251: struct sbdsp_softc *sc = addr;
1252: int cc = sc->sc_i.blksize;
1253:
1254: DPRINTFN(2, ("sbdsp_block_input: sc=%p cc=%d\n", addr, cc));
1255:
1256: if (sc->sc_i.run != SB_NOTRUNNING)
1257: sc->sc_intrr(sc->sc_argr);
1258:
1259: if (sc->sc_model == SB_1) {
1260: /* Non-looping mode, start DMA */
1261: if (sbdsp_wdsp(sc, sc->sc_i.modep->cmd) < 0 ||
1262: sbdsp_wdsp(sc, cc) < 0 ||
1263: sbdsp_wdsp(sc, cc >> 8) < 0) {
1264: DPRINTF(("sbdsp_block_input: SB1 DMA start failed\n"));
1265: return (EIO);
1266: }
1267: sc->sc_i.run = SB_RUNNING;
1268: } else if (sc->sc_i.run == SB_NOTRUNNING) {
1269: /* Initialize looping PCM */
1270: if (ISSB16CLASS(sc)) {
1271: DPRINTFN(3, ("sbdsp16 input command cmd=0x%02x bmode=0x%02x cc=%d\n",
1272: sc->sc_i.modep->cmd, sc->sc_i.bmode, cc));
1273: if (sbdsp_wdsp(sc, sc->sc_i.modep->cmd) < 0 ||
1274: sbdsp_wdsp(sc, sc->sc_i.bmode) < 0 ||
1275: sbdsp_wdsp(sc, cc) < 0 ||
1276: sbdsp_wdsp(sc, cc >> 8) < 0) {
1277: DPRINTF(("sbdsp_block_input: SB16 DMA start failed\n"));
1278: return (EIO);
1279: }
1280: } else {
1281: DPRINTF(("sbdsp_block_input: set blocksize=%d\n", cc));
1282: if (sbdsp_wdsp(sc, SB_DSP_BLOCKSIZE) < 0 ||
1283: sbdsp_wdsp(sc, cc) < 0 ||
1284: sbdsp_wdsp(sc, cc >> 8) < 0) {
1285: DPRINTF(("sbdsp_block_input: SB2 DMA blocksize failed\n"));
1286: return (EIO);
1287: }
1288: if (sbdsp_wdsp(sc, sc->sc_i.modep->cmd) < 0) {
1289: DPRINTF(("sbdsp_block_input: SB2 DMA start failed\n"));
1290: return (EIO);
1291: }
1292: }
1293: sc->sc_i.run = SB_LOOPING;
1294: }
1295:
1296: return (0);
1297: }
1298:
1299: int
1300: sbdsp_trigger_output(addr, start, end, blksize, intr, arg, param)
1301: void *addr;
1302: void *start, *end;
1303: int blksize;
1304: void (*intr)(void *);
1305: void *arg;
1306: struct audio_params *param;
1307: {
1308: struct sbdsp_softc *sc = addr;
1309: int stereo = param->channels == 2;
1310: int width = param->precision * param->factor;
1311: int cmd;
1312:
1313: #ifdef DIAGNOSTIC
1314: if (stereo && (blksize & 1)) {
1315: DPRINTF(("stereo playback odd bytes (%d)\n", blksize));
1316: return (EIO);
1317: }
1318: #endif
1319:
1320: sc->sc_intrp = intr;
1321: sc->sc_argp = arg;
1322:
1323: if (width == 8) {
1324: #ifdef DIAGNOSTIC
1325: if (sc->sc_o.dmachan != sc->sc_drq8) {
1326: printf("sbdsp_trigger_output: width=%d bad chan %d\n",
1327: width, sc->sc_o.dmachan);
1328: return (EIO);
1329: }
1330: #endif
1331: sc->sc_intr8 = sbdsp_block_output;
1332: sc->sc_arg8 = addr;
1333: } else {
1334: #ifdef DIAGNOSTIC
1335: if (sc->sc_o.dmachan != sc->sc_drq16) {
1336: printf("sbdsp_trigger_output: width=%d bad chan %d\n",
1337: width, sc->sc_o.dmachan);
1338: return (EIO);
1339: }
1340: #endif
1341: sc->sc_intr16 = sbdsp_block_output;
1342: sc->sc_arg16 = addr;
1343: }
1344:
1345: if ((sc->sc_model == SB_JAZZ) ? (sc->sc_o.dmachan > 3) : (width == 16))
1346: blksize >>= 1;
1347: --blksize;
1348: sc->sc_o.blksize = blksize;
1349:
1350: if (ISSBPRO(sc)) {
1351: /* make sure we re-set stereo mixer bit when we start output. */
1352: sbdsp_mix_write(sc, SBP_STEREO,
1353: (sbdsp_mix_read(sc, SBP_STEREO) & ~SBP_PLAYMODE_MASK) |
1354: (stereo ? SBP_PLAYMODE_STEREO : SBP_PLAYMODE_MONO));
1355: cmd = sc->sc_o.modep->cmdchan;
1356: if (cmd && sbdsp_wdsp(sc, cmd) < 0)
1357: return (EIO);
1358: }
1359:
1360: if (ISSB16CLASS(sc)) {
1361: if (sbdsp16_set_rate(sc, SB_DSP16_OUTPUTRATE, sc->sc_o.rate)) {
1362: DPRINTF(("sbdsp_trigger_output: rate=%d set failed\n",
1363: sc->sc_o.rate));
1364: return (EIO);
1365: }
1366: } else {
1367: if (sbdsp_set_timeconst(sc, sc->sc_o.tc)) {
1368: DPRINTF(("sbdsp_trigger_output: tc=%d set failed\n",
1369: sc->sc_o.rate));
1370: return (EIO);
1371: }
1372: }
1373:
1374: DPRINTF(("sbdsp: dma start loop output start=%p end=%p chan=%d\n",
1375: start, end, sc->sc_o.dmachan));
1376: isa_dmastart(sc->sc_isa, sc->sc_o.dmachan, start, (char *)end -
1377: (char *)start, NULL, DMAMODE_WRITE | DMAMODE_LOOP, BUS_DMA_NOWAIT);
1378:
1379: return sbdsp_block_output(addr);
1380: }
1381:
1382: int
1383: sbdsp_block_output(addr)
1384: void *addr;
1385: {
1386: struct sbdsp_softc *sc = addr;
1387: int cc = sc->sc_o.blksize;
1388:
1389: DPRINTFN(2, ("sbdsp_block_output: sc=%p cc=%d\n", addr, cc));
1390:
1391: if (sc->sc_o.run != SB_NOTRUNNING)
1392: sc->sc_intrp(sc->sc_argp);
1393:
1394: if (sc->sc_model == SB_1) {
1395: /* Non-looping mode, initialized. Start DMA and PCM */
1396: if (sbdsp_wdsp(sc, sc->sc_o.modep->cmd) < 0 ||
1397: sbdsp_wdsp(sc, cc) < 0 ||
1398: sbdsp_wdsp(sc, cc >> 8) < 0) {
1399: DPRINTF(("sbdsp_block_output: SB1 DMA start failed\n"));
1400: return (EIO);
1401: }
1402: sc->sc_o.run = SB_RUNNING;
1403: } else if (sc->sc_o.run == SB_NOTRUNNING) {
1404: /* Initialize looping PCM */
1405: if (ISSB16CLASS(sc)) {
1406: DPRINTF(("sbdsp_block_output: SB16 cmd=0x%02x bmode=0x%02x cc=%d\n",
1407: sc->sc_o.modep->cmd,sc->sc_o.bmode, cc));
1408: if (sbdsp_wdsp(sc, sc->sc_o.modep->cmd) < 0 ||
1409: sbdsp_wdsp(sc, sc->sc_o.bmode) < 0 ||
1410: sbdsp_wdsp(sc, cc) < 0 ||
1411: sbdsp_wdsp(sc, cc >> 8) < 0) {
1412: DPRINTF(("sbdsp_block_output: SB16 DMA start failed\n"));
1413: return (EIO);
1414: }
1415: } else {
1416: DPRINTF(("sbdsp_block_output: set blocksize=%d\n", cc));
1417: if (sbdsp_wdsp(sc, SB_DSP_BLOCKSIZE) < 0 ||
1418: sbdsp_wdsp(sc, cc) < 0 ||
1419: sbdsp_wdsp(sc, cc >> 8) < 0) {
1420: DPRINTF(("sbdsp_block_output: SB2 DMA blocksize failed\n"));
1421: return (EIO);
1422: }
1423: if (sbdsp_wdsp(sc, sc->sc_o.modep->cmd) < 0) {
1424: DPRINTF(("sbdsp_block_output: SB2 DMA start failed\n"));
1425: return (EIO);
1426: }
1427: }
1428: sc->sc_o.run = SB_LOOPING;
1429: }
1430:
1431: return (0);
1432: }
1433:
1434: /*
1435: * Only the DSP unit on the sound blaster generates interrupts.
1436: * There are three cases of interrupt: reception of a midi byte
1437: * (when mode is enabled), completion of dma transmission, or
1438: * completion of a dma reception.
1439: *
1440: * If there is interrupt sharing or a spurious interrupt occurs
1441: * there is no way to distinguish this on an SB2. So if you have
1442: * an SB2 and experience problems, buy an SB16 (it's only $40).
1443: */
1444: int
1445: sbdsp_intr(arg)
1446: void *arg;
1447: {
1448: struct sbdsp_softc *sc = arg;
1449: u_char irq;
1450:
1451: DPRINTFN(2, ("sbdsp_intr: intr8=%p, intr16=%p\n",
1452: sc->sc_intr8, sc->sc_intr16));
1453: if (ISSB16CLASS(sc)) {
1454: irq = sbdsp_mix_read(sc, SBP_IRQ_STATUS);
1455: if ((irq & (SBP_IRQ_DMA8 | SBP_IRQ_DMA16 | SBP_IRQ_MPU401)) == 0) {
1456: DPRINTF(("sbdsp_intr: Spurious interrupt 0x%x\n", irq));
1457: return 0;
1458: }
1459: } else {
1460: /* XXXX CHECK FOR INTERRUPT */
1461: irq = SBP_IRQ_DMA8;
1462: }
1463:
1464: sc->sc_interrupts++;
1465: delay(10); /* XXX why? */
1466:
1467: /* clear interrupt */
1468: if (irq & SBP_IRQ_DMA8) {
1469: bus_space_read_1(sc->sc_iot, sc->sc_ioh, SBP_DSP_IRQACK8);
1470: if (sc->sc_intr8)
1471: sc->sc_intr8(sc->sc_arg8);
1472: }
1473: if (irq & SBP_IRQ_DMA16) {
1474: bus_space_read_1(sc->sc_iot, sc->sc_ioh, SBP_DSP_IRQACK16);
1475: if (sc->sc_intr16)
1476: sc->sc_intr16(sc->sc_arg16);
1477: }
1478: #if NMIDI > 0
1479: if ((irq & SBP_IRQ_MPU401) && sc->sc_hasmpu) {
1480: mpu_intr(&sc->sc_mpu_sc);
1481: }
1482: #endif
1483: return 1;
1484: }
1485:
1486: /* Like val & mask, but make sure the result is correctly rounded. */
1487: #define MAXVAL 256
1488: static int
1489: sbdsp_adjust(val, mask)
1490: int val, mask;
1491: {
1492: val += (MAXVAL - mask) >> 1;
1493: if (val >= MAXVAL)
1494: val = MAXVAL-1;
1495: return val & mask;
1496: }
1497:
1498: void
1499: sbdsp_set_mixer_gain(sc, port)
1500: struct sbdsp_softc *sc;
1501: int port;
1502: {
1503: int src, gain;
1504:
1505: switch(sc->sc_mixer_model) {
1506: case SBM_NONE:
1507: return;
1508: case SBM_CT1335:
1509: gain = SB_1335_GAIN(sc->gain[port][SB_LEFT]);
1510: switch(port) {
1511: case SB_MASTER_VOL:
1512: src = SBP_1335_MASTER_VOL;
1513: break;
1514: case SB_MIDI_VOL:
1515: src = SBP_1335_MIDI_VOL;
1516: break;
1517: case SB_CD_VOL:
1518: src = SBP_1335_CD_VOL;
1519: break;
1520: case SB_VOICE_VOL:
1521: src = SBP_1335_VOICE_VOL;
1522: gain = SB_1335_MASTER_GAIN(sc->gain[port][SB_LEFT]);
1523: break;
1524: default:
1525: return;
1526: }
1527: sbdsp_mix_write(sc, src, gain);
1528: break;
1529: case SBM_CT1345:
1530: gain = SB_STEREO_GAIN(sc->gain[port][SB_LEFT],
1531: sc->gain[port][SB_RIGHT]);
1532: switch (port) {
1533: case SB_MIC_VOL:
1534: src = SBP_MIC_VOL;
1535: gain = SB_MIC_GAIN(sc->gain[port][SB_LEFT]);
1536: break;
1537: case SB_MASTER_VOL:
1538: src = SBP_MASTER_VOL;
1539: break;
1540: case SB_LINE_IN_VOL:
1541: src = SBP_LINE_VOL;
1542: break;
1543: case SB_VOICE_VOL:
1544: src = SBP_VOICE_VOL;
1545: break;
1546: case SB_MIDI_VOL:
1547: src = SBP_MIDI_VOL;
1548: break;
1549: case SB_CD_VOL:
1550: src = SBP_CD_VOL;
1551: break;
1552: default:
1553: return;
1554: }
1555: sbdsp_mix_write(sc, src, gain);
1556: break;
1557: case SBM_CT1XX5:
1558: case SBM_CT1745:
1559: switch (port) {
1560: case SB_MIC_VOL:
1561: src = SB16P_MIC_L;
1562: break;
1563: case SB_MASTER_VOL:
1564: src = SB16P_MASTER_L;
1565: break;
1566: case SB_LINE_IN_VOL:
1567: src = SB16P_LINE_L;
1568: break;
1569: case SB_VOICE_VOL:
1570: src = SB16P_VOICE_L;
1571: break;
1572: case SB_MIDI_VOL:
1573: src = SB16P_MIDI_L;
1574: break;
1575: case SB_CD_VOL:
1576: src = SB16P_CD_L;
1577: break;
1578: case SB_INPUT_GAIN:
1579: src = SB16P_INPUT_GAIN_L;
1580: break;
1581: case SB_OUTPUT_GAIN:
1582: src = SB16P_OUTPUT_GAIN_L;
1583: break;
1584: case SB_TREBLE:
1585: src = SB16P_TREBLE_L;
1586: break;
1587: case SB_BASS:
1588: src = SB16P_BASS_L;
1589: break;
1590: case SB_PCSPEAKER:
1591: sbdsp_mix_write(sc, SB16P_PCSPEAKER, sc->gain[port][SB_LEFT]);
1592: return;
1593: default:
1594: return;
1595: }
1596: sbdsp_mix_write(sc, src, sc->gain[port][SB_LEFT]);
1597: sbdsp_mix_write(sc, SB16P_L_TO_R(src), sc->gain[port][SB_RIGHT]);
1598: break;
1599: }
1600: }
1601:
1602: int
1603: sbdsp_mixer_set_port(addr, cp)
1604: void *addr;
1605: mixer_ctrl_t *cp;
1606: {
1607: struct sbdsp_softc *sc = addr;
1608: int lgain, rgain;
1609: int mask, bits;
1610: int lmask, rmask, lbits, rbits;
1611: int mute, swap;
1612:
1613: if (sc->sc_open == SB_OPEN_MIDI)
1614: return EBUSY;
1615:
1616: DPRINTF(("sbdsp_mixer_set_port: port=%d num_channels=%d\n", cp->dev,
1617: cp->un.value.num_channels));
1618:
1619: if (sc->sc_mixer_model == SBM_NONE)
1620: return EINVAL;
1621:
1622: switch (cp->dev) {
1623: case SB_TREBLE:
1624: case SB_BASS:
1625: if (sc->sc_mixer_model == SBM_CT1345 ||
1626: sc->sc_mixer_model == SBM_CT1XX5) {
1627: if (cp->type != AUDIO_MIXER_ENUM)
1628: return EINVAL;
1629: switch (cp->dev) {
1630: case SB_TREBLE:
1631: sbdsp_set_ifilter(addr, cp->un.ord ? SB_TREBLE : 0);
1632: return 0;
1633: case SB_BASS:
1634: sbdsp_set_ifilter(addr, cp->un.ord ? SB_BASS : 0);
1635: return 0;
1636: }
1637: }
1638: case SB_PCSPEAKER:
1639: case SB_INPUT_GAIN:
1640: case SB_OUTPUT_GAIN:
1641: if (!ISSBM1745(sc))
1642: return EINVAL;
1643: case SB_MIC_VOL:
1644: case SB_LINE_IN_VOL:
1645: if (sc->sc_mixer_model == SBM_CT1335)
1646: return EINVAL;
1647: case SB_VOICE_VOL:
1648: case SB_MIDI_VOL:
1649: case SB_CD_VOL:
1650: case SB_MASTER_VOL:
1651: if (cp->type != AUDIO_MIXER_VALUE)
1652: return EINVAL;
1653:
1654: /*
1655: * All the mixer ports are stereo except for the microphone.
1656: * If we get a single-channel gain value passed in, then we
1657: * duplicate it to both left and right channels.
1658: */
1659:
1660: switch (cp->dev) {
1661: case SB_MIC_VOL:
1662: if (cp->un.value.num_channels != 1)
1663: return EINVAL;
1664:
1665: lgain = rgain = SB_ADJUST_MIC_GAIN(sc,
1666: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
1667: break;
1668: case SB_PCSPEAKER:
1669: if (cp->un.value.num_channels != 1)
1670: return EINVAL;
1671: /* fall into */
1672: case SB_INPUT_GAIN:
1673: case SB_OUTPUT_GAIN:
1674: lgain = rgain = SB_ADJUST_2_GAIN(sc,
1675: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
1676: break;
1677: default:
1678: switch (cp->un.value.num_channels) {
1679: case 1:
1680: lgain = rgain = SB_ADJUST_GAIN(sc,
1681: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
1682: break;
1683: case 2:
1684: if (sc->sc_mixer_model == SBM_CT1335)
1685: return EINVAL;
1686: lgain = SB_ADJUST_GAIN(sc,
1687: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
1688: rgain = SB_ADJUST_GAIN(sc,
1689: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
1690: break;
1691: default:
1692: return EINVAL;
1693: }
1694: break;
1695: }
1696: sc->gain[cp->dev][SB_LEFT] = lgain;
1697: sc->gain[cp->dev][SB_RIGHT] = rgain;
1698:
1699: sbdsp_set_mixer_gain(sc, cp->dev);
1700: break;
1701:
1702: case SB_RECORD_SOURCE:
1703: if (ISSBM1745(sc)) {
1704: if (cp->type != AUDIO_MIXER_SET)
1705: return EINVAL;
1706: return sbdsp_set_in_ports(sc, cp->un.mask);
1707: } else {
1708: if (cp->type != AUDIO_MIXER_ENUM)
1709: return EINVAL;
1710: sc->in_port = cp->un.ord;
1711: return sbdsp_set_in_ports(sc, 1 << cp->un.ord);
1712: }
1713: break;
1714:
1715: case SB_AGC:
1716: if (!ISSBM1745(sc) || cp->type != AUDIO_MIXER_ENUM)
1717: return EINVAL;
1718: sbdsp_mix_write(sc, SB16P_AGC, cp->un.ord & 1);
1719: break;
1720:
1721: case SB_CD_OUT_MUTE:
1722: mask = SB16P_SW_CD;
1723: goto omute;
1724: case SB_MIC_OUT_MUTE:
1725: mask = SB16P_SW_MIC;
1726: goto omute;
1727: case SB_LINE_OUT_MUTE:
1728: mask = SB16P_SW_LINE;
1729: omute:
1730: if (cp->type != AUDIO_MIXER_ENUM)
1731: return EINVAL;
1732: bits = sbdsp_mix_read(sc, SB16P_OSWITCH);
1733: sc->gain[cp->dev][SB_LR] = cp->un.ord != 0;
1734: if (cp->un.ord)
1735: bits = bits & ~mask;
1736: else
1737: bits = bits | mask;
1738: sbdsp_mix_write(sc, SB16P_OSWITCH, bits);
1739: break;
1740:
1741: case SB_MIC_IN_MUTE:
1742: case SB_MIC_SWAP:
1743: lmask = rmask = SB16P_SW_MIC;
1744: goto imute;
1745: case SB_CD_IN_MUTE:
1746: case SB_CD_SWAP:
1747: lmask = SB16P_SW_CD_L;
1748: rmask = SB16P_SW_CD_R;
1749: goto imute;
1750: case SB_LINE_IN_MUTE:
1751: case SB_LINE_SWAP:
1752: lmask = SB16P_SW_LINE_L;
1753: rmask = SB16P_SW_LINE_R;
1754: goto imute;
1755: case SB_MIDI_IN_MUTE:
1756: case SB_MIDI_SWAP:
1757: lmask = SB16P_SW_MIDI_L;
1758: rmask = SB16P_SW_MIDI_R;
1759: imute:
1760: if (cp->type != AUDIO_MIXER_ENUM)
1761: return EINVAL;
1762: mask = lmask | rmask;
1763: lbits = sbdsp_mix_read(sc, SB16P_ISWITCH_L) & ~mask;
1764: rbits = sbdsp_mix_read(sc, SB16P_ISWITCH_R) & ~mask;
1765: sc->gain[cp->dev][SB_LR] = cp->un.ord != 0;
1766: if (SB_IS_IN_MUTE(cp->dev)) {
1767: mute = cp->dev;
1768: swap = mute - SB_CD_IN_MUTE + SB_CD_SWAP;
1769: } else {
1770: swap = cp->dev;
1771: mute = swap + SB_CD_IN_MUTE - SB_CD_SWAP;
1772: }
1773: if (sc->gain[swap][SB_LR]) {
1774: mask = lmask;
1775: lmask = rmask;
1776: rmask = mask;
1777: }
1778: if (!sc->gain[mute][SB_LR]) {
1779: lbits = lbits | lmask;
1780: rbits = rbits | rmask;
1781: }
1782: sbdsp_mix_write(sc, SB16P_ISWITCH_L, lbits);
1783: sbdsp_mix_write(sc, SB16P_ISWITCH_L, rbits);
1784: break;
1785:
1786: default:
1787: return EINVAL;
1788: }
1789:
1790: return 0;
1791: }
1792:
1793: int
1794: sbdsp_mixer_get_port(addr, cp)
1795: void *addr;
1796: mixer_ctrl_t *cp;
1797: {
1798: struct sbdsp_softc *sc = addr;
1799:
1800: if (sc->sc_open == SB_OPEN_MIDI)
1801: return EBUSY;
1802:
1803: DPRINTF(("sbdsp_mixer_get_port: port=%d\n", cp->dev));
1804:
1805: if (sc->sc_mixer_model == SBM_NONE)
1806: return EINVAL;
1807:
1808: switch (cp->dev) {
1809: case SB_TREBLE:
1810: case SB_BASS:
1811: if (sc->sc_mixer_model == SBM_CT1345 ||
1812: sc->sc_mixer_model == SBM_CT1XX5) {
1813: switch (cp->dev) {
1814: case SB_TREBLE:
1815: cp->un.ord = sbdsp_get_ifilter(addr) == SB_TREBLE;
1816: return 0;
1817: case SB_BASS:
1818: cp->un.ord = sbdsp_get_ifilter(addr) == SB_BASS;
1819: return 0;
1820: }
1821: }
1822: case SB_PCSPEAKER:
1823: case SB_INPUT_GAIN:
1824: case SB_OUTPUT_GAIN:
1825: if (!ISSBM1745(sc))
1826: return EINVAL;
1827: case SB_MIC_VOL:
1828: case SB_LINE_IN_VOL:
1829: if (sc->sc_mixer_model == SBM_CT1335)
1830: return EINVAL;
1831: case SB_VOICE_VOL:
1832: case SB_MIDI_VOL:
1833: case SB_CD_VOL:
1834: case SB_MASTER_VOL:
1835: switch (cp->dev) {
1836: case SB_MIC_VOL:
1837: case SB_PCSPEAKER:
1838: if (cp->un.value.num_channels != 1)
1839: return EINVAL;
1840: /* fall into */
1841: default:
1842: switch (cp->un.value.num_channels) {
1843: case 1:
1844: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
1845: sc->gain[cp->dev][SB_LEFT];
1846: break;
1847: case 2:
1848: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
1849: sc->gain[cp->dev][SB_LEFT];
1850: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
1851: sc->gain[cp->dev][SB_RIGHT];
1852: break;
1853: default:
1854: return EINVAL;
1855: }
1856: break;
1857: }
1858: break;
1859:
1860: case SB_RECORD_SOURCE:
1861: if (ISSBM1745(sc))
1862: cp->un.mask = sc->in_mask;
1863: else
1864: cp->un.ord = sc->in_port;
1865: break;
1866:
1867: case SB_AGC:
1868: if (!ISSBM1745(sc))
1869: return EINVAL;
1870: cp->un.ord = sbdsp_mix_read(sc, SB16P_AGC);
1871: break;
1872:
1873: case SB_CD_IN_MUTE:
1874: case SB_MIC_IN_MUTE:
1875: case SB_LINE_IN_MUTE:
1876: case SB_MIDI_IN_MUTE:
1877: case SB_CD_SWAP:
1878: case SB_MIC_SWAP:
1879: case SB_LINE_SWAP:
1880: case SB_MIDI_SWAP:
1881: case SB_CD_OUT_MUTE:
1882: case SB_MIC_OUT_MUTE:
1883: case SB_LINE_OUT_MUTE:
1884: cp->un.ord = sc->gain[cp->dev][SB_LR];
1885: break;
1886:
1887: default:
1888: return EINVAL;
1889: }
1890:
1891: return 0;
1892: }
1893:
1894: int
1895: sbdsp_mixer_query_devinfo(addr, dip)
1896: void *addr;
1897: mixer_devinfo_t *dip;
1898: {
1899: struct sbdsp_softc *sc = addr;
1900: int chan, class, is1745;
1901:
1902: DPRINTF(("sbdsp_mixer_query_devinfo: model=%d index=%d\n",
1903: sc->sc_mixer_model, dip->index));
1904:
1905: if (sc->sc_mixer_model == SBM_NONE)
1906: return ENXIO;
1907:
1908: chan = sc->sc_mixer_model == SBM_CT1335 ? 1 : 2;
1909: is1745 = ISSBM1745(sc);
1910: class = is1745 ? SB_INPUT_CLASS : SB_OUTPUT_CLASS;
1911:
1912: switch (dip->index) {
1913: case SB_MASTER_VOL:
1914: dip->type = AUDIO_MIXER_VALUE;
1915: dip->mixer_class = SB_OUTPUT_CLASS;
1916: dip->prev = dip->next = AUDIO_MIXER_LAST;
1917: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
1918: dip->un.v.num_channels = chan;
1919: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
1920: return 0;
1921: case SB_MIDI_VOL:
1922: dip->type = AUDIO_MIXER_VALUE;
1923: dip->mixer_class = class;
1924: dip->prev = AUDIO_MIXER_LAST;
1925: dip->next = is1745 ? SB_MIDI_IN_MUTE : AUDIO_MIXER_LAST;
1926: strlcpy(dip->label.name, AudioNfmsynth, sizeof dip->label.name);
1927: dip->un.v.num_channels = chan;
1928: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
1929: return 0;
1930: case SB_CD_VOL:
1931: dip->type = AUDIO_MIXER_VALUE;
1932: dip->mixer_class = class;
1933: dip->prev = AUDIO_MIXER_LAST;
1934: dip->next = is1745 ? SB_CD_IN_MUTE : AUDIO_MIXER_LAST;
1935: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
1936: dip->un.v.num_channels = chan;
1937: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
1938: return 0;
1939: case SB_VOICE_VOL:
1940: dip->type = AUDIO_MIXER_VALUE;
1941: dip->mixer_class = class;
1942: dip->prev = AUDIO_MIXER_LAST;
1943: dip->next = AUDIO_MIXER_LAST;
1944: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
1945: dip->un.v.num_channels = chan;
1946: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
1947: return 0;
1948: case SB_OUTPUT_CLASS:
1949: dip->type = AUDIO_MIXER_CLASS;
1950: dip->mixer_class = SB_OUTPUT_CLASS;
1951: dip->next = dip->prev = AUDIO_MIXER_LAST;
1952: strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
1953: return 0;
1954: }
1955:
1956: if (sc->sc_mixer_model == SBM_CT1335)
1957: return ENXIO;
1958:
1959: switch (dip->index) {
1960: case SB_MIC_VOL:
1961: dip->type = AUDIO_MIXER_VALUE;
1962: dip->mixer_class = class;
1963: dip->prev = AUDIO_MIXER_LAST;
1964: dip->next = is1745 ? SB_MIC_IN_MUTE : AUDIO_MIXER_LAST;
1965: strlcpy(dip->label.name, AudioNmicrophone,
1966: sizeof dip->label.name);
1967: dip->un.v.num_channels = 1;
1968: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
1969: return 0;
1970:
1971: case SB_LINE_IN_VOL:
1972: dip->type = AUDIO_MIXER_VALUE;
1973: dip->mixer_class = class;
1974: dip->prev = AUDIO_MIXER_LAST;
1975: dip->next = is1745 ? SB_LINE_IN_MUTE : AUDIO_MIXER_LAST;
1976: strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
1977: dip->un.v.num_channels = 2;
1978: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
1979: return 0;
1980:
1981: case SB_RECORD_SOURCE:
1982: dip->mixer_class = SB_RECORD_CLASS;
1983: dip->prev = dip->next = AUDIO_MIXER_LAST;
1984: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
1985: if (ISSBM1745(sc)) {
1986: dip->type = AUDIO_MIXER_SET;
1987: dip->un.s.num_mem = 4;
1988: strlcpy(dip->un.s.member[0].label.name,
1989: AudioNmicrophone,
1990: sizeof dip->un.s.member[0].label.name);
1991: dip->un.s.member[0].mask = 1 << SB_MIC_VOL;
1992: strlcpy(dip->un.s.member[1].label.name,
1993: AudioNcd, sizeof dip->un.s.member[1].label.name);
1994: dip->un.s.member[1].mask = 1 << SB_CD_VOL;
1995: strlcpy(dip->un.s.member[2].label.name,
1996: AudioNline, sizeof dip->un.s.member[2].label.name);
1997: dip->un.s.member[2].mask = 1 << SB_LINE_IN_VOL;
1998: strlcpy(dip->un.s.member[3].label.name,
1999: AudioNfmsynth,
2000: sizeof dip->un.s.member[3].label.name);
2001: dip->un.s.member[3].mask = 1 << SB_MIDI_VOL;
2002: } else {
2003: dip->type = AUDIO_MIXER_ENUM;
2004: dip->un.e.num_mem = 3;
2005: strlcpy(dip->un.e.member[0].label.name,
2006: AudioNmicrophone,
2007: sizeof dip->un.e.member[0].label.name);
2008: dip->un.e.member[0].ord = SB_MIC_VOL;
2009: strlcpy(dip->un.e.member[1].label.name, AudioNcd,
2010: sizeof dip->un.e.member[1].label.name);
2011: dip->un.e.member[1].ord = SB_CD_VOL;
2012: strlcpy(dip->un.e.member[2].label.name, AudioNline,
2013: sizeof dip->un.e.member[2].label.name);
2014: dip->un.e.member[2].ord = SB_LINE_IN_VOL;
2015: }
2016: return 0;
2017:
2018: case SB_BASS:
2019: dip->prev = dip->next = AUDIO_MIXER_LAST;
2020: strlcpy(dip->label.name, AudioNbass, sizeof dip->label.name);
2021: if (sc->sc_mixer_model == SBM_CT1745) {
2022: dip->type = AUDIO_MIXER_VALUE;
2023: dip->mixer_class = SB_EQUALIZATION_CLASS;
2024: dip->un.v.num_channels = 2;
2025: strlcpy(dip->un.v.units.name, AudioNbass, sizeof dip->un.v.units.name);
2026: } else {
2027: dip->type = AUDIO_MIXER_ENUM;
2028: dip->mixer_class = SB_INPUT_CLASS;
2029: dip->un.e.num_mem = 2;
2030: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
2031: sizeof dip->un.e.member[0].label.name);
2032: dip->un.e.member[0].ord = 0;
2033: strlcpy(dip->un.e.member[1].label.name, AudioNon,
2034: sizeof dip->un.e.member[1].label.name);
2035: dip->un.e.member[1].ord = 1;
2036: }
2037: return 0;
2038:
2039: case SB_TREBLE:
2040: dip->prev = dip->next = AUDIO_MIXER_LAST;
2041: strlcpy(dip->label.name, AudioNtreble, sizeof dip->label.name);
2042: if (sc->sc_mixer_model == SBM_CT1745) {
2043: dip->type = AUDIO_MIXER_VALUE;
2044: dip->mixer_class = SB_EQUALIZATION_CLASS;
2045: dip->un.v.num_channels = 2;
2046: strlcpy(dip->un.v.units.name, AudioNtreble, sizeof dip->un.v.units.name);
2047: } else {
2048: dip->type = AUDIO_MIXER_ENUM;
2049: dip->mixer_class = SB_INPUT_CLASS;
2050: dip->un.e.num_mem = 2;
2051: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
2052: sizeof dip->un.e.member[0].label.name);
2053: dip->un.e.member[0].ord = 0;
2054: strlcpy(dip->un.e.member[1].label.name, AudioNon,
2055: sizeof dip->un.e.member[1].label.name);
2056: dip->un.e.member[1].ord = 1;
2057: }
2058: return 0;
2059:
2060: case SB_RECORD_CLASS: /* record source class */
2061: dip->type = AUDIO_MIXER_CLASS;
2062: dip->mixer_class = SB_RECORD_CLASS;
2063: dip->next = dip->prev = AUDIO_MIXER_LAST;
2064: strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
2065: return 0;
2066:
2067: case SB_INPUT_CLASS:
2068: dip->type = AUDIO_MIXER_CLASS;
2069: dip->mixer_class = SB_INPUT_CLASS;
2070: dip->next = dip->prev = AUDIO_MIXER_LAST;
2071: strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
2072: return 0;
2073:
2074: }
2075:
2076: if (sc->sc_mixer_model == SBM_CT1345)
2077: return ENXIO;
2078:
2079: switch(dip->index) {
2080: case SB_PCSPEAKER:
2081: dip->type = AUDIO_MIXER_VALUE;
2082: dip->mixer_class = SB_INPUT_CLASS;
2083: dip->prev = dip->next = AUDIO_MIXER_LAST;
2084: strlcpy(dip->label.name, "pc_speaker", sizeof dip->label.name);
2085: dip->un.v.num_channels = 1;
2086: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
2087: return 0;
2088:
2089: case SB_INPUT_GAIN:
2090: dip->type = AUDIO_MIXER_VALUE;
2091: dip->mixer_class = SB_INPUT_CLASS;
2092: dip->prev = dip->next = AUDIO_MIXER_LAST;
2093: strlcpy(dip->label.name, AudioNinput, sizeof dip->label.name);
2094: dip->un.v.num_channels = 2;
2095: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
2096: return 0;
2097:
2098: case SB_OUTPUT_GAIN:
2099: dip->type = AUDIO_MIXER_VALUE;
2100: dip->mixer_class = SB_OUTPUT_CLASS;
2101: dip->prev = dip->next = AUDIO_MIXER_LAST;
2102: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
2103: dip->un.v.num_channels = 2;
2104: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
2105: return 0;
2106:
2107: case SB_AGC:
2108: dip->type = AUDIO_MIXER_ENUM;
2109: dip->mixer_class = SB_INPUT_CLASS;
2110: dip->prev = dip->next = AUDIO_MIXER_LAST;
2111: strlcpy(dip->label.name, "agc", sizeof dip->label.name);
2112: dip->un.e.num_mem = 2;
2113: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
2114: sizeof dip->un.e.member[0].label.name);
2115: dip->un.e.member[0].ord = 0;
2116: strlcpy(dip->un.e.member[1].label.name, AudioNon,
2117: sizeof dip->un.e.member[1].label.name);
2118: dip->un.e.member[1].ord = 1;
2119: return 0;
2120:
2121: case SB_EQUALIZATION_CLASS:
2122: dip->type = AUDIO_MIXER_CLASS;
2123: dip->mixer_class = SB_EQUALIZATION_CLASS;
2124: dip->next = dip->prev = AUDIO_MIXER_LAST;
2125: strlcpy(dip->label.name, AudioCequalization, sizeof dip->label.name);
2126: return 0;
2127:
2128: case SB_CD_IN_MUTE:
2129: dip->prev = SB_CD_VOL;
2130: dip->next = SB_CD_SWAP;
2131: dip->mixer_class = SB_INPUT_CLASS;
2132: goto mute;
2133:
2134: case SB_MIC_IN_MUTE:
2135: dip->prev = SB_MIC_VOL;
2136: dip->next = SB_MIC_SWAP;
2137: dip->mixer_class = SB_INPUT_CLASS;
2138: goto mute;
2139:
2140: case SB_LINE_IN_MUTE:
2141: dip->prev = SB_LINE_IN_VOL;
2142: dip->next = SB_LINE_SWAP;
2143: dip->mixer_class = SB_INPUT_CLASS;
2144: goto mute;
2145:
2146: case SB_MIDI_IN_MUTE:
2147: dip->prev = SB_MIDI_VOL;
2148: dip->next = SB_MIDI_SWAP;
2149: dip->mixer_class = SB_INPUT_CLASS;
2150: goto mute;
2151:
2152: case SB_CD_SWAP:
2153: dip->prev = SB_CD_IN_MUTE;
2154: dip->next = SB_CD_OUT_MUTE;
2155: goto swap;
2156:
2157: case SB_MIC_SWAP:
2158: dip->prev = SB_MIC_IN_MUTE;
2159: dip->next = SB_MIC_OUT_MUTE;
2160: goto swap;
2161:
2162: case SB_LINE_SWAP:
2163: dip->prev = SB_LINE_IN_MUTE;
2164: dip->next = SB_LINE_OUT_MUTE;
2165: goto swap;
2166:
2167: case SB_MIDI_SWAP:
2168: dip->prev = SB_MIDI_IN_MUTE;
2169: dip->next = AUDIO_MIXER_LAST;
2170: swap:
2171: dip->mixer_class = SB_INPUT_CLASS;
2172: strlcpy(dip->label.name, AudioNswap, sizeof dip->label.name);
2173: goto mute1;
2174:
2175: case SB_CD_OUT_MUTE:
2176: dip->prev = SB_CD_SWAP;
2177: dip->next = AUDIO_MIXER_LAST;
2178: dip->mixer_class = SB_OUTPUT_CLASS;
2179: goto mute;
2180:
2181: case SB_MIC_OUT_MUTE:
2182: dip->prev = SB_MIC_SWAP;
2183: dip->next = AUDIO_MIXER_LAST;
2184: dip->mixer_class = SB_OUTPUT_CLASS;
2185: goto mute;
2186:
2187: case SB_LINE_OUT_MUTE:
2188: dip->prev = SB_LINE_SWAP;
2189: dip->next = AUDIO_MIXER_LAST;
2190: dip->mixer_class = SB_OUTPUT_CLASS;
2191: mute:
2192: strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
2193: mute1:
2194: dip->type = AUDIO_MIXER_ENUM;
2195: dip->un.e.num_mem = 2;
2196: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
2197: sizeof dip->un.e.member[0].label.name);
2198: dip->un.e.member[0].ord = 0;
2199: strlcpy(dip->un.e.member[1].label.name, AudioNon,
2200: sizeof dip->un.e.member[1].label.name);
2201: dip->un.e.member[1].ord = 1;
2202: return 0;
2203:
2204: }
2205:
2206: return ENXIO;
2207: }
2208:
2209: void *
2210: sb_malloc(addr, direction, size, pool, flags)
2211: void *addr;
2212: int direction;
2213: size_t size;
2214: int pool;
2215: int flags;
2216: {
2217: struct sbdsp_softc *sc = addr;
2218: int drq;
2219:
2220: /* 8-bit has more restrictive alignment */
2221: if (sc->sc_drq8 != -1)
2222: drq = sc->sc_drq8;
2223: else
2224: drq = sc->sc_drq16;
2225:
2226: return isa_malloc(sc->sc_isa, drq, size, pool, flags);
2227: }
2228:
2229: void
2230: sb_free(addr, ptr, pool)
2231: void *addr;
2232: void *ptr;
2233: int pool;
2234: {
2235: isa_free(ptr, pool);
2236: }
2237:
2238: size_t
2239: sb_round(addr, direction, size)
2240: void *addr;
2241: int direction;
2242: size_t size;
2243: {
2244: if (size > MAX_ISADMA)
2245: size = MAX_ISADMA;
2246: return size;
2247: }
2248:
2249: paddr_t
2250: sb_mappage(addr, mem, off, prot)
2251: void *addr;
2252: void *mem;
2253: off_t off;
2254: int prot;
2255: {
2256: return isa_mappage(mem, off, prot);
2257: }
2258:
2259: int
2260: sbdsp_get_props(addr)
2261: void *addr;
2262: {
2263: struct sbdsp_softc *sc = addr;
2264: return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT |
2265: (sc->sc_fullduplex ? AUDIO_PROP_FULLDUPLEX : 0);
2266: }
2267:
2268: #if NMIDI > 0
2269: /*
2270: * MIDI related routines.
2271: */
2272:
2273: int
2274: sbdsp_midi_open(addr, flags, iintr, ointr, arg)
2275: void *addr;
2276: int flags;
2277: void (*iintr)(void *, int);
2278: void (*ointr)(void *);
2279: void *arg;
2280: {
2281: struct sbdsp_softc *sc = addr;
2282:
2283: DPRINTF(("sbdsp_midi_open: sc=%p\n", sc));
2284:
2285: if (sc->sc_open != SB_CLOSED)
2286: return EBUSY;
2287: if (sbdsp_reset(sc) != 0)
2288: return EIO;
2289:
2290: if (sc->sc_model >= SB_20)
2291: if (sbdsp_wdsp(sc, SB_MIDI_UART_INTR)) /* enter UART mode */
2292: return EIO;
2293: sc->sc_open = SB_OPEN_MIDI;
2294: sc->sc_openflags = flags;
2295: sc->sc_intr8 = sbdsp_midi_intr;
2296: sc->sc_arg8 = addr;
2297: sc->sc_intrm = iintr;
2298: sc->sc_argm = arg;
2299: return 0;
2300: }
2301:
2302: void
2303: sbdsp_midi_close(addr)
2304: void *addr;
2305: {
2306: struct sbdsp_softc *sc = addr;
2307:
2308: DPRINTF(("sbdsp_midi_close: sc=%p\n", sc));
2309:
2310: if (sc->sc_model >= SB_20)
2311: sbdsp_reset(sc); /* exit UART mode */
2312: sc->sc_open = SB_CLOSED;
2313: sc->sc_intrm = 0;
2314: }
2315:
2316: int
2317: sbdsp_midi_output(addr, d)
2318: void *addr;
2319: int d;
2320: {
2321: struct sbdsp_softc *sc = addr;
2322:
2323: if (sc->sc_model < SB_20 && sbdsp_wdsp(sc, SB_MIDI_WRITE))
2324: return EIO;
2325: if (sbdsp_wdsp(sc, d))
2326: return EIO;
2327: return 0;
2328: }
2329:
2330: void
2331: sbdsp_midi_getinfo(addr, mi)
2332: void *addr;
2333: struct midi_info *mi;
2334: {
2335: struct sbdsp_softc *sc = addr;
2336:
2337: mi->name = sc->sc_model < SB_20 ? "SB MIDI cmd" : "SB MIDI UART";
2338: mi->props = MIDI_PROP_CAN_INPUT;
2339: }
2340:
2341: int
2342: sbdsp_midi_intr(addr)
2343: void *addr;
2344: {
2345: struct sbdsp_softc *sc = addr;
2346:
2347: sc->sc_intrm(sc->sc_argm, sbdsp_rdsp(sc));
2348: return (0);
2349: }
2350:
2351: #endif