Annotation of sys/dev/isa/ess.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ess.c,v 1.11 2006/02/22 19:43:42 miod Exp $ */
2: /* $NetBSD: ess.c,v 1.44.4.1 1999/06/21 01:18:00 thorpej Exp $ */
3:
4: /*
5: * Copyright 1997
6: * Digital Equipment Corporation. All rights reserved.
7: *
8: * This software is furnished under license and may be used and
9: * copied only in accordance with the following terms and conditions.
10: * Subject to these conditions, you may download, copy, install,
11: * use, modify and distribute this software in source and/or binary
12: * form. No title or ownership is transferred hereby.
13: *
14: * 1) Any source code used, modified or distributed must reproduce
15: * and retain this copyright notice and list of conditions as
16: * they appear in the source file.
17: *
18: * 2) No right is granted to use any trade name, trademark, or logo of
19: * Digital Equipment Corporation. Neither the "Digital Equipment
20: * Corporation" name nor any trademark or logo of Digital Equipment
21: * Corporation may be used to endorse or promote products derived
22: * from this software without the prior written permission of
23: * Digital Equipment Corporation.
24: *
25: * 3) This software is provided "AS-IS" and any express or implied
26: * warranties, including but not limited to, any implied warranties
27: * of merchantability, fitness for a particular purpose, or
28: * non-infringement are disclaimed. In no event shall DIGITAL be
29: * liable for any damages whatsoever, and in particular, DIGITAL
30: * shall not be liable for special, indirect, consequential, or
31: * incidental damages or damages for lost profits, loss of
32: * revenue or loss of use, whether such damages arise in contract,
33: * negligence, tort, under statute, in equity, at law or otherwise,
34: * even if advised of the possibility of such damage.
35: */
36:
37: /*
38: **++
39: **
40: ** ess.c
41: **
42: ** FACILITY:
43: **
44: ** DIGITAL Network Appliance Reference Design (DNARD)
45: **
46: ** MODULE DESCRIPTION:
47: **
48: ** This module contains the device driver for the ESS
49: ** Technologies 1888/1887/888 sound chip. The code in sbdsp.c was
50: ** used as a reference point when implementing this driver.
51: **
52: ** AUTHORS:
53: **
54: ** Blair Fidler Software Engineering Australia
55: ** Gold Coast, Australia.
56: **
57: ** CREATION DATE:
58: **
59: ** March 10, 1997.
60: **
61: ** MODIFICATION HISTORY:
62: **
63: ** Heavily modified by Lennart Augustsson and Charles M. Hannum for
64: ** bus_dma, changes to audio interface, and many bug fixes.
65: ** ESS1788 support by Nathan J. Williams and Charles M. Hannum.
66: **--
67: */
68:
69: #include <sys/param.h>
70: #include <sys/systm.h>
71: #include <sys/errno.h>
72: #include <sys/ioctl.h>
73: #include <sys/syslog.h>
74: #include <sys/device.h>
75: #include <sys/proc.h>
76: #include <sys/kernel.h>
77: #include <sys/timeout.h>
78:
79: #include <machine/cpu.h>
80: #include <machine/intr.h>
81: #include <machine/bus.h>
82:
83: #include <sys/audioio.h>
84: #include <dev/audio_if.h>
85: #include <dev/auconv.h>
86: #include <dev/mulaw.h>
87:
88: #include <dev/isa/isavar.h>
89: #include <dev/isa/isadmavar.h>
90:
91: #include <dev/isa/essvar.h>
92: #include <dev/isa/essreg.h>
93:
94: #ifdef AUDIO_DEBUG
95: #define DPRINTF(x) if (essdebug) printf x
96: #define DPRINTFN(n,x) if (essdebug>(n)) printf x
97: int essdebug = 0;
98: #else
99: #define DPRINTF(x)
100: #define DPRINTFN(n,x)
101: #endif
102:
103: #if 0
104: unsigned uuu;
105: #define EREAD1(t, h, a) (uuu=bus_space_read_1(t, h, a),printf("EREAD %02x=%02x\n", ((int)h&0xfff)+a, uuu),uuu)
106: #define EWRITE1(t, h, a, d) (printf("EWRITE %02x=%02x\n", ((int)h & 0xfff)+a, d), bus_space_write_1(t, h, a, d))
107: #else
108: #define EREAD1(t, h, a) bus_space_read_1(t, h, a)
109: #define EWRITE1(t, h, a, d) bus_space_write_1(t, h, a, d)
110: #endif
111:
112: struct cfdriver ess_cd = {
113: NULL, "ess", DV_DULL
114: };
115:
116: int ess_setup_sc(struct ess_softc *, int);
117:
118: int ess_open(void *, int);
119: void ess_1788_close(void *);
120: void ess_1888_close(void *);
121: int ess_getdev(void *, struct audio_device *);
122: int ess_drain(void *);
123:
124: int ess_query_encoding(void *, struct audio_encoding *);
125:
126: int ess_set_params(void *, int, int, struct audio_params *,
127: struct audio_params *);
128:
129: int ess_round_blocksize(void *, int);
130:
131: int ess_audio1_trigger_output(void *, void *, void *, int,
132: void (*)(void *), void *, struct audio_params *);
133: int ess_audio2_trigger_output(void *, void *, void *, int,
134: void (*)(void *), void *, struct audio_params *);
135: int ess_audio1_trigger_input(void *, void *, void *, int,
136: void (*)(void *), void *, struct audio_params *);
137: int ess_audio1_halt(void *);
138: int ess_audio2_halt(void *);
139: int ess_audio1_intr(void *);
140: int ess_audio2_intr(void *);
141: void ess_audio1_poll(void *);
142: void ess_audio2_poll(void *);
143:
144: int ess_speaker_ctl(void *, int);
145:
146: int ess_getdev(void *, struct audio_device *);
147:
148: int ess_set_port(void *, mixer_ctrl_t *);
149: int ess_get_port(void *, mixer_ctrl_t *);
150:
151: void *ess_malloc(void *, int, size_t, int, int);
152: void ess_free(void *, void *, int);
153: size_t ess_round_buffersize(void *, int, size_t);
154: paddr_t ess_mappage(void *, void *, off_t, int);
155:
156:
157: int ess_query_devinfo(void *, mixer_devinfo_t *);
158: int ess_1788_get_props(void *);
159: int ess_1888_get_props(void *);
160:
161: void ess_speaker_on(struct ess_softc *);
162: void ess_speaker_off(struct ess_softc *);
163:
164: int ess_config_addr(struct ess_softc *);
165: void ess_config_irq(struct ess_softc *);
166: void ess_config_drq(struct ess_softc *);
167: void ess_setup(struct ess_softc *);
168: int ess_identify(struct ess_softc *);
169:
170: int ess_reset(struct ess_softc *);
171: void ess_set_gain(struct ess_softc *, int, int);
172: int ess_set_in_port(struct ess_softc *, int);
173: int ess_set_in_ports(struct ess_softc *, int);
174: u_int ess_srtotc(u_int);
175: u_int ess_srtofc(u_int);
176: u_char ess_get_dsp_status(struct ess_softc *);
177: u_char ess_dsp_read_ready(struct ess_softc *);
178: u_char ess_dsp_write_ready(struct ess_softc *);
179: int ess_rdsp(struct ess_softc *);
180: int ess_wdsp(struct ess_softc *, u_char);
181: u_char ess_read_x_reg(struct ess_softc *, u_char);
182: int ess_write_x_reg(struct ess_softc *, u_char, u_char);
183: void ess_clear_xreg_bits(struct ess_softc *, u_char, u_char);
184: void ess_set_xreg_bits(struct ess_softc *, u_char, u_char);
185: u_char ess_read_mix_reg(struct ess_softc *, u_char);
186: void ess_write_mix_reg(struct ess_softc *, u_char, u_char);
187: void ess_clear_mreg_bits(struct ess_softc *, u_char, u_char);
188: void ess_set_mreg_bits(struct ess_softc *, u_char, u_char);
189: void ess_read_multi_mix_reg(struct ess_softc *, u_char, u_int8_t *, bus_size_t);
190:
191: static char *essmodel[] = {
192: "unsupported",
193: "1888",
194: "1887",
195: "888",
196: "1788",
197: "1869",
198: "1879",
199: "1868",
200: "1878",
201: };
202:
203: struct audio_device ess_device = {
204: "ESS Technology",
205: "x",
206: "ess"
207: };
208:
209: /*
210: * Define our interface to the higher level audio driver.
211: */
212:
213: struct audio_hw_if ess_1788_hw_if = {
214: ess_open,
215: ess_1788_close,
216: ess_drain,
217: ess_query_encoding,
218: ess_set_params,
219: ess_round_blocksize,
220: NULL,
221: NULL,
222: NULL,
223: NULL,
224: NULL,
225: ess_audio1_halt,
226: ess_audio1_halt,
227: ess_speaker_ctl,
228: ess_getdev,
229: NULL,
230: ess_set_port,
231: ess_get_port,
232: ess_query_devinfo,
233: ess_malloc,
234: ess_free,
235: ess_round_buffersize,
236: ess_mappage,
237: ess_1788_get_props,
238: ess_audio1_trigger_output,
239: ess_audio1_trigger_input,
240: };
241:
242: struct audio_hw_if ess_1888_hw_if = {
243: ess_open,
244: ess_1888_close,
245: ess_drain,
246: ess_query_encoding,
247: ess_set_params,
248: ess_round_blocksize,
249: NULL,
250: NULL,
251: NULL,
252: NULL,
253: NULL,
254: ess_audio2_halt,
255: ess_audio1_halt,
256: ess_speaker_ctl,
257: ess_getdev,
258: NULL,
259: ess_set_port,
260: ess_get_port,
261: ess_query_devinfo,
262: ess_malloc,
263: ess_free,
264: ess_round_buffersize,
265: ess_mappage,
266: ess_1888_get_props,
267: ess_audio2_trigger_output,
268: ess_audio1_trigger_input,
269: };
270:
271: #ifdef AUDIO_DEBUG
272: void ess_printsc(struct ess_softc *);
273: void ess_dump_mixer(struct ess_softc *);
274:
275: void
276: ess_printsc(sc)
277: struct ess_softc *sc;
278: {
279: int i;
280:
281: printf("open %d iobase 0x%x outport %u inport %u speaker %s\n",
282: (int)sc->sc_open, sc->sc_iobase, sc->out_port,
283: sc->in_port, sc->spkr_state ? "on" : "off");
284:
285: printf("audio1: dmachan %d irq %d nintr %lu intr %p arg %p\n",
286: sc->sc_audio1.drq, sc->sc_audio1.irq, sc->sc_audio1.nintr,
287: sc->sc_audio1.intr, sc->sc_audio1.arg);
288:
289: if (!ESS_USE_AUDIO1(sc->sc_model)) {
290: printf("audio2: dmachan %d irq %d nintr %lu intr %p arg %p\n",
291: sc->sc_audio2.drq, sc->sc_audio2.irq, sc->sc_audio2.nintr,
292: sc->sc_audio2.intr, sc->sc_audio2.arg);
293: }
294:
295: printf("gain:");
296: for (i = 0; i < sc->ndevs; i++)
297: printf(" %u,%u", sc->gain[i][ESS_LEFT], sc->gain[i][ESS_RIGHT]);
298: printf("\n");
299: }
300:
301: void
302: ess_dump_mixer(sc)
303: struct ess_softc *sc;
304: {
305: printf("ESS_DAC_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
306: 0x7C, ess_read_mix_reg(sc, 0x7C));
307: printf("ESS_MIC_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
308: 0x1A, ess_read_mix_reg(sc, 0x1A));
309: printf("ESS_LINE_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
310: 0x3E, ess_read_mix_reg(sc, 0x3E));
311: printf("ESS_SYNTH_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
312: 0x36, ess_read_mix_reg(sc, 0x36));
313: printf("ESS_CD_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
314: 0x38, ess_read_mix_reg(sc, 0x38));
315: printf("ESS_AUXB_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
316: 0x3A, ess_read_mix_reg(sc, 0x3A));
317: printf("ESS_MASTER_VOL: mix reg 0x%02x=0x%02x\n",
318: 0x32, ess_read_mix_reg(sc, 0x32));
319: printf("ESS_PCSPEAKER_VOL: mix reg 0x%02x=0x%02x\n",
320: 0x3C, ess_read_mix_reg(sc, 0x3C));
321: printf("ESS_DAC_REC_VOL: mix reg 0x%02x=0x%02x\n",
322: 0x69, ess_read_mix_reg(sc, 0x69));
323: printf("ESS_MIC_REC_VOL: mix reg 0x%02x=0x%02x\n",
324: 0x68, ess_read_mix_reg(sc, 0x68));
325: printf("ESS_LINE_REC_VOL: mix reg 0x%02x=0x%02x\n",
326: 0x6E, ess_read_mix_reg(sc, 0x6E));
327: printf("ESS_SYNTH_REC_VOL: mix reg 0x%02x=0x%02x\n",
328: 0x6B, ess_read_mix_reg(sc, 0x6B));
329: printf("ESS_CD_REC_VOL: mix reg 0x%02x=0x%02x\n",
330: 0x6A, ess_read_mix_reg(sc, 0x6A));
331: printf("ESS_AUXB_REC_VOL: mix reg 0x%02x=0x%02x\n",
332: 0x6C, ess_read_mix_reg(sc, 0x6C));
333: printf("ESS_RECORD_VOL: x reg 0x%02x=0x%02x\n",
334: 0xB4, ess_read_x_reg(sc, 0xB4));
335: printf("Audio 1 play vol (unused): mix reg 0x%02x=0x%02x\n",
336: 0x14, ess_read_mix_reg(sc, 0x14));
337:
338: printf("ESS_MIC_PREAMP: x reg 0x%02x=0x%02x\n",
339: ESS_XCMD_PREAMP_CTRL, ess_read_x_reg(sc, ESS_XCMD_PREAMP_CTRL));
340: printf("ESS_RECORD_MONITOR: x reg 0x%02x=0x%02x\n",
341: ESS_XCMD_AUDIO_CTRL, ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL));
342: printf("Record source: mix reg 0x%02x=0x%02x, 0x%02x=0x%02x\n",
343: ESS_MREG_ADC_SOURCE, ess_read_mix_reg(sc, ESS_MREG_ADC_SOURCE),
344: ESS_MREG_AUDIO2_CTRL2, ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2));
345: }
346:
347: #endif
348:
349: /*
350: * Configure the ESS chip for the desired audio base address.
351: */
352: int
353: ess_config_addr(sc)
354: struct ess_softc *sc;
355: {
356: int iobase = sc->sc_iobase;
357: bus_space_tag_t iot = sc->sc_iot;
358:
359: /*
360: * Configure using the System Control Register method. This
361: * method is used when the AMODE line is tied high, which is
362: * the case for the Shark, but not for the evaluation board.
363: */
364:
365: bus_space_handle_t scr_access_ioh;
366: bus_space_handle_t scr_ioh;
367: u_short scr_value;
368:
369: /*
370: * Set the SCR bit to enable audio.
371: */
372: scr_value = ESS_SCR_AUDIO_ENABLE;
373:
374: /*
375: * Set the SCR bits necessary to select the specified audio
376: * base address.
377: */
378: switch(iobase) {
379: case 0x220:
380: scr_value |= ESS_SCR_AUDIO_220;
381: break;
382: case 0x230:
383: scr_value |= ESS_SCR_AUDIO_230;
384: break;
385: case 0x240:
386: scr_value |= ESS_SCR_AUDIO_240;
387: break;
388: case 0x250:
389: scr_value |= ESS_SCR_AUDIO_250;
390: break;
391: default:
392: printf("ess: configured iobase 0x%x invalid\n", iobase);
393: return (1);
394: break;
395: }
396:
397: /*
398: * Get a mapping for the System Control Register (SCR) access
399: * registers and the SCR data registers.
400: */
401: if (bus_space_map(iot, ESS_SCR_ACCESS_BASE, ESS_SCR_ACCESS_PORTS,
402: 0, &scr_access_ioh)) {
403: printf("ess: can't map SCR access registers\n");
404: return (1);
405: }
406: if (bus_space_map(iot, ESS_SCR_BASE, ESS_SCR_PORTS,
407: 0, &scr_ioh)) {
408: printf("ess: can't map SCR registers\n");
409: bus_space_unmap(iot, scr_access_ioh, ESS_SCR_ACCESS_PORTS);
410: return (1);
411: }
412:
413: /* Unlock the SCR. */
414: EWRITE1(iot, scr_access_ioh, ESS_SCR_UNLOCK, 0);
415:
416: /* Write the base address information into SCR[0]. */
417: EWRITE1(iot, scr_ioh, ESS_SCR_INDEX, 0);
418: EWRITE1(iot, scr_ioh, ESS_SCR_DATA, scr_value);
419:
420: /* Lock the SCR. */
421: EWRITE1(iot, scr_access_ioh, ESS_SCR_LOCK, 0);
422:
423: /* Unmap the SCR access ports and the SCR data ports. */
424: bus_space_unmap(iot, scr_access_ioh, ESS_SCR_ACCESS_PORTS);
425: bus_space_unmap(iot, scr_ioh, ESS_SCR_PORTS);
426:
427: return 0;
428: }
429:
430:
431: /*
432: * Configure the ESS chip for the desired IRQ and DMA channels.
433: * ESS ISA
434: * --------
435: * IRQA irq9
436: * IRQB irq5
437: * IRQC irq7
438: * IRQD irq10
439: * IRQE irq15
440: *
441: * DRQA drq0
442: * DRQB drq1
443: * DRQC drq3
444: * DRQD drq5
445: */
446: void
447: ess_config_irq(sc)
448: struct ess_softc *sc;
449: {
450: int v;
451:
452: DPRINTFN(2,("ess_config_irq\n"));
453:
454: if (sc->sc_model == ESS_1887 &&
455: sc->sc_audio1.irq == sc->sc_audio2.irq &&
456: sc->sc_audio1.irq != -1) {
457: /* Use new method, both interrupts are the same. */
458: v = ESS_IS_SELECT_IRQ; /* enable intrs */
459: switch (sc->sc_audio1.irq) {
460: case 5:
461: v |= ESS_IS_INTRB;
462: break;
463: case 7:
464: v |= ESS_IS_INTRC;
465: break;
466: case 9:
467: v |= ESS_IS_INTRA;
468: break;
469: case 10:
470: v |= ESS_IS_INTRD;
471: break;
472: case 15:
473: v |= ESS_IS_INTRE;
474: break;
475: #ifdef DIAGNOSTIC
476: default:
477: printf("ess_config_irq: configured irq %d not supported for Audio 1\n",
478: sc->sc_audio1.irq);
479: return;
480: #endif
481: }
482: /* Set the IRQ */
483: ess_write_mix_reg(sc, ESS_MREG_INTR_ST, v);
484: return;
485: }
486:
487: if (sc->sc_model == ESS_1887) {
488: /* Tell the 1887 to use the old interrupt method. */
489: ess_write_mix_reg(sc, ESS_MREG_INTR_ST, ESS_IS_ES1888);
490: }
491:
492: if (sc->sc_audio1.polled) {
493: /* Turn off Audio1 interrupts. */
494: v = 0;
495: } else {
496: /* Configure Audio 1 for the appropriate IRQ line. */
497: v = ESS_IRQ_CTRL_MASK | ESS_IRQ_CTRL_EXT; /* All intrs on */
498: switch (sc->sc_audio1.irq) {
499: case 5:
500: v |= ESS_IRQ_CTRL_INTRB;
501: break;
502: case 7:
503: v |= ESS_IRQ_CTRL_INTRC;
504: break;
505: case 9:
506: v |= ESS_IRQ_CTRL_INTRA;
507: break;
508: case 10:
509: v |= ESS_IRQ_CTRL_INTRD;
510: break;
511: #ifdef DIAGNOSTIC
512: default:
513: printf("ess: configured irq %d not supported for Audio 1\n",
514: sc->sc_audio1.irq);
515: return;
516: #endif
517: }
518: }
519: ess_write_x_reg(sc, ESS_XCMD_IRQ_CTRL, v);
520:
521: if (ESS_USE_AUDIO1(sc->sc_model))
522: return;
523:
524: if (sc->sc_audio2.polled) {
525: /* Turn off Audio2 interrupts. */
526: ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
527: ESS_AUDIO2_CTRL2_IRQ2_ENABLE);
528: } else {
529: /* Audio2 is hardwired to INTRE in this mode. */
530: ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
531: ESS_AUDIO2_CTRL2_IRQ2_ENABLE);
532: }
533: }
534:
535:
536: void
537: ess_config_drq(sc)
538: struct ess_softc *sc;
539: {
540: int v;
541:
542: DPRINTFN(2,("ess_config_drq\n"));
543:
544: /* Configure Audio 1 (record) for DMA on the appropriate channel. */
545: v = ESS_DRQ_CTRL_PU | ESS_DRQ_CTRL_EXT;
546: switch (sc->sc_audio1.drq) {
547: case 0:
548: v |= ESS_DRQ_CTRL_DRQA;
549: break;
550: case 1:
551: v |= ESS_DRQ_CTRL_DRQB;
552: break;
553: case 3:
554: v |= ESS_DRQ_CTRL_DRQC;
555: break;
556: #ifdef DIAGNOSTIC
557: default:
558: printf("ess_config_drq: configured dma chan %d not supported for Audio 1\n",
559: sc->sc_audio1.drq);
560: return;
561: #endif
562: }
563: /* Set DRQ1 */
564: ess_write_x_reg(sc, ESS_XCMD_DRQ_CTRL, v);
565:
566: if (ESS_USE_AUDIO1(sc->sc_model))
567: return;
568:
569: /* Configure DRQ2 */
570: v = ESS_AUDIO2_CTRL3_DRQ_PD;
571: switch (sc->sc_audio2.drq) {
572: case 0:
573: v |= ESS_AUDIO2_CTRL3_DRQA;
574: break;
575: case 1:
576: v |= ESS_AUDIO2_CTRL3_DRQB;
577: break;
578: case 3:
579: v |= ESS_AUDIO2_CTRL3_DRQC;
580: break;
581: case 5:
582: v |= ESS_AUDIO2_CTRL3_DRQD;
583: break;
584: #ifdef DIAGNOSTIC
585: default:
586: printf("ess_config_drq: configured dma chan %d not supported for Audio 2\n",
587: sc->sc_audio2.drq);
588: return;
589: #endif
590: }
591: ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL3, v);
592: /* Enable DMA 2 */
593: ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
594: ESS_AUDIO2_CTRL2_DMA_ENABLE);
595: }
596:
597: /*
598: * Set up registers after a reset.
599: */
600: void
601: ess_setup(sc)
602: struct ess_softc *sc;
603: {
604:
605: ess_config_irq(sc);
606: ess_config_drq(sc);
607:
608: DPRINTFN(2,("ess_setup: done\n"));
609: }
610:
611: /*
612: * Determine the model of ESS chip we are talking to. Currently we
613: * only support ES1888, ES1887 and ES888. The method of determining
614: * the chip is based on the information on page 27 of the ES1887 data
615: * sheet.
616: *
617: * This routine sets the values of sc->sc_model and sc->sc_version.
618: */
619: int
620: ess_identify(sc)
621: struct ess_softc *sc;
622: {
623: u_char reg1;
624: u_char reg2;
625: u_char reg3;
626: u_int8_t ident[4];
627:
628: sc->sc_model = ESS_UNSUPPORTED;
629: sc->sc_version = 0;
630:
631: memset(ident, 0, sizeof(ident));
632:
633: /*
634: * 1. Check legacy ID bytes. These should be 0x68 0x8n, where
635: * n >= 8 for an ES1887 or an ES888. Other values indicate
636: * earlier (unsupported) chips.
637: */
638: ess_wdsp(sc, ESS_ACMD_LEGACY_ID);
639:
640: if ((reg1 = ess_rdsp(sc)) != 0x68) {
641: printf("ess: First ID byte wrong (0x%02x)\n", reg1);
642: return 1;
643: }
644:
645: reg2 = ess_rdsp(sc);
646: if (((reg2 & 0xf0) != 0x80) ||
647: ((reg2 & 0x0f) < 8)) {
648: printf("ess: Second ID byte wrong (0x%02x)\n", reg2);
649: return 1;
650: }
651:
652: /*
653: * Store the ID bytes as the version.
654: */
655: sc->sc_version = (reg1 << 8) + reg2;
656:
657:
658: /*
659: * 2. Verify we can change bit 2 in mixer register 0x64. This
660: * should be possible on all supported chips.
661: */
662: reg1 = ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL);
663: reg2 = reg1 ^ 0x04; /* toggle bit 2 */
664:
665: ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg2);
666:
667: if (ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL) != reg2) {
668: printf("ess: Hardware error (unable to toggle bit 2 of mixer register 0x64)\n");
669: return 1;
670: }
671:
672: /*
673: * Restore the original value of mixer register 0x64.
674: */
675: ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg1);
676:
677:
678: /*
679: * 3. Verify we can change the value of mixer register
680: * ESS_MREG_SAMPLE_RATE.
681: * This is possible on the 1888/1887/888, but not on the 1788.
682: * It is not necessary to restore the value of this mixer register.
683: */
684: reg1 = ess_read_mix_reg(sc, ESS_MREG_SAMPLE_RATE);
685: reg2 = reg1 ^ 0xff; /* toggle all bits */
686:
687: ess_write_mix_reg(sc, ESS_MREG_SAMPLE_RATE, reg2);
688:
689: if (ess_read_mix_reg(sc, ESS_MREG_SAMPLE_RATE) != reg2) {
690: /* If we got this far before failing, it's a 1788. */
691: sc->sc_model = ESS_1788;
692:
693: /*
694: * Identify ESS model for ES18[67]8.
695: */
696: ess_read_multi_mix_reg(sc, 0x40, ident, sizeof(ident));
697: if(ident[0] == 0x18) {
698: switch(ident[1]) {
699: case 0x68:
700: sc->sc_model = ESS_1868;
701: break;
702: case 0x78:
703: sc->sc_model = ESS_1878;
704: break;
705: }
706: }
707: } else {
708: /*
709: * 4. Determine if we can change bit 5 in mixer register 0x64.
710: * This determines whether we have an ES1887:
711: *
712: * - can change indicates ES1887
713: * - can't change indicates ES1888 or ES888
714: */
715: reg1 = ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL);
716: reg2 = reg1 ^ 0x20; /* toggle bit 5 */
717:
718: ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg2);
719:
720: if (ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL) == reg2) {
721: sc->sc_model = ESS_1887;
722:
723: /*
724: * Restore the original value of mixer register 0x64.
725: */
726: ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg1);
727:
728: /*
729: * Identify ESS model for ES18[67]9.
730: */
731: ess_read_multi_mix_reg(sc, 0x40, ident, sizeof(ident));
732: if(ident[0] == 0x18) {
733: switch(ident[1]) {
734: case 0x69:
735: sc->sc_model = ESS_1869;
736: break;
737: case 0x79:
738: sc->sc_model = ESS_1879;
739: break;
740: }
741: }
742: } else {
743: /*
744: * 5. Determine if we can change the value of mixer
745: * register 0x69 independently of mixer register
746: * 0x68. This determines which chip we have:
747: *
748: * - can modify idependently indicates ES888
749: * - register 0x69 is an alias of 0x68 indicates ES1888
750: */
751: reg1 = ess_read_mix_reg(sc, 0x68);
752: reg2 = ess_read_mix_reg(sc, 0x69);
753: reg3 = reg2 ^ 0xff; /* toggle all bits */
754:
755: /*
756: * Write different values to each register.
757: */
758: ess_write_mix_reg(sc, 0x68, reg2);
759: ess_write_mix_reg(sc, 0x69, reg3);
760:
761: if (ess_read_mix_reg(sc, 0x68) == reg2 &&
762: ess_read_mix_reg(sc, 0x69) == reg3)
763: sc->sc_model = ESS_888;
764: else
765: sc->sc_model = ESS_1888;
766:
767: /*
768: * Restore the original value of the registers.
769: */
770: ess_write_mix_reg(sc, 0x68, reg1);
771: ess_write_mix_reg(sc, 0x69, reg2);
772: }
773: }
774:
775: return 0;
776: }
777:
778:
779: int
780: ess_setup_sc(sc, doinit)
781: struct ess_softc *sc;
782: int doinit;
783: {
784: /* Reset the chip. */
785: if (ess_reset(sc) != 0) {
786: DPRINTF(("ess_setup_sc: couldn't reset chip\n"));
787: return (1);
788: }
789:
790: /* Identify the ESS chip, and check that it is supported. */
791: if (ess_identify(sc)) {
792: DPRINTF(("ess_setup_sc: couldn't identify\n"));
793: return (1);
794: }
795:
796: return (0);
797: }
798:
799: /*
800: * Probe for the ESS hardware.
801: */
802: int
803: essmatch(sc)
804: struct ess_softc *sc;
805: {
806: if (!ESS_BASE_VALID(sc->sc_iobase)) {
807: printf("ess: configured iobase 0x%x invalid\n", sc->sc_iobase);
808: return (0);
809: }
810:
811: /* Configure the ESS chip for the desired audio base address. */
812: if (ess_config_addr(sc))
813: return (0);
814:
815: if (ess_setup_sc(sc, 1))
816: return (0);
817:
818: if (sc->sc_model == ESS_UNSUPPORTED) {
819: DPRINTF(("ess: Unsupported model\n"));
820: return (0);
821: }
822:
823: /* Check that requested DMA channels are valid and different. */
824: if (!ESS_DRQ1_VALID(sc->sc_audio1.drq)) {
825: printf("ess: record drq %d invalid\n", sc->sc_audio1.drq);
826: return (0);
827: }
828: if (!isa_drq_isfree(sc->sc_isa, sc->sc_audio1.drq))
829: return (0);
830: if (!ESS_USE_AUDIO1(sc->sc_model)) {
831: if (!ESS_DRQ2_VALID(sc->sc_audio2.drq)) {
832: printf("ess: play drq %d invalid\n", sc->sc_audio2.drq);
833: return (0);
834: }
835: if (sc->sc_audio1.drq == sc->sc_audio2.drq) {
836: printf("ess: play and record drq both %d\n",
837: sc->sc_audio1.drq);
838: return (0);
839: }
840: if (!isa_drq_isfree(sc->sc_isa, sc->sc_audio2.drq))
841: return (0);
842: }
843:
844: /*
845: * The 1887 has an additional IRQ mode where both channels are mapped
846: * to the same IRQ.
847: */
848: if (sc->sc_model == ESS_1887 &&
849: sc->sc_audio1.irq == sc->sc_audio2.irq &&
850: sc->sc_audio1.irq != -1 &&
851: ESS_IRQ12_VALID(sc->sc_audio1.irq))
852: goto irq_not1888;
853:
854: /* Check that requested IRQ lines are valid and different. */
855: if (sc->sc_audio1.irq != -1 &&
856: !ESS_IRQ1_VALID(sc->sc_audio1.irq)) {
857: printf("ess: record irq %d invalid\n", sc->sc_audio1.irq);
858: return (0);
859: }
860: if (!ESS_USE_AUDIO1(sc->sc_model)) {
861: if (sc->sc_audio2.irq != -1 &&
862: !ESS_IRQ2_VALID(sc->sc_audio2.irq)) {
863: printf("ess: play irq %d invalid\n", sc->sc_audio2.irq);
864: return (0);
865: }
866: if (sc->sc_audio1.irq == sc->sc_audio2.irq &&
867: sc->sc_audio1.irq != -1) {
868: printf("ess: play and record irq both %d\n",
869: sc->sc_audio1.irq);
870: return (0);
871: }
872: }
873:
874: irq_not1888:
875: /* XXX should we check IRQs as well? */
876:
877: return (1);
878: }
879:
880:
881: /*
882: * Attach hardware to driver, attach hardware driver to audio
883: * pseudo-device driver.
884: */
885: void
886: essattach(sc)
887: struct ess_softc *sc;
888: {
889: struct audio_attach_args arg;
890: struct audio_params pparams, rparams;
891: int i;
892: u_int v;
893:
894: if (ess_setup_sc(sc, 0)) {
895: printf(": setup failed\n");
896: return;
897: }
898:
899: printf(": ESS Technology ES%s [version 0x%04x]\n",
900: essmodel[sc->sc_model], sc->sc_version);
901:
902: sc->sc_audio1.polled = sc->sc_audio1.irq == -1;
903: if (!sc->sc_audio1.polled) {
904: sc->sc_audio1.ih = isa_intr_establish(sc->sc_ic,
905: sc->sc_audio1.irq, sc->sc_audio1.ist, IPL_AUDIO,
906: ess_audio1_intr, sc, sc->sc_dev.dv_xname);
907: printf("%s: audio1 interrupting at irq %d\n",
908: sc->sc_dev.dv_xname, sc->sc_audio1.irq);
909: } else
910: printf("%s: audio1 polled\n", sc->sc_dev.dv_xname);
911: if (isa_dmamap_create(sc->sc_isa, sc->sc_audio1.drq,
912: MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
913: printf("%s: can't create map for drq %d\n",
914: sc->sc_dev.dv_xname, sc->sc_audio1.drq);
915: return;
916: }
917:
918: if (!ESS_USE_AUDIO1(sc->sc_model)) {
919: sc->sc_audio2.polled = sc->sc_audio2.irq == -1;
920: if (!sc->sc_audio2.polled) {
921: sc->sc_audio2.ih = isa_intr_establish(sc->sc_ic,
922: sc->sc_audio2.irq, sc->sc_audio2.ist, IPL_AUDIO,
923: ess_audio2_intr, sc, sc->sc_dev.dv_xname);
924: printf("%s: audio2 interrupting at irq %d\n",
925: sc->sc_dev.dv_xname, sc->sc_audio2.irq);
926: } else
927: printf("%s: audio2 polled\n", sc->sc_dev.dv_xname);
928: if (isa_dmamap_create(sc->sc_isa, sc->sc_audio2.drq,
929: MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
930: printf("%s: can't create map for drq %d\n",
931: sc->sc_dev.dv_xname, sc->sc_audio2.drq);
932: return;
933: }
934: }
935:
936: timeout_set(&sc->sc_tmo1, ess_audio1_poll, sc);
937: timeout_set(&sc->sc_tmo2, ess_audio2_poll, sc);
938:
939: /*
940: * Set record and play parameters to default values defined in
941: * generic audio driver.
942: */
943: pparams = audio_default;
944: rparams = audio_default;
945: ess_set_params(sc, AUMODE_RECORD|AUMODE_PLAY, 0, &pparams, &rparams);
946:
947: /* Do a hardware reset on the mixer. */
948: ess_write_mix_reg(sc, ESS_MIX_RESET, ESS_MIX_RESET);
949:
950: /*
951: * Set volume of Audio 1 to zero and disable Audio 1 DAC input
952: * to playback mixer, since playback is always through Audio 2.
953: */
954: if (!ESS_USE_AUDIO1(sc->sc_model))
955: ess_write_mix_reg(sc, ESS_MREG_VOLUME_VOICE, 0);
956: ess_wdsp(sc, ESS_ACMD_DISABLE_SPKR);
957:
958: if (ESS_USE_AUDIO1(sc->sc_model)) {
959: ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ESS_SOURCE_MIC);
960: sc->in_port = ESS_SOURCE_MIC;
961: sc->ndevs = ESS_1788_NDEVS;
962: } else {
963: /*
964: * Set hardware record source to use output of the record
965: * mixer. We do the selection of record source in software by
966: * setting the gain of the unused sources to zero. (See
967: * ess_set_in_ports.)
968: */
969: ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ESS_SOURCE_MIXER);
970: sc->in_mask = 1 << ESS_MIC_REC_VOL;
971: sc->ndevs = ESS_1888_NDEVS;
972: ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2, 0x10);
973: ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2, 0x08);
974: }
975:
976: /*
977: * Set gain on each mixer device to a sensible value.
978: * Devices not normally used are turned off, and other devices
979: * are set to 50% volume.
980: */
981: for (i = 0; i < sc->ndevs; i++) {
982: switch (i) {
983: case ESS_MIC_PLAY_VOL:
984: case ESS_LINE_PLAY_VOL:
985: case ESS_CD_PLAY_VOL:
986: case ESS_AUXB_PLAY_VOL:
987: case ESS_DAC_REC_VOL:
988: case ESS_LINE_REC_VOL:
989: case ESS_SYNTH_REC_VOL:
990: case ESS_CD_REC_VOL:
991: case ESS_AUXB_REC_VOL:
992: v = 0;
993: break;
994: default:
995: v = ESS_4BIT_GAIN(AUDIO_MAX_GAIN / 2);
996: break;
997: }
998: sc->gain[i][ESS_LEFT] = sc->gain[i][ESS_RIGHT] = v;
999: ess_set_gain(sc, i, 1);
1000: }
1001:
1002: ess_setup(sc);
1003:
1004: /* Disable the speaker until the device is opened. */
1005: ess_speaker_off(sc);
1006: sc->spkr_state = SPKR_OFF;
1007:
1008: snprintf(ess_device.name, sizeof ess_device.name, "ES%s",
1009: essmodel[sc->sc_model]);
1010: snprintf(ess_device.version, sizeof ess_device.version, "0x%04x",
1011: sc->sc_version);
1012:
1013: if (ESS_USE_AUDIO1(sc->sc_model))
1014: audio_attach_mi(&ess_1788_hw_if, sc, &sc->sc_dev);
1015: else
1016: audio_attach_mi(&ess_1888_hw_if, sc, &sc->sc_dev);
1017:
1018: arg.type = AUDIODEV_TYPE_OPL;
1019: arg.hwif = 0;
1020: arg.hdl = 0;
1021: (void)config_found(&sc->sc_dev, &arg, audioprint);
1022:
1023: #ifdef AUDIO_DEBUG
1024: if (essdebug > 0)
1025: ess_printsc(sc);
1026: #endif
1027: }
1028:
1029: /*
1030: * Various routines to interface to higher level audio driver
1031: */
1032:
1033: int
1034: ess_open(addr, flags)
1035: void *addr;
1036: int flags;
1037: {
1038: struct ess_softc *sc = addr;
1039:
1040: DPRINTF(("ess_open: sc=%p\n", sc));
1041:
1042: if (sc->sc_open != 0 || ess_reset(sc) != 0)
1043: return ENXIO;
1044:
1045: ess_setup(sc); /* because we did a reset */
1046:
1047: sc->sc_open = 1;
1048:
1049: DPRINTF(("ess_open: opened\n"));
1050:
1051: return (0);
1052: }
1053:
1054: void
1055: ess_1788_close(addr)
1056: void *addr;
1057: {
1058: struct ess_softc *sc = addr;
1059:
1060: DPRINTF(("ess_1788_close: sc=%p\n", sc));
1061:
1062: ess_speaker_off(sc);
1063: sc->spkr_state = SPKR_OFF;
1064:
1065: ess_audio1_halt(sc);
1066:
1067: sc->sc_open = 0;
1068: DPRINTF(("ess_1788_close: closed\n"));
1069: }
1070:
1071: void
1072: ess_1888_close(addr)
1073: void *addr;
1074: {
1075: struct ess_softc *sc = addr;
1076:
1077: DPRINTF(("ess_1888_close: sc=%p\n", sc));
1078:
1079: ess_speaker_off(sc);
1080: sc->spkr_state = SPKR_OFF;
1081:
1082: ess_audio1_halt(sc);
1083: ess_audio2_halt(sc);
1084:
1085: sc->sc_open = 0;
1086: DPRINTF(("ess_1888_close: closed\n"));
1087: }
1088:
1089: /*
1090: * Wait for FIFO to drain, and analog section to settle.
1091: * XXX should check FIFO empty bit.
1092: */
1093: int
1094: ess_drain(addr)
1095: void *addr;
1096: {
1097: tsleep(addr, PWAIT | PCATCH, "essdr", hz/20); /* XXX */
1098: return (0);
1099: }
1100:
1101: /* XXX should use reference count */
1102: int
1103: ess_speaker_ctl(addr, newstate)
1104: void *addr;
1105: int newstate;
1106: {
1107: struct ess_softc *sc = addr;
1108:
1109: if ((newstate == SPKR_ON) && (sc->spkr_state == SPKR_OFF)) {
1110: ess_speaker_on(sc);
1111: sc->spkr_state = SPKR_ON;
1112: }
1113: if ((newstate == SPKR_OFF) && (sc->spkr_state == SPKR_ON)) {
1114: ess_speaker_off(sc);
1115: sc->spkr_state = SPKR_OFF;
1116: }
1117: return (0);
1118: }
1119:
1120: int
1121: ess_getdev(addr, retp)
1122: void *addr;
1123: struct audio_device *retp;
1124: {
1125: *retp = ess_device;
1126: return (0);
1127: }
1128:
1129: int
1130: ess_query_encoding(addr, fp)
1131: void *addr;
1132: struct audio_encoding *fp;
1133: {
1134: /*struct ess_softc *sc = addr;*/
1135:
1136: switch (fp->index) {
1137: case 0:
1138: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
1139: fp->encoding = AUDIO_ENCODING_ULINEAR;
1140: fp->precision = 8;
1141: fp->flags = 0;
1142: return (0);
1143: case 1:
1144: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
1145: fp->encoding = AUDIO_ENCODING_ULAW;
1146: fp->precision = 8;
1147: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
1148: return (0);
1149: case 2:
1150: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
1151: fp->encoding = AUDIO_ENCODING_ALAW;
1152: fp->precision = 8;
1153: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
1154: return (0);
1155: case 3:
1156: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
1157: fp->encoding = AUDIO_ENCODING_SLINEAR;
1158: fp->precision = 8;
1159: fp->flags = 0;
1160: return (0);
1161: case 4:
1162: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
1163: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
1164: fp->precision = 16;
1165: fp->flags = 0;
1166: return (0);
1167: case 5:
1168: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
1169: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
1170: fp->precision = 16;
1171: fp->flags = 0;
1172: return (0);
1173: case 6:
1174: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
1175: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
1176: fp->precision = 16;
1177: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
1178: return (0);
1179: case 7:
1180: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
1181: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
1182: fp->precision = 16;
1183: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
1184: return (0);
1185: default:
1186: return EINVAL;
1187: }
1188: return (0);
1189: }
1190:
1191: int
1192: ess_set_params(addr, setmode, usemode, play, rec)
1193: void *addr;
1194: int setmode, usemode;
1195: struct audio_params *play, *rec;
1196: {
1197: struct ess_softc *sc = addr;
1198: struct audio_params *p;
1199: int mode;
1200: int rate;
1201:
1202: DPRINTF(("ess_set_params: set=%d use=%d\n", setmode, usemode));
1203:
1204: /*
1205: * The ES1887 manual (page 39, `Full-Duplex DMA Mode') claims that in
1206: * full-duplex operation the sample rates must be the same for both
1207: * channels. This appears to be false; the only bit in common is the
1208: * clock source selection. However, we'll be conservative here.
1209: * - mycroft
1210: */
1211: if (play->sample_rate != rec->sample_rate &&
1212: usemode == (AUMODE_PLAY | AUMODE_RECORD)) {
1213: if (setmode == AUMODE_PLAY) {
1214: rec->sample_rate = play->sample_rate;
1215: setmode |= AUMODE_RECORD;
1216: } else if (setmode == AUMODE_RECORD) {
1217: play->sample_rate = rec->sample_rate;
1218: setmode |= AUMODE_PLAY;
1219: } else
1220: return (EINVAL);
1221: }
1222:
1223: for (mode = AUMODE_RECORD; mode != -1;
1224: mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
1225: if ((setmode & mode) == 0)
1226: continue;
1227:
1228: p = mode == AUMODE_PLAY ? play : rec;
1229:
1230: if (p->sample_rate < ESS_MINRATE ||
1231: p->sample_rate > ESS_MAXRATE ||
1232: (p->precision != 8 && p->precision != 16) ||
1233: (p->channels != 1 && p->channels != 2))
1234: return (EINVAL);
1235:
1236: p->factor = 1;
1237: p->sw_code = 0;
1238: switch (p->encoding) {
1239: case AUDIO_ENCODING_SLINEAR_BE:
1240: case AUDIO_ENCODING_ULINEAR_BE:
1241: if (p->precision == 16)
1242: p->sw_code = swap_bytes;
1243: break;
1244: case AUDIO_ENCODING_SLINEAR_LE:
1245: case AUDIO_ENCODING_ULINEAR_LE:
1246: break;
1247: case AUDIO_ENCODING_ULAW:
1248: if (mode == AUMODE_PLAY) {
1249: p->factor = 2;
1250: p->sw_code = mulaw_to_ulinear16;
1251: } else
1252: p->sw_code = ulinear8_to_mulaw;
1253: break;
1254: case AUDIO_ENCODING_ALAW:
1255: if (mode == AUMODE_PLAY) {
1256: p->factor = 2;
1257: p->sw_code = alaw_to_ulinear16;
1258: } else
1259: p->sw_code = ulinear8_to_alaw;
1260: break;
1261: default:
1262: return (EINVAL);
1263: }
1264: }
1265:
1266: if (usemode == AUMODE_RECORD)
1267: rate = rec->sample_rate;
1268: else
1269: rate = play->sample_rate;
1270:
1271: ess_write_x_reg(sc, ESS_XCMD_SAMPLE_RATE, ess_srtotc(rate));
1272: ess_write_x_reg(sc, ESS_XCMD_FILTER_CLOCK, ess_srtofc(rate));
1273:
1274: if (!ESS_USE_AUDIO1(sc->sc_model)) {
1275: ess_write_mix_reg(sc, ESS_MREG_SAMPLE_RATE, ess_srtotc(rate));
1276: ess_write_mix_reg(sc, ESS_MREG_FILTER_CLOCK, ess_srtofc(rate));
1277: }
1278:
1279: return (0);
1280: }
1281:
1282: int
1283: ess_audio1_trigger_output(addr, start, end, blksize, intr, arg, param)
1284: void *addr;
1285: void *start, *end;
1286: int blksize;
1287: void (*intr)(void *);
1288: void *arg;
1289: struct audio_params *param;
1290: {
1291: struct ess_softc *sc = addr;
1292: u_int8_t reg;
1293:
1294: DPRINTFN(1, ("ess_audio1_trigger_output: sc=%p start=%p end=%p blksize=%d intr=%p(%p)\n",
1295: addr, start, end, blksize, intr, arg));
1296:
1297: if (sc->sc_audio1.active)
1298: panic("ess_audio1_trigger_output: already running");
1299:
1300: sc->sc_audio1.active = 1;
1301: sc->sc_audio1.intr = intr;
1302: sc->sc_audio1.arg = arg;
1303: if (sc->sc_audio1.polled) {
1304: sc->sc_audio1.dmapos = 0;
1305: sc->sc_audio1.buffersize = (char *)end - (char *)start;
1306: sc->sc_audio1.dmacount = 0;
1307: sc->sc_audio1.blksize = blksize;
1308: timeout_add(&sc->sc_tmo1, hz/30);
1309: }
1310:
1311: reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL);
1312: if (param->channels == 2) {
1313: reg &= ~ESS_AUDIO_CTRL_MONO;
1314: reg |= ESS_AUDIO_CTRL_STEREO;
1315: } else {
1316: reg |= ESS_AUDIO_CTRL_MONO;
1317: reg &= ~ESS_AUDIO_CTRL_STEREO;
1318: }
1319: ess_write_x_reg(sc, ESS_XCMD_AUDIO_CTRL, reg);
1320:
1321: reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1);
1322: if (param->precision * param->factor == 16)
1323: reg |= ESS_AUDIO1_CTRL1_FIFO_SIZE;
1324: else
1325: reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIZE;
1326: if (param->channels == 2)
1327: reg |= ESS_AUDIO1_CTRL1_FIFO_STEREO;
1328: else
1329: reg &= ~ESS_AUDIO1_CTRL1_FIFO_STEREO;
1330: if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
1331: param->encoding == AUDIO_ENCODING_SLINEAR_LE)
1332: reg |= ESS_AUDIO1_CTRL1_FIFO_SIGNED;
1333: else
1334: reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIGNED;
1335: reg |= ESS_AUDIO1_CTRL1_FIFO_CONNECT;
1336: ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);
1337:
1338: isa_dmastart(sc->sc_isa, sc->sc_audio1.drq, start,
1339: (char *)end - (char *)start, NULL,
1340: DMAMODE_WRITE | DMAMODE_LOOP, BUS_DMA_NOWAIT);
1341:
1342: /* Program transfer count registers with 2's complement of count. */
1343: blksize = -blksize;
1344: ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTLO, blksize);
1345: ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTHI, blksize >> 8);
1346:
1347: /* Use 4 bytes per output DMA. */
1348: ess_set_xreg_bits(sc, ESS_XCMD_DEMAND_CTRL, ESS_DEMAND_CTRL_DEMAND_4);
1349:
1350: /* Start auto-init DMA */
1351: ess_wdsp(sc, ESS_ACMD_ENABLE_SPKR);
1352: reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2);
1353: reg &= ~(ESS_AUDIO1_CTRL2_DMA_READ | ESS_AUDIO1_CTRL2_ADC_ENABLE);
1354: reg |= ESS_AUDIO1_CTRL2_FIFO_ENABLE | ESS_AUDIO1_CTRL2_AUTO_INIT;
1355: ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2, reg);
1356:
1357: return (0);
1358: }
1359:
1360: int
1361: ess_audio2_trigger_output(addr, start, end, blksize, intr, arg, param)
1362: void *addr;
1363: void *start, *end;
1364: int blksize;
1365: void (*intr)(void *);
1366: void *arg;
1367: struct audio_params *param;
1368: {
1369: struct ess_softc *sc = addr;
1370: u_int8_t reg;
1371:
1372: DPRINTFN(1, ("ess_audio2_trigger_output: sc=%p start=%p end=%p blksize=%d intr=%p(%p)\n",
1373: addr, start, end, blksize, intr, arg));
1374:
1375: if (sc->sc_audio2.active)
1376: panic("ess_audio2_trigger_output: already running");
1377:
1378: sc->sc_audio2.active = 1;
1379: sc->sc_audio2.intr = intr;
1380: sc->sc_audio2.arg = arg;
1381: if (sc->sc_audio2.polled) {
1382: sc->sc_audio2.dmapos = 0;
1383: sc->sc_audio2.buffersize = (char *)end - (char *)start;
1384: sc->sc_audio2.dmacount = 0;
1385: sc->sc_audio2.blksize = blksize;
1386: timeout_add(&sc->sc_tmo2, hz/30);
1387: }
1388:
1389: reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2);
1390: if (param->precision * param->factor == 16)
1391: reg |= ESS_AUDIO2_CTRL2_FIFO_SIZE;
1392: else
1393: reg &= ~ESS_AUDIO2_CTRL2_FIFO_SIZE;
1394: if (param->channels == 2)
1395: reg |= ESS_AUDIO2_CTRL2_CHANNELS;
1396: else
1397: reg &= ~ESS_AUDIO2_CTRL2_CHANNELS;
1398: if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
1399: param->encoding == AUDIO_ENCODING_SLINEAR_LE)
1400: reg |= ESS_AUDIO2_CTRL2_FIFO_SIGNED;
1401: else
1402: reg &= ~ESS_AUDIO2_CTRL2_FIFO_SIGNED;
1403: ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2, reg);
1404:
1405: isa_dmastart(sc->sc_isa, sc->sc_audio2.drq, start,
1406: (char *)end - (char *)start, NULL,
1407: DMAMODE_WRITE | DMAMODE_LOOP, BUS_DMA_NOWAIT);
1408:
1409: if (IS16BITDRQ(sc->sc_audio2.drq))
1410: blksize >>= 1; /* use word count for 16 bit DMA */
1411: /* Program transfer count registers with 2's complement of count. */
1412: blksize = -blksize;
1413: ess_write_mix_reg(sc, ESS_MREG_XFER_COUNTLO, blksize);
1414: ess_write_mix_reg(sc, ESS_MREG_XFER_COUNTHI, blksize >> 8);
1415:
1416: reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL1);
1417: if (IS16BITDRQ(sc->sc_audio2.drq))
1418: reg |= ESS_AUDIO2_CTRL1_XFER_SIZE;
1419: else
1420: reg &= ~ESS_AUDIO2_CTRL1_XFER_SIZE;
1421: reg |= ESS_AUDIO2_CTRL1_DEMAND_8;
1422: reg |= ESS_AUDIO2_CTRL1_DAC_ENABLE | ESS_AUDIO2_CTRL1_FIFO_ENABLE |
1423: ESS_AUDIO2_CTRL1_AUTO_INIT;
1424: ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL1, reg);
1425:
1426: return (0);
1427: }
1428:
1429: int
1430: ess_audio1_trigger_input(addr, start, end, blksize, intr, arg, param)
1431: void *addr;
1432: void *start, *end;
1433: int blksize;
1434: void (*intr)(void *);
1435: void *arg;
1436: struct audio_params *param;
1437: {
1438: struct ess_softc *sc = addr;
1439: u_int8_t reg;
1440:
1441: DPRINTFN(1, ("ess_audio1_trigger_input: sc=%p start=%p end=%p blksize=%d intr=%p(%p)\n",
1442: addr, start, end, blksize, intr, arg));
1443:
1444: if (sc->sc_audio1.active)
1445: panic("ess_audio1_trigger_input: already running");
1446:
1447: sc->sc_audio1.active = 1;
1448: sc->sc_audio1.intr = intr;
1449: sc->sc_audio1.arg = arg;
1450: if (sc->sc_audio1.polled) {
1451: sc->sc_audio1.dmapos = 0;
1452: sc->sc_audio1.buffersize = (char *)end - (char *)start;
1453: sc->sc_audio1.dmacount = 0;
1454: sc->sc_audio1.blksize = blksize;
1455: timeout_add(&sc->sc_tmo1, hz/30);
1456: }
1457:
1458: reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL);
1459: if (param->channels == 2) {
1460: reg &= ~ESS_AUDIO_CTRL_MONO;
1461: reg |= ESS_AUDIO_CTRL_STEREO;
1462: } else {
1463: reg |= ESS_AUDIO_CTRL_MONO;
1464: reg &= ~ESS_AUDIO_CTRL_STEREO;
1465: }
1466: ess_write_x_reg(sc, ESS_XCMD_AUDIO_CTRL, reg);
1467:
1468: reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1);
1469: if (param->precision * param->factor == 16)
1470: reg |= ESS_AUDIO1_CTRL1_FIFO_SIZE;
1471: else
1472: reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIZE;
1473: if (param->channels == 2)
1474: reg |= ESS_AUDIO1_CTRL1_FIFO_STEREO;
1475: else
1476: reg &= ~ESS_AUDIO1_CTRL1_FIFO_STEREO;
1477: if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
1478: param->encoding == AUDIO_ENCODING_SLINEAR_LE)
1479: reg |= ESS_AUDIO1_CTRL1_FIFO_SIGNED;
1480: else
1481: reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIGNED;
1482: reg |= ESS_AUDIO1_CTRL1_FIFO_CONNECT;
1483: ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);
1484:
1485: isa_dmastart(sc->sc_isa, sc->sc_audio1.drq, start,
1486: (char *)end - (char *)start, NULL,
1487: DMAMODE_READ | DMAMODE_LOOP, BUS_DMA_NOWAIT);
1488:
1489: /* Program transfer count registers with 2's complement of count. */
1490: blksize = -blksize;
1491: ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTLO, blksize);
1492: ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTHI, blksize >> 8);
1493:
1494: /* Use 4 bytes per input DMA. */
1495: ess_set_xreg_bits(sc, ESS_XCMD_DEMAND_CTRL, ESS_DEMAND_CTRL_DEMAND_4);
1496:
1497: /* Start auto-init DMA */
1498: ess_wdsp(sc, ESS_ACMD_DISABLE_SPKR);
1499: reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2);
1500: reg |= ESS_AUDIO1_CTRL2_DMA_READ | ESS_AUDIO1_CTRL2_ADC_ENABLE;
1501: reg |= ESS_AUDIO1_CTRL2_FIFO_ENABLE | ESS_AUDIO1_CTRL2_AUTO_INIT;
1502: ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2, reg);
1503:
1504: return (0);
1505: }
1506:
1507: int
1508: ess_audio1_halt(addr)
1509: void *addr;
1510: {
1511: struct ess_softc *sc = addr;
1512:
1513: DPRINTF(("ess_audio1_halt: sc=%p\n", sc));
1514:
1515: if (sc->sc_audio1.active) {
1516: ess_clear_xreg_bits(sc, ESS_XCMD_AUDIO1_CTRL2,
1517: ESS_AUDIO1_CTRL2_FIFO_ENABLE);
1518: isa_dmaabort(sc->sc_isa, sc->sc_audio1.drq);
1519: if (sc->sc_audio1.polled)
1520: timeout_del(&sc->sc_tmo1);
1521: sc->sc_audio1.active = 0;
1522: }
1523:
1524: return (0);
1525: }
1526:
1527: int
1528: ess_audio2_halt(addr)
1529: void *addr;
1530: {
1531: struct ess_softc *sc = addr;
1532:
1533: DPRINTF(("ess_audio2_halt: sc=%p\n", sc));
1534:
1535: if (sc->sc_audio2.active) {
1536: ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL1,
1537: ESS_AUDIO2_CTRL1_DAC_ENABLE |
1538: ESS_AUDIO2_CTRL1_FIFO_ENABLE);
1539: isa_dmaabort(sc->sc_isa, sc->sc_audio2.drq);
1540: if (sc->sc_audio2.polled)
1541: timeout_del(&sc->sc_tmo2);
1542: sc->sc_audio2.active = 0;
1543: }
1544:
1545: return (0);
1546: }
1547:
1548: int
1549: ess_audio1_intr(arg)
1550: void *arg;
1551: {
1552: struct ess_softc *sc = arg;
1553: u_int8_t reg;
1554:
1555: DPRINTFN(1,("ess_audio1_intr: intr=%p\n", sc->sc_audio1.intr));
1556:
1557: /* Check and clear interrupt on Audio1. */
1558: reg = EREAD1(sc->sc_iot, sc->sc_ioh, ESS_DSP_RW_STATUS);
1559: if ((reg & ESS_DSP_READ_OFLOW) == 0)
1560: return (0);
1561: reg = EREAD1(sc->sc_iot, sc->sc_ioh, ESS_CLEAR_INTR);
1562:
1563: sc->sc_audio1.nintr++;
1564:
1565: if (sc->sc_audio1.active) {
1566: (*sc->sc_audio1.intr)(sc->sc_audio1.arg);
1567: return (1);
1568: } else
1569: return (0);
1570: }
1571:
1572: int
1573: ess_audio2_intr(arg)
1574: void *arg;
1575: {
1576: struct ess_softc *sc = arg;
1577: u_int8_t reg;
1578:
1579: DPRINTFN(1,("ess_audio2_intr: intr=%p\n", sc->sc_audio2.intr));
1580:
1581: /* Check and clear interrupt on Audio2. */
1582: reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2);
1583: if ((reg & ESS_AUDIO2_CTRL2_IRQ_LATCH) == 0)
1584: return (0);
1585: reg &= ~ESS_AUDIO2_CTRL2_IRQ_LATCH;
1586: ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2, reg);
1587:
1588: sc->sc_audio2.nintr++;
1589:
1590: if (sc->sc_audio2.active) {
1591: (*sc->sc_audio2.intr)(sc->sc_audio2.arg);
1592: return (1);
1593: } else
1594: return (0);
1595: }
1596:
1597: void
1598: ess_audio1_poll(addr)
1599: void *addr;
1600: {
1601: struct ess_softc *sc = addr;
1602: int dmapos, dmacount;
1603:
1604: if (!sc->sc_audio1.active)
1605: return;
1606:
1607: sc->sc_audio1.nintr++;
1608:
1609: dmapos = isa_dmacount(sc->sc_isa, sc->sc_audio1.drq);
1610: dmacount = sc->sc_audio1.dmapos - dmapos;
1611: if (dmacount < 0)
1612: dmacount += sc->sc_audio1.buffersize;
1613: sc->sc_audio1.dmapos = dmapos;
1614: #if 1
1615: dmacount += sc->sc_audio1.dmacount;
1616: while (dmacount > sc->sc_audio1.blksize) {
1617: dmacount -= sc->sc_audio1.blksize;
1618: (*sc->sc_audio1.intr)(sc->sc_audio1.arg);
1619: }
1620: sc->sc_audio1.dmacount = dmacount;
1621: #else
1622: (*sc->sc_audio1.intr)(sc->sc_audio1.arg, dmacount);
1623: #endif
1624:
1625: timeout_add(&sc->sc_tmo1, hz/30);
1626: }
1627:
1628: void
1629: ess_audio2_poll(addr)
1630: void *addr;
1631: {
1632: struct ess_softc *sc = addr;
1633: int dmapos, dmacount;
1634:
1635: if (!sc->sc_audio2.active)
1636: return;
1637:
1638: sc->sc_audio2.nintr++;
1639:
1640: dmapos = isa_dmacount(sc->sc_isa, sc->sc_audio2.drq);
1641: dmacount = sc->sc_audio2.dmapos - dmapos;
1642: if (dmacount < 0)
1643: dmacount += sc->sc_audio2.buffersize;
1644: sc->sc_audio2.dmapos = dmapos;
1645: #if 1
1646: dmacount += sc->sc_audio2.dmacount;
1647: while (dmacount > sc->sc_audio2.blksize) {
1648: dmacount -= sc->sc_audio2.blksize;
1649: (*sc->sc_audio2.intr)(sc->sc_audio2.arg);
1650: }
1651: sc->sc_audio2.dmacount = dmacount;
1652: #else
1653: (*sc->sc_audio2.intr)(sc->sc_audio2.arg, dmacount);
1654: #endif
1655:
1656: timeout_add(&sc->sc_tmo2, hz/30);
1657: }
1658:
1659: int
1660: ess_round_blocksize(addr, blk)
1661: void *addr;
1662: int blk;
1663: {
1664: return ((blk + 7) & -8); /* round for max DMA size */
1665: }
1666:
1667: int
1668: ess_set_port(addr, cp)
1669: void *addr;
1670: mixer_ctrl_t *cp;
1671: {
1672: struct ess_softc *sc = addr;
1673: int lgain, rgain;
1674:
1675: DPRINTFN(5,("ess_set_port: port=%d num_channels=%d\n",
1676: cp->dev, cp->un.value.num_channels));
1677:
1678: switch (cp->dev) {
1679: /*
1680: * The following mixer ports are all stereo. If we get a
1681: * single-channel gain value passed in, then we duplicate it
1682: * to both left and right channels.
1683: */
1684: case ESS_MASTER_VOL:
1685: case ESS_DAC_PLAY_VOL:
1686: case ESS_MIC_PLAY_VOL:
1687: case ESS_LINE_PLAY_VOL:
1688: case ESS_SYNTH_PLAY_VOL:
1689: case ESS_CD_PLAY_VOL:
1690: case ESS_AUXB_PLAY_VOL:
1691: case ESS_RECORD_VOL:
1692: if (cp->type != AUDIO_MIXER_VALUE)
1693: return EINVAL;
1694:
1695: switch (cp->un.value.num_channels) {
1696: case 1:
1697: lgain = rgain = ESS_4BIT_GAIN(
1698: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
1699: break;
1700: case 2:
1701: lgain = ESS_4BIT_GAIN(
1702: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
1703: rgain = ESS_4BIT_GAIN(
1704: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
1705: break;
1706: default:
1707: return EINVAL;
1708: }
1709:
1710: sc->gain[cp->dev][ESS_LEFT] = lgain;
1711: sc->gain[cp->dev][ESS_RIGHT] = rgain;
1712: ess_set_gain(sc, cp->dev, 1);
1713: return (0);
1714:
1715: /*
1716: * The PC speaker port is mono. If we get a stereo gain value
1717: * passed in, then we return EINVAL.
1718: */
1719: case ESS_PCSPEAKER_VOL:
1720: if (cp->un.value.num_channels != 1)
1721: return EINVAL;
1722:
1723: sc->gain[cp->dev][ESS_LEFT] = sc->gain[cp->dev][ESS_RIGHT] =
1724: ESS_3BIT_GAIN(cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
1725: ess_set_gain(sc, cp->dev, 1);
1726: return (0);
1727:
1728: case ESS_RECORD_SOURCE:
1729: if (ESS_USE_AUDIO1(sc->sc_model)) {
1730: if (cp->type == AUDIO_MIXER_ENUM)
1731: return (ess_set_in_port(sc, cp->un.ord));
1732: else
1733: return (EINVAL);
1734: } else {
1735: if (cp->type == AUDIO_MIXER_SET)
1736: return (ess_set_in_ports(sc, cp->un.mask));
1737: else
1738: return (EINVAL);
1739: }
1740: return (0);
1741:
1742: case ESS_RECORD_MONITOR:
1743: if (cp->type != AUDIO_MIXER_ENUM)
1744: return EINVAL;
1745:
1746: if (cp->un.ord)
1747: /* Enable monitor */
1748: ess_set_xreg_bits(sc, ESS_XCMD_AUDIO_CTRL,
1749: ESS_AUDIO_CTRL_MONITOR);
1750: else
1751: /* Disable monitor */
1752: ess_clear_xreg_bits(sc, ESS_XCMD_AUDIO_CTRL,
1753: ESS_AUDIO_CTRL_MONITOR);
1754: return (0);
1755: }
1756:
1757: if (ESS_USE_AUDIO1(sc->sc_model))
1758: return (EINVAL);
1759:
1760: switch (cp->dev) {
1761: case ESS_DAC_REC_VOL:
1762: case ESS_MIC_REC_VOL:
1763: case ESS_LINE_REC_VOL:
1764: case ESS_SYNTH_REC_VOL:
1765: case ESS_CD_REC_VOL:
1766: case ESS_AUXB_REC_VOL:
1767: if (cp->type != AUDIO_MIXER_VALUE)
1768: return EINVAL;
1769:
1770: switch (cp->un.value.num_channels) {
1771: case 1:
1772: lgain = rgain = ESS_4BIT_GAIN(
1773: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
1774: break;
1775: case 2:
1776: lgain = ESS_4BIT_GAIN(
1777: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
1778: rgain = ESS_4BIT_GAIN(
1779: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
1780: break;
1781: default:
1782: return EINVAL;
1783: }
1784:
1785: sc->gain[cp->dev][ESS_LEFT] = lgain;
1786: sc->gain[cp->dev][ESS_RIGHT] = rgain;
1787: ess_set_gain(sc, cp->dev, 1);
1788: return (0);
1789:
1790: case ESS_MIC_PREAMP:
1791: if (cp->type != AUDIO_MIXER_ENUM)
1792: return EINVAL;
1793:
1794: if (cp->un.ord)
1795: /* Enable microphone preamp */
1796: ess_set_xreg_bits(sc, ESS_XCMD_PREAMP_CTRL,
1797: ESS_PREAMP_CTRL_ENABLE);
1798: else
1799: /* Disable microphone preamp */
1800: ess_clear_xreg_bits(sc, ESS_XCMD_PREAMP_CTRL,
1801: ESS_PREAMP_CTRL_ENABLE);
1802: return (0);
1803: }
1804:
1805: return (EINVAL);
1806: }
1807:
1808: int
1809: ess_get_port(addr, cp)
1810: void *addr;
1811: mixer_ctrl_t *cp;
1812: {
1813: struct ess_softc *sc = addr;
1814:
1815: DPRINTFN(5,("ess_get_port: port=%d\n", cp->dev));
1816:
1817: switch (cp->dev) {
1818: case ESS_MASTER_VOL:
1819: case ESS_DAC_PLAY_VOL:
1820: case ESS_MIC_PLAY_VOL:
1821: case ESS_LINE_PLAY_VOL:
1822: case ESS_SYNTH_PLAY_VOL:
1823: case ESS_CD_PLAY_VOL:
1824: case ESS_AUXB_PLAY_VOL:
1825: case ESS_RECORD_VOL:
1826: switch (cp->un.value.num_channels) {
1827: case 1:
1828: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
1829: sc->gain[cp->dev][ESS_LEFT];
1830: break;
1831: case 2:
1832: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
1833: sc->gain[cp->dev][ESS_LEFT];
1834: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
1835: sc->gain[cp->dev][ESS_RIGHT];
1836: break;
1837: default:
1838: return EINVAL;
1839: }
1840: return (0);
1841:
1842: case ESS_PCSPEAKER_VOL:
1843: if (cp->un.value.num_channels != 1)
1844: return EINVAL;
1845:
1846: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
1847: sc->gain[cp->dev][ESS_LEFT];
1848: return (0);
1849:
1850: case ESS_RECORD_SOURCE:
1851: if (ESS_USE_AUDIO1(sc->sc_model))
1852: cp->un.ord = sc->in_port;
1853: else
1854: cp->un.mask = sc->in_mask;
1855: return (0);
1856:
1857: case ESS_RECORD_MONITOR:
1858: cp->un.ord = (ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL) &
1859: ESS_AUDIO_CTRL_MONITOR) ? 1 : 0;
1860: return (0);
1861: }
1862:
1863: if (ESS_USE_AUDIO1(sc->sc_model))
1864: return (EINVAL);
1865:
1866: switch (cp->dev) {
1867: case ESS_DAC_REC_VOL:
1868: case ESS_MIC_REC_VOL:
1869: case ESS_LINE_REC_VOL:
1870: case ESS_SYNTH_REC_VOL:
1871: case ESS_CD_REC_VOL:
1872: case ESS_AUXB_REC_VOL:
1873: switch (cp->un.value.num_channels) {
1874: case 1:
1875: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
1876: sc->gain[cp->dev][ESS_LEFT];
1877: break;
1878: case 2:
1879: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
1880: sc->gain[cp->dev][ESS_LEFT];
1881: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
1882: sc->gain[cp->dev][ESS_RIGHT];
1883: break;
1884: default:
1885: return EINVAL;
1886: }
1887: return (0);
1888:
1889: case ESS_MIC_PREAMP:
1890: cp->un.ord = (ess_read_x_reg(sc, ESS_XCMD_PREAMP_CTRL) &
1891: ESS_PREAMP_CTRL_ENABLE) ? 1 : 0;
1892: return (0);
1893: }
1894:
1895: return (EINVAL);
1896: }
1897:
1898: int
1899: ess_query_devinfo(addr, dip)
1900: void *addr;
1901: mixer_devinfo_t *dip;
1902: {
1903: struct ess_softc *sc = addr;
1904:
1905: DPRINTFN(5,("ess_query_devinfo: model=%d index=%d\n",
1906: sc->sc_model, dip->index));
1907:
1908: /*
1909: * REVISIT: There are some slight differences between the
1910: * mixers on the different ESS chips, which can
1911: * be sorted out using the chip model rather than a
1912: * separate mixer model.
1913: * This is currently coded assuming an ES1887; we
1914: * need to work out which bits are not applicable to
1915: * the other models (1888 and 888).
1916: */
1917: switch (dip->index) {
1918: case ESS_DAC_PLAY_VOL:
1919: dip->mixer_class = ESS_INPUT_CLASS;
1920: dip->next = dip->prev = AUDIO_MIXER_LAST;
1921: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
1922: dip->type = AUDIO_MIXER_VALUE;
1923: dip->un.v.num_channels = 2;
1924: strlcpy(dip->un.v.units.name, AudioNvolume,
1925: sizeof dip->un.v.units.name);
1926: return (0);
1927:
1928: case ESS_MIC_PLAY_VOL:
1929: dip->mixer_class = ESS_INPUT_CLASS;
1930: dip->prev = AUDIO_MIXER_LAST;
1931: if (ESS_USE_AUDIO1(sc->sc_model))
1932: dip->next = AUDIO_MIXER_LAST;
1933: else
1934: dip->next = ESS_MIC_PREAMP;
1935: strlcpy(dip->label.name, AudioNmicrophone,
1936: sizeof dip->label.name);
1937: dip->type = AUDIO_MIXER_VALUE;
1938: dip->un.v.num_channels = 2;
1939: strlcpy(dip->un.v.units.name, AudioNvolume,
1940: sizeof dip->un.v.units.name);
1941: return (0);
1942:
1943: case ESS_LINE_PLAY_VOL:
1944: dip->mixer_class = ESS_INPUT_CLASS;
1945: dip->next = dip->prev = AUDIO_MIXER_LAST;
1946: strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
1947: dip->type = AUDIO_MIXER_VALUE;
1948: dip->un.v.num_channels = 2;
1949: strlcpy(dip->un.v.units.name, AudioNvolume,
1950: sizeof dip->un.v.units.name);
1951: return (0);
1952:
1953: case ESS_SYNTH_PLAY_VOL:
1954: dip->mixer_class = ESS_INPUT_CLASS;
1955: dip->next = dip->prev = AUDIO_MIXER_LAST;
1956: strlcpy(dip->label.name, AudioNfmsynth,
1957: sizeof dip->label.name);
1958: dip->type = AUDIO_MIXER_VALUE;
1959: dip->un.v.num_channels = 2;
1960: strlcpy(dip->un.v.units.name, AudioNvolume,
1961: sizeof dip->un.v.units.name);
1962: return (0);
1963:
1964: case ESS_CD_PLAY_VOL:
1965: dip->mixer_class = ESS_INPUT_CLASS;
1966: dip->next = dip->prev = AUDIO_MIXER_LAST;
1967: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
1968: dip->type = AUDIO_MIXER_VALUE;
1969: dip->un.v.num_channels = 2;
1970: strlcpy(dip->un.v.units.name, AudioNvolume,
1971: sizeof dip->un.v.units.name);
1972: return (0);
1973:
1974: case ESS_AUXB_PLAY_VOL:
1975: dip->mixer_class = ESS_INPUT_CLASS;
1976: dip->next = dip->prev = AUDIO_MIXER_LAST;
1977: strlcpy(dip->label.name, "auxb", sizeof dip->label.name);
1978: dip->type = AUDIO_MIXER_VALUE;
1979: dip->un.v.num_channels = 2;
1980: strlcpy(dip->un.v.units.name, AudioNvolume,
1981: sizeof dip->un.v.units.name);
1982: return (0);
1983:
1984: case ESS_INPUT_CLASS:
1985: dip->mixer_class = ESS_INPUT_CLASS;
1986: dip->next = dip->prev = AUDIO_MIXER_LAST;
1987: strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
1988: dip->type = AUDIO_MIXER_CLASS;
1989: return (0);
1990:
1991: case ESS_MASTER_VOL:
1992: dip->mixer_class = ESS_OUTPUT_CLASS;
1993: dip->next = dip->prev = AUDIO_MIXER_LAST;
1994: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
1995: dip->type = AUDIO_MIXER_VALUE;
1996: dip->un.v.num_channels = 2;
1997: strlcpy(dip->un.v.units.name, AudioNvolume,
1998: sizeof dip->un.v.units.name);
1999: return (0);
2000:
2001: case ESS_PCSPEAKER_VOL:
2002: dip->mixer_class = ESS_OUTPUT_CLASS;
2003: dip->next = dip->prev = AUDIO_MIXER_LAST;
2004: strlcpy(dip->label.name, "pc_speaker", sizeof dip->label.name);
2005: dip->type = AUDIO_MIXER_VALUE;
2006: dip->un.v.num_channels = 1;
2007: strlcpy(dip->un.v.units.name, AudioNvolume,
2008: sizeof dip->un.v.units.name);
2009: return (0);
2010:
2011: case ESS_OUTPUT_CLASS:
2012: dip->mixer_class = ESS_OUTPUT_CLASS;
2013: dip->next = dip->prev = AUDIO_MIXER_LAST;
2014: strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
2015: dip->type = AUDIO_MIXER_CLASS;
2016: return (0);
2017:
2018: case ESS_RECORD_VOL:
2019: dip->mixer_class = ESS_RECORD_CLASS;
2020: dip->next = dip->prev = AUDIO_MIXER_LAST;
2021: strlcpy(dip->label.name, AudioNrecord, sizeof dip->label.name);
2022: dip->type = AUDIO_MIXER_VALUE;
2023: dip->un.v.num_channels = 2;
2024: strlcpy(dip->un.v.units.name, AudioNvolume,
2025: sizeof dip->un.v.units.name);
2026: return (0);
2027:
2028: case ESS_RECORD_SOURCE:
2029: dip->mixer_class = ESS_RECORD_CLASS;
2030: dip->next = dip->prev = AUDIO_MIXER_LAST;
2031: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
2032: if (ESS_USE_AUDIO1(sc->sc_model)) {
2033: /*
2034: * The 1788 doesn't use the input mixer control that
2035: * the 1888 uses, because it's a pain when you only
2036: * have one mixer.
2037: * Perhaps it could be emulated by keeping both sets of
2038: * gain values, and doing a `context switch' of the
2039: * mixer registers when shifting from playing to
2040: * recording.
2041: */
2042: dip->type = AUDIO_MIXER_ENUM;
2043: dip->un.e.num_mem = 4;
2044: strlcpy(dip->un.e.member[0].label.name,
2045: AudioNmicrophone,
2046: sizeof dip->un.e.member[0].label.name);
2047: dip->un.e.member[0].ord = ESS_SOURCE_MIC;
2048: strlcpy(dip->un.e.member[1].label.name, AudioNline,
2049: sizeof dip->un.e.member[1].label.name);
2050: dip->un.e.member[1].ord = ESS_SOURCE_LINE;
2051: strlcpy(dip->un.e.member[2].label.name, AudioNcd,
2052: sizeof dip->un.e.member[2].label.name);
2053: dip->un.e.member[2].ord = ESS_SOURCE_CD;
2054: strlcpy(dip->un.e.member[3].label.name, AudioNmixerout,
2055: sizeof dip->un.e.member[3].label.name);
2056: dip->un.e.member[3].ord = ESS_SOURCE_MIXER;
2057: } else {
2058: dip->type = AUDIO_MIXER_SET;
2059: dip->un.s.num_mem = 6;
2060: strlcpy(dip->un.s.member[0].label.name, AudioNdac,
2061: sizeof dip->un.e.member[0].label.name);
2062: dip->un.s.member[0].mask = 1 << ESS_DAC_REC_VOL;
2063: strlcpy(dip->un.s.member[1].label.name,
2064: AudioNmicrophone,
2065: sizeof dip->un.e.member[1].label.name);
2066: dip->un.s.member[1].mask = 1 << ESS_MIC_REC_VOL;
2067: strlcpy(dip->un.s.member[2].label.name, AudioNline,
2068: sizeof dip->un.e.member[2].label.name);
2069: dip->un.s.member[2].mask = 1 << ESS_LINE_REC_VOL;
2070: strlcpy(dip->un.s.member[3].label.name, AudioNfmsynth,
2071: sizeof dip->un.e.member[3].label.name);
2072: dip->un.s.member[3].mask = 1 << ESS_SYNTH_REC_VOL;
2073: strlcpy(dip->un.s.member[4].label.name, AudioNcd,
2074: sizeof dip->un.e.member[4].label.name);
2075: dip->un.s.member[4].mask = 1 << ESS_CD_REC_VOL;
2076: strlcpy(dip->un.s.member[5].label.name, "auxb",
2077: sizeof dip->un.e.member[5].label.name);
2078: dip->un.s.member[5].mask = 1 << ESS_AUXB_REC_VOL;
2079: }
2080: return (0);
2081:
2082: case ESS_RECORD_CLASS:
2083: dip->mixer_class = ESS_RECORD_CLASS;
2084: dip->next = dip->prev = AUDIO_MIXER_LAST;
2085: strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
2086: dip->type = AUDIO_MIXER_CLASS;
2087: return (0);
2088:
2089: case ESS_RECORD_MONITOR:
2090: dip->prev = dip->next = AUDIO_MIXER_LAST;
2091: strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
2092: dip->type = AUDIO_MIXER_ENUM;
2093: dip->mixer_class = ESS_MONITOR_CLASS;
2094: dip->un.e.num_mem = 2;
2095: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
2096: sizeof dip->un.e.member[0].label.name);
2097: dip->un.e.member[0].ord = 0;
2098: strlcpy(dip->un.e.member[1].label.name, AudioNon,
2099: sizeof dip->un.e.member[1].label.name);
2100: dip->un.e.member[1].ord = 1;
2101: return (0);
2102:
2103: case ESS_MONITOR_CLASS:
2104: dip->mixer_class = ESS_MONITOR_CLASS;
2105: dip->next = dip->prev = AUDIO_MIXER_LAST;
2106: strlcpy(dip->label.name, AudioCmonitor,
2107: sizeof dip->label.name);
2108: dip->type = AUDIO_MIXER_CLASS;
2109: return (0);
2110: }
2111:
2112: if (ESS_USE_AUDIO1(sc->sc_model))
2113: return (ENXIO);
2114:
2115: switch (dip->index) {
2116: case ESS_DAC_REC_VOL:
2117: dip->mixer_class = ESS_RECORD_CLASS;
2118: dip->next = dip->prev = AUDIO_MIXER_LAST;
2119: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
2120: dip->type = AUDIO_MIXER_VALUE;
2121: dip->un.v.num_channels = 2;
2122: strlcpy(dip->un.v.units.name, AudioNvolume,
2123: sizeof dip->un.v.units.name);
2124: return (0);
2125:
2126: case ESS_MIC_REC_VOL:
2127: dip->mixer_class = ESS_RECORD_CLASS;
2128: dip->next = dip->prev = AUDIO_MIXER_LAST;
2129: strlcpy(dip->label.name, AudioNmicrophone,
2130: sizeof dip->label.name);
2131: dip->type = AUDIO_MIXER_VALUE;
2132: dip->un.v.num_channels = 2;
2133: strlcpy(dip->un.v.units.name, AudioNvolume,
2134: sizeof dip->un.v.units.name);
2135: return (0);
2136:
2137: case ESS_LINE_REC_VOL:
2138: dip->mixer_class = ESS_RECORD_CLASS;
2139: dip->next = dip->prev = AUDIO_MIXER_LAST;
2140: strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
2141: dip->type = AUDIO_MIXER_VALUE;
2142: dip->un.v.num_channels = 2;
2143: strlcpy(dip->un.v.units.name, AudioNvolume,
2144: sizeof dip->un.v.units.name);
2145: return (0);
2146:
2147: case ESS_SYNTH_REC_VOL:
2148: dip->mixer_class = ESS_RECORD_CLASS;
2149: dip->next = dip->prev = AUDIO_MIXER_LAST;
2150: strlcpy(dip->label.name, AudioNfmsynth,
2151: sizeof dip->label.name);
2152: dip->type = AUDIO_MIXER_VALUE;
2153: dip->un.v.num_channels = 2;
2154: strlcpy(dip->un.v.units.name, AudioNvolume,
2155: sizeof dip->un.v.units.name);
2156: return (0);
2157:
2158: case ESS_CD_REC_VOL:
2159: dip->mixer_class = ESS_RECORD_CLASS;
2160: dip->next = dip->prev = AUDIO_MIXER_LAST;
2161: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
2162: dip->type = AUDIO_MIXER_VALUE;
2163: dip->un.v.num_channels = 2;
2164: strlcpy(dip->un.v.units.name, AudioNvolume,
2165: sizeof dip->un.v.units.name);
2166: return (0);
2167:
2168: case ESS_AUXB_REC_VOL:
2169: dip->mixer_class = ESS_RECORD_CLASS;
2170: dip->next = dip->prev = AUDIO_MIXER_LAST;
2171: strlcpy(dip->label.name, "auxb", sizeof dip->label.name);
2172: dip->type = AUDIO_MIXER_VALUE;
2173: dip->un.v.num_channels = 2;
2174: strlcpy(dip->un.v.units.name, AudioNvolume,
2175: sizeof dip->un.v.units.name);
2176: return (0);
2177:
2178: case ESS_MIC_PREAMP:
2179: dip->mixer_class = ESS_INPUT_CLASS;
2180: dip->prev = ESS_MIC_PLAY_VOL;
2181: dip->next = AUDIO_MIXER_LAST;
2182: strlcpy(dip->label.name, AudioNpreamp, sizeof dip->label.name);
2183: dip->type = AUDIO_MIXER_ENUM;
2184: dip->un.e.num_mem = 2;
2185: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
2186: sizeof dip->un.e.member[0].label.name);
2187: dip->un.e.member[0].ord = 0;
2188: strlcpy(dip->un.e.member[1].label.name, AudioNon,
2189: sizeof dip->un.e.member[1].label.name);
2190: dip->un.e.member[1].ord = 1;
2191: return (0);
2192: }
2193:
2194: return (ENXIO);
2195: }
2196:
2197: void *
2198: ess_malloc(addr, direction, size, pool, flags)
2199: void *addr;
2200: int direction;
2201: size_t size;
2202: int pool, flags;
2203: {
2204: struct ess_softc *sc = addr;
2205: int drq;
2206:
2207: if (!ESS_USE_AUDIO1(sc->sc_model))
2208: drq = sc->sc_audio2.drq;
2209: else
2210: drq = sc->sc_audio1.drq;
2211: return (isa_malloc(sc->sc_isa, drq, size, pool, flags));
2212: }
2213:
2214: void
2215: ess_free(addr, ptr, pool)
2216: void *addr;
2217: void *ptr;
2218: int pool;
2219: {
2220: isa_free(ptr, pool);
2221: }
2222:
2223: size_t
2224: ess_round_buffersize(addr, direction, size)
2225: void *addr;
2226: int direction;
2227: size_t size;
2228: {
2229: if (size > MAX_ISADMA)
2230: size = MAX_ISADMA;
2231: return (size);
2232: }
2233:
2234: paddr_t
2235: ess_mappage(addr, mem, off, prot)
2236: void *addr;
2237: void *mem;
2238: off_t off;
2239: int prot;
2240: {
2241: return (isa_mappage(mem, off, prot));
2242: }
2243:
2244: int
2245: ess_1788_get_props(addr)
2246: void *addr;
2247: {
2248:
2249: return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT);
2250: }
2251:
2252: int
2253: ess_1888_get_props(addr)
2254: void *addr;
2255: {
2256:
2257: return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX);
2258: }
2259:
2260: /* ============================================
2261: * Generic functions for ess, not used by audio h/w i/f
2262: * =============================================
2263: */
2264:
2265: /*
2266: * Reset the chip.
2267: * Return non-zero if the chip isn't detected.
2268: */
2269: int
2270: ess_reset(sc)
2271: struct ess_softc *sc;
2272: {
2273: bus_space_tag_t iot = sc->sc_iot;
2274: bus_space_handle_t ioh = sc->sc_ioh;
2275:
2276: sc->sc_audio1.active = 0;
2277: sc->sc_audio2.active = 0;
2278:
2279: EWRITE1(iot, ioh, ESS_DSP_RESET, ESS_RESET_EXT);
2280: delay(10000);
2281: EWRITE1(iot, ioh, ESS_DSP_RESET, 0);
2282: if (ess_rdsp(sc) != ESS_MAGIC)
2283: return (1);
2284:
2285: /* Enable access to the ESS extension commands. */
2286: ess_wdsp(sc, ESS_ACMD_ENABLE_EXT);
2287:
2288: return (0);
2289: }
2290:
2291: void
2292: ess_set_gain(sc, port, on)
2293: struct ess_softc *sc;
2294: int port;
2295: int on;
2296: {
2297: int gain, left, right;
2298: int mix;
2299: int src;
2300: int stereo;
2301:
2302: /*
2303: * Most gain controls are found in the mixer registers and
2304: * are stereo. Any that are not, must set mix and stereo as
2305: * required.
2306: */
2307: mix = 1;
2308: stereo = 1;
2309:
2310: switch (port) {
2311: case ESS_MASTER_VOL:
2312: src = ESS_MREG_VOLUME_MASTER;
2313: break;
2314: case ESS_DAC_PLAY_VOL:
2315: if (ESS_USE_AUDIO1(sc->sc_model))
2316: src = ESS_MREG_VOLUME_VOICE;
2317: else
2318: src = 0x7C;
2319: break;
2320: case ESS_MIC_PLAY_VOL:
2321: src = ESS_MREG_VOLUME_MIC;
2322: break;
2323: case ESS_LINE_PLAY_VOL:
2324: src = ESS_MREG_VOLUME_LINE;
2325: break;
2326: case ESS_SYNTH_PLAY_VOL:
2327: src = ESS_MREG_VOLUME_SYNTH;
2328: break;
2329: case ESS_CD_PLAY_VOL:
2330: src = ESS_MREG_VOLUME_CD;
2331: break;
2332: case ESS_AUXB_PLAY_VOL:
2333: src = ESS_MREG_VOLUME_AUXB;
2334: break;
2335: case ESS_PCSPEAKER_VOL:
2336: src = ESS_MREG_VOLUME_PCSPKR;
2337: stereo = 0;
2338: break;
2339: case ESS_DAC_REC_VOL:
2340: src = 0x69;
2341: break;
2342: case ESS_MIC_REC_VOL:
2343: src = 0x68;
2344: break;
2345: case ESS_LINE_REC_VOL:
2346: src = 0x6E;
2347: break;
2348: case ESS_SYNTH_REC_VOL:
2349: src = 0x6B;
2350: break;
2351: case ESS_CD_REC_VOL:
2352: src = 0x6A;
2353: break;
2354: case ESS_AUXB_REC_VOL:
2355: src = 0x6C;
2356: break;
2357: case ESS_RECORD_VOL:
2358: src = ESS_XCMD_VOLIN_CTRL;
2359: mix = 0;
2360: break;
2361: default:
2362: return;
2363: }
2364:
2365: /* 1788 doesn't have a separate recording mixer */
2366: if (ESS_USE_AUDIO1(sc->sc_model) && mix && src > 0x62)
2367: return;
2368:
2369: if (on) {
2370: left = sc->gain[port][ESS_LEFT];
2371: right = sc->gain[port][ESS_RIGHT];
2372: } else {
2373: left = right = 0;
2374: }
2375:
2376: if (stereo)
2377: gain = ESS_STEREO_GAIN(left, right);
2378: else
2379: gain = ESS_MONO_GAIN(left);
2380:
2381: if (mix)
2382: ess_write_mix_reg(sc, src, gain);
2383: else
2384: ess_write_x_reg(sc, src, gain);
2385: }
2386:
2387: /* Set the input device on devices without an input mixer. */
2388: int
2389: ess_set_in_port(sc, ord)
2390: struct ess_softc *sc;
2391: int ord;
2392: {
2393: mixer_devinfo_t di;
2394: int i;
2395:
2396: DPRINTF(("ess_set_in_port: ord=0x%x\n", ord));
2397:
2398: /*
2399: * Get the device info for the record source control,
2400: * including the list of available sources.
2401: */
2402: di.index = ESS_RECORD_SOURCE;
2403: if (ess_query_devinfo(sc, &di))
2404: return EINVAL;
2405:
2406: /* See if the given ord value was anywhere in the list. */
2407: for (i = 0; i < di.un.e.num_mem; i++) {
2408: if (ord == di.un.e.member[i].ord)
2409: break;
2410: }
2411: if (i == di.un.e.num_mem)
2412: return EINVAL;
2413:
2414: ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ord);
2415:
2416: sc->in_port = ord;
2417: return (0);
2418: }
2419:
2420: /* Set the input device levels on input-mixer-enabled devices. */
2421: int
2422: ess_set_in_ports(sc, mask)
2423: struct ess_softc *sc;
2424: int mask;
2425: {
2426: mixer_devinfo_t di;
2427: int i, port;
2428:
2429: DPRINTF(("ess_set_in_ports: mask=0x%x\n", mask));
2430:
2431: /*
2432: * Get the device info for the record source control,
2433: * including the list of available sources.
2434: */
2435: di.index = ESS_RECORD_SOURCE;
2436: if (ess_query_devinfo(sc, &di))
2437: return EINVAL;
2438:
2439: /*
2440: * Set or disable the record volume control for each of the
2441: * possible sources.
2442: */
2443: for (i = 0; i < di.un.s.num_mem; i++) {
2444: /*
2445: * Calculate the source port number from its mask.
2446: */
2447: port = ffs(di.un.s.member[i].mask);
2448:
2449: /*
2450: * Set the source gain:
2451: * to the current value if source is enabled
2452: * to zero if source is disabled
2453: */
2454: ess_set_gain(sc, port, mask & di.un.s.member[i].mask);
2455: }
2456:
2457: sc->in_mask = mask;
2458: return (0);
2459: }
2460:
2461: void
2462: ess_speaker_on(sc)
2463: struct ess_softc *sc;
2464: {
2465: /* Unmute the DAC. */
2466: ess_set_gain(sc, ESS_DAC_PLAY_VOL, 1);
2467: }
2468:
2469: void
2470: ess_speaker_off(sc)
2471: struct ess_softc *sc;
2472: {
2473: /* Mute the DAC. */
2474: ess_set_gain(sc, ESS_DAC_PLAY_VOL, 0);
2475: }
2476:
2477: /*
2478: * Calculate the time constant for the requested sampling rate.
2479: */
2480: u_int
2481: ess_srtotc(rate)
2482: u_int rate;
2483: {
2484: u_int tc;
2485:
2486: /* The following formulae are from the ESS data sheet. */
2487: if (rate <= 22050)
2488: tc = 128 - 397700L / rate;
2489: else
2490: tc = 256 - 795500L / rate;
2491:
2492: return (tc);
2493: }
2494:
2495:
2496: /*
2497: * Calculate the filter constant for the reuqested sampling rate.
2498: */
2499: u_int
2500: ess_srtofc(rate)
2501: u_int rate;
2502: {
2503: /*
2504: * The following formula is derived from the information in
2505: * the ES1887 data sheet, based on a roll-off frequency of
2506: * 87%.
2507: */
2508: return (256 - 200279L / rate);
2509: }
2510:
2511:
2512: /*
2513: * Return the status of the DSP.
2514: */
2515: u_char
2516: ess_get_dsp_status(sc)
2517: struct ess_softc *sc;
2518: {
2519: return (EREAD1(sc->sc_iot, sc->sc_ioh, ESS_DSP_RW_STATUS));
2520: }
2521:
2522:
2523: /*
2524: * Return the read status of the DSP: 1 -> DSP ready for reading
2525: * 0 -> DSP not ready for reading
2526: */
2527: u_char
2528: ess_dsp_read_ready(sc)
2529: struct ess_softc *sc;
2530: {
2531: return ((ess_get_dsp_status(sc) & ESS_DSP_READ_READY) ? 1 : 0);
2532: }
2533:
2534:
2535: /*
2536: * Return the write status of the DSP: 1 -> DSP ready for writing
2537: * 0 -> DSP not ready for writing
2538: */
2539: u_char
2540: ess_dsp_write_ready(sc)
2541: struct ess_softc *sc;
2542: {
2543: return ((ess_get_dsp_status(sc) & ESS_DSP_WRITE_BUSY) ? 0 : 1);
2544: }
2545:
2546:
2547: /*
2548: * Read a byte from the DSP.
2549: */
2550: int
2551: ess_rdsp(sc)
2552: struct ess_softc *sc;
2553: {
2554: bus_space_tag_t iot = sc->sc_iot;
2555: bus_space_handle_t ioh = sc->sc_ioh;
2556: int i;
2557:
2558: for (i = ESS_READ_TIMEOUT; i > 0; --i) {
2559: if (ess_dsp_read_ready(sc)) {
2560: i = EREAD1(iot, ioh, ESS_DSP_READ);
2561: DPRINTFN(8,("ess_rdsp() = 0x%02x\n", i));
2562: return i;
2563: } else
2564: delay(10);
2565: }
2566:
2567: DPRINTF(("ess_rdsp: timed out\n"));
2568: return (-1);
2569: }
2570:
2571: /*
2572: * Write a byte to the DSP.
2573: */
2574: int
2575: ess_wdsp(sc, v)
2576: struct ess_softc *sc;
2577: u_char v;
2578: {
2579: bus_space_tag_t iot = sc->sc_iot;
2580: bus_space_handle_t ioh = sc->sc_ioh;
2581: int i;
2582:
2583: DPRINTFN(8,("ess_wdsp(0x%02x)\n", v));
2584:
2585: for (i = ESS_WRITE_TIMEOUT; i > 0; --i) {
2586: if (ess_dsp_write_ready(sc)) {
2587: EWRITE1(iot, ioh, ESS_DSP_WRITE, v);
2588: return (0);
2589: } else
2590: delay(10);
2591: }
2592:
2593: DPRINTF(("ess_wdsp(0x%02x): timed out\n", v));
2594: return (-1);
2595: }
2596:
2597: /*
2598: * Write a value to one of the ESS extended registers.
2599: */
2600: int
2601: ess_write_x_reg(sc, reg, val)
2602: struct ess_softc *sc;
2603: u_char reg;
2604: u_char val;
2605: {
2606: int error;
2607:
2608: DPRINTFN(2,("ess_write_x_reg: %02x=%02x\n", reg, val));
2609: if ((error = ess_wdsp(sc, reg)) == 0)
2610: error = ess_wdsp(sc, val);
2611:
2612: return error;
2613: }
2614:
2615: /*
2616: * Read the value of one of the ESS extended registers.
2617: */
2618: u_char
2619: ess_read_x_reg(sc, reg)
2620: struct ess_softc *sc;
2621: u_char reg;
2622: {
2623: int error;
2624: int val;
2625:
2626: if ((error = ess_wdsp(sc, 0xC0)) == 0)
2627: error = ess_wdsp(sc, reg);
2628: if (error)
2629: DPRINTF(("Error reading extended register 0x%02x\n", reg));
2630: /* REVISIT: what if an error is returned above? */
2631: val = ess_rdsp(sc);
2632: DPRINTFN(2,("ess_read_x_reg: %02x=%02x\n", reg, val));
2633: return val;
2634: }
2635:
2636: void
2637: ess_clear_xreg_bits(sc, reg, mask)
2638: struct ess_softc *sc;
2639: u_char reg;
2640: u_char mask;
2641: {
2642: if (ess_write_x_reg(sc, reg, ess_read_x_reg(sc, reg) & ~mask) == -1)
2643: DPRINTF(("Error clearing bits in extended register 0x%02x\n",
2644: reg));
2645: }
2646:
2647: void
2648: ess_set_xreg_bits(sc, reg, mask)
2649: struct ess_softc *sc;
2650: u_char reg;
2651: u_char mask;
2652: {
2653: if (ess_write_x_reg(sc, reg, ess_read_x_reg(sc, reg) | mask) == -1)
2654: DPRINTF(("Error setting bits in extended register 0x%02x\n",
2655: reg));
2656: }
2657:
2658:
2659: /*
2660: * Write a value to one of the ESS mixer registers.
2661: */
2662: void
2663: ess_write_mix_reg(sc, reg, val)
2664: struct ess_softc *sc;
2665: u_char reg;
2666: u_char val;
2667: {
2668: bus_space_tag_t iot = sc->sc_iot;
2669: bus_space_handle_t ioh = sc->sc_ioh;
2670: int s;
2671:
2672: DPRINTFN(2,("ess_write_mix_reg: %x=%x\n", reg, val));
2673:
2674: s = splaudio();
2675: EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
2676: EWRITE1(iot, ioh, ESS_MIX_REG_DATA, val);
2677: splx(s);
2678: }
2679:
2680: /*
2681: * Read the value of one of the ESS mixer registers.
2682: */
2683: u_char
2684: ess_read_mix_reg(sc, reg)
2685: struct ess_softc *sc;
2686: u_char reg;
2687: {
2688: bus_space_tag_t iot = sc->sc_iot;
2689: bus_space_handle_t ioh = sc->sc_ioh;
2690: int s;
2691: u_char val;
2692:
2693: s = splaudio();
2694: EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
2695: val = EREAD1(iot, ioh, ESS_MIX_REG_DATA);
2696: splx(s);
2697:
2698: DPRINTFN(2,("ess_read_mix_reg: %x=%x\n", reg, val));
2699: return val;
2700: }
2701:
2702: void
2703: ess_clear_mreg_bits(sc, reg, mask)
2704: struct ess_softc *sc;
2705: u_char reg;
2706: u_char mask;
2707: {
2708: ess_write_mix_reg(sc, reg, ess_read_mix_reg(sc, reg) & ~mask);
2709: }
2710:
2711: void
2712: ess_set_mreg_bits(sc, reg, mask)
2713: struct ess_softc *sc;
2714: u_char reg;
2715: u_char mask;
2716: {
2717: ess_write_mix_reg(sc, reg, ess_read_mix_reg(sc, reg) | mask);
2718: }
2719:
2720: void
2721: ess_read_multi_mix_reg(sc, reg, datap, count)
2722: struct ess_softc *sc;
2723: u_char reg;
2724: u_int8_t *datap;
2725: bus_size_t count;
2726: {
2727: bus_space_tag_t iot = sc->sc_iot;
2728: bus_space_handle_t ioh = sc->sc_ioh;
2729: int s;
2730:
2731: s = splaudio();
2732: EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
2733: bus_space_read_multi_1(iot, ioh, ESS_MIX_REG_DATA, datap, count);
2734: splx(s);
2735: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ess.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa