xref: /netbsd-src/sys/dev/pci/eso.c (revision 8b0f9554ff8762542c4defc4f70e1eb76fb508fa)
1 /*	$NetBSD: eso.c,v 1.51 2007/10/19 12:00:43 ad Exp $	*/
2 
3 /*
4  * Copyright (c) 1999, 2000, 2004 Klaus J. Klein
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. The name of the author may not be used to endorse or promote products
16  *    derived from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
25  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30 
31 /*
32  * ESS Technology Inc. Solo-1 PCI AudioDrive (ES1938/1946) device driver.
33  */
34 
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: eso.c,v 1.51 2007/10/19 12:00:43 ad Exp $");
37 
38 #include "mpu.h"
39 
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/kernel.h>
43 #include <sys/malloc.h>
44 #include <sys/device.h>
45 #include <sys/queue.h>
46 #include <sys/proc.h>
47 
48 #include <dev/pci/pcidevs.h>
49 #include <dev/pci/pcivar.h>
50 
51 #include <sys/audioio.h>
52 #include <dev/audio_if.h>
53 #include <dev/midi_if.h>
54 
55 #include <dev/mulaw.h>
56 #include <dev/auconv.h>
57 
58 #include <dev/ic/mpuvar.h>
59 #include <dev/ic/i8237reg.h>
60 #include <dev/pci/esoreg.h>
61 #include <dev/pci/esovar.h>
62 
63 #include <sys/bus.h>
64 #include <sys/intr.h>
65 
66 /*
67  * XXX Work around the 24-bit implementation limit of the Audio 1 DMA
68  * XXX engine by allocating through the ISA DMA tag.
69  */
70 #if defined(amd64) || defined(i386)
71 #include "isa.h"
72 #if NISA > 0
73 #include <dev/isa/isavar.h>
74 #endif
75 #endif
76 
77 #if defined(AUDIO_DEBUG) || defined(DEBUG)
78 #define DPRINTF(x) printf x
79 #else
80 #define DPRINTF(x)
81 #endif
82 
83 struct eso_dma {
84 	bus_dma_tag_t		ed_dmat;
85 	bus_dmamap_t		ed_map;
86 	void *			ed_kva;
87 	bus_dma_segment_t	ed_segs[1];
88 	int			ed_nsegs;
89 	size_t			ed_size;
90 	SLIST_ENTRY(eso_dma)	ed_slist;
91 };
92 
93 #define KVADDR(dma)	((void *)(dma)->ed_kva)
94 #define DMAADDR(dma)	((dma)->ed_map->dm_segs[0].ds_addr)
95 
96 /* Autoconfiguration interface */
97 static int eso_match(struct device *, struct cfdata *, void *);
98 static void eso_attach(struct device *, struct device *, void *);
99 static void eso_defer(struct device *);
100 static int eso_print(void *, const char *);
101 
102 CFATTACH_DECL(eso, sizeof (struct eso_softc),
103     eso_match, eso_attach, NULL, NULL);
104 
105 /* PCI interface */
106 static int eso_intr(void *);
107 
108 /* MI audio layer interface */
109 static int	eso_query_encoding(void *, struct audio_encoding *);
110 static int	eso_set_params(void *, int, int, audio_params_t *,
111 		    audio_params_t *, stream_filter_list_t *,
112 		    stream_filter_list_t *);
113 static int	eso_round_blocksize(void *, int, int, const audio_params_t *);
114 static int	eso_halt_output(void *);
115 static int	eso_halt_input(void *);
116 static int	eso_getdev(void *, struct audio_device *);
117 static int	eso_set_port(void *, mixer_ctrl_t *);
118 static int	eso_get_port(void *, mixer_ctrl_t *);
119 static int	eso_query_devinfo(void *, mixer_devinfo_t *);
120 static void *	eso_allocm(void *, int, size_t, struct malloc_type *, int);
121 static void	eso_freem(void *, void *, struct malloc_type *);
122 static size_t	eso_round_buffersize(void *, int, size_t);
123 static paddr_t	eso_mappage(void *, void *, off_t, int);
124 static int	eso_get_props(void *);
125 static int	eso_trigger_output(void *, void *, void *, int,
126 		    void (*)(void *), void *, const audio_params_t *);
127 static int	eso_trigger_input(void *, void *, void *, int,
128 		    void (*)(void *), void *, const audio_params_t *);
129 
130 static const struct audio_hw_if eso_hw_if = {
131 	NULL,			/* open */
132 	NULL,			/* close */
133 	NULL,			/* drain */
134 	eso_query_encoding,
135 	eso_set_params,
136 	eso_round_blocksize,
137 	NULL,			/* commit_settings */
138 	NULL,			/* init_output */
139 	NULL,			/* init_input */
140 	NULL,			/* start_output */
141 	NULL,			/* start_input */
142 	eso_halt_output,
143 	eso_halt_input,
144 	NULL,			/* speaker_ctl */
145 	eso_getdev,
146 	NULL,			/* setfd */
147 	eso_set_port,
148 	eso_get_port,
149 	eso_query_devinfo,
150 	eso_allocm,
151 	eso_freem,
152 	eso_round_buffersize,
153 	eso_mappage,
154 	eso_get_props,
155 	eso_trigger_output,
156 	eso_trigger_input,
157 	NULL,			/* dev_ioctl */
158 	NULL,			/* powerstate */
159 };
160 
161 static const char * const eso_rev2model[] = {
162 	"ES1938",
163 	"ES1946",
164 	"ES1946 Revision E"
165 };
166 
167 #define ESO_NFORMATS	8
168 static const struct audio_format eso_formats[ESO_NFORMATS] = {
169 	{NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 16, 16,
170 	 2, AUFMT_STEREO, 0, {ESO_MINRATE, ESO_MAXRATE}},
171 	{NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 16, 16,
172 	 1, AUFMT_MONAURAL, 0, {ESO_MINRATE, ESO_MAXRATE}},
173 	{NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_ULINEAR_LE, 16, 16,
174 	 2, AUFMT_STEREO, 0, {ESO_MINRATE, ESO_MAXRATE}},
175 	{NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_ULINEAR_LE, 16, 16,
176 	 1, AUFMT_MONAURAL, 0, {ESO_MINRATE, ESO_MAXRATE}},
177 	{NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 8, 8,
178 	 2, AUFMT_STEREO, 0, {ESO_MINRATE, ESO_MAXRATE}},
179 	{NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 8, 8,
180 	 1, AUFMT_MONAURAL, 0, {ESO_MINRATE, ESO_MAXRATE}},
181 	{NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_ULINEAR_LE, 8, 8,
182 	 2, AUFMT_STEREO, 0, {ESO_MINRATE, ESO_MAXRATE}},
183 	{NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_ULINEAR_LE, 8, 8,
184 	 1, AUFMT_MONAURAL, 0, {ESO_MINRATE, ESO_MAXRATE}}
185 };
186 
187 
188 /*
189  * Utility routines
190  */
191 /* Register access etc. */
192 static uint8_t	eso_read_ctlreg(struct eso_softc *, uint8_t);
193 static uint8_t	eso_read_mixreg(struct eso_softc *, uint8_t);
194 static uint8_t	eso_read_rdr(struct eso_softc *);
195 static void	eso_reload_master_vol(struct eso_softc *);
196 static int	eso_reset(struct eso_softc *);
197 static void	eso_set_gain(struct eso_softc *, unsigned int);
198 static int	eso_set_recsrc(struct eso_softc *, unsigned int);
199 static int	eso_set_monooutsrc(struct eso_softc *, unsigned int);
200 static int	eso_set_monoinbypass(struct eso_softc *, unsigned int);
201 static int	eso_set_preamp(struct eso_softc *, unsigned int);
202 static void	eso_write_cmd(struct eso_softc *, uint8_t);
203 static void	eso_write_ctlreg(struct eso_softc *, uint8_t, uint8_t);
204 static void	eso_write_mixreg(struct eso_softc *, uint8_t, uint8_t);
205 /* DMA memory allocation */
206 static int	eso_allocmem(struct eso_softc *, size_t, size_t, size_t,
207 		    int, int, struct eso_dma *);
208 static void	eso_freemem(struct eso_dma *);
209 static struct eso_dma *	eso_kva2dma(const struct eso_softc *, const void *);
210 
211 
212 static int
213 eso_match(struct device *parent, struct cfdata *match,
214     void *aux)
215 {
216 	struct pci_attach_args *pa;
217 
218 	pa = aux;
219 	if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ESSTECH &&
220 	    PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ESSTECH_SOLO1)
221 		return 1;
222 
223 	return 0;
224 }
225 
226 static void
227 eso_attach(struct device *parent, struct device *self, void *aux)
228 {
229 	struct eso_softc *sc;
230 	struct pci_attach_args *pa;
231 	struct audio_attach_args aa;
232 	pci_intr_handle_t ih;
233 	bus_addr_t vcbase;
234 	const char *intrstring;
235 	int idx;
236 	uint8_t a2mode, mvctl;
237 
238 	sc = (struct eso_softc *)self;
239 	pa = aux;
240 	aprint_naive(": Audio controller\n");
241 
242 	sc->sc_revision = PCI_REVISION(pa->pa_class);
243 
244 	aprint_normal(": ESS Solo-1 PCI AudioDrive ");
245 	if (sc->sc_revision <
246 	    sizeof (eso_rev2model) / sizeof (eso_rev2model[0]))
247 		aprint_normal("%s\n", eso_rev2model[sc->sc_revision]);
248 	else
249 		aprint_normal("(unknown rev. 0x%02x)\n", sc->sc_revision);
250 
251 	/* Map I/O registers. */
252 	if (pci_mapreg_map(pa, ESO_PCI_BAR_IO, PCI_MAPREG_TYPE_IO, 0,
253 	    &sc->sc_iot, &sc->sc_ioh, NULL, NULL)) {
254 		aprint_error("%s: can't map I/O space\n", sc->sc_dev.dv_xname);
255 		return;
256 	}
257 	if (pci_mapreg_map(pa, ESO_PCI_BAR_SB, PCI_MAPREG_TYPE_IO, 0,
258 	    &sc->sc_sb_iot, &sc->sc_sb_ioh, NULL, NULL)) {
259 		aprint_error("%s: can't map SB I/O space\n",
260 		    sc->sc_dev.dv_xname);
261 		return;
262 	}
263 	if (pci_mapreg_map(pa, ESO_PCI_BAR_VC, PCI_MAPREG_TYPE_IO, 0,
264 	    &sc->sc_dmac_iot, &sc->sc_dmac_ioh, &vcbase, &sc->sc_vcsize)) {
265 		aprint_error("%s: can't map VC I/O space\n",
266 		    sc->sc_dev.dv_xname);
267 		/* Don't bail out yet: we can map it later, see below. */
268 		vcbase = 0;
269 		sc->sc_vcsize = 0x10; /* From the data sheet. */
270 	}
271 	if (pci_mapreg_map(pa, ESO_PCI_BAR_MPU, PCI_MAPREG_TYPE_IO, 0,
272 	    &sc->sc_mpu_iot, &sc->sc_mpu_ioh, NULL, NULL)) {
273 		aprint_error("%s: can't map MPU I/O space\n",
274 		    sc->sc_dev.dv_xname);
275 		return;
276 	}
277 	if (pci_mapreg_map(pa, ESO_PCI_BAR_GAME, PCI_MAPREG_TYPE_IO, 0,
278 	    &sc->sc_game_iot, &sc->sc_game_ioh, NULL, NULL)) {
279 		aprint_error("%s: can't map Game I/O space\n",
280 		    sc->sc_dev.dv_xname);
281 		return;
282 	}
283 
284 	sc->sc_dmat = pa->pa_dmat;
285 	SLIST_INIT(&sc->sc_dmas);
286 	sc->sc_dmac_configured = 0;
287 
288 	/* Enable bus mastering. */
289 	pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
290 	    pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG) |
291 	    PCI_COMMAND_MASTER_ENABLE);
292 
293 	/* Reset the device; bail out upon failure. */
294 	if (eso_reset(sc) != 0) {
295 		aprint_error("%s: can't reset\n", sc->sc_dev.dv_xname);
296 		return;
297 	}
298 
299 	/* Select the DMA/IRQ policy: DDMA, ISA IRQ emulation disabled. */
300 	pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_S1C,
301 	    pci_conf_read(pa->pa_pc, pa->pa_tag, ESO_PCI_S1C) &
302 	    ~(ESO_PCI_S1C_IRQP_MASK | ESO_PCI_S1C_DMAP_MASK));
303 
304 	/* Enable the relevant (DMA) interrupts. */
305 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_IRQCTL,
306 	    ESO_IO_IRQCTL_A1IRQ | ESO_IO_IRQCTL_A2IRQ | ESO_IO_IRQCTL_HVIRQ |
307 	    ESO_IO_IRQCTL_MPUIRQ);
308 
309 	/* Set up A1's sample rate generator for new-style parameters. */
310 	a2mode = eso_read_mixreg(sc, ESO_MIXREG_A2MODE);
311 	a2mode |= ESO_MIXREG_A2MODE_NEWA1 | ESO_MIXREG_A2MODE_ASYNC;
312 	eso_write_mixreg(sc, ESO_MIXREG_A2MODE, a2mode);
313 
314 	/* Slave Master Volume to Hardware Volume Control Counter, unmask IRQ.*/
315 	mvctl = eso_read_mixreg(sc, ESO_MIXREG_MVCTL);
316 	mvctl &= ~ESO_MIXREG_MVCTL_SPLIT;
317 	mvctl |= ESO_MIXREG_MVCTL_HVIRQM;
318 	eso_write_mixreg(sc, ESO_MIXREG_MVCTL, mvctl);
319 
320 	/* Set mixer regs to something reasonable, needs work. */
321 	sc->sc_recmon = sc->sc_spatializer = sc->sc_mvmute = 0;
322 	eso_set_monooutsrc(sc, ESO_MIXREG_MPM_MOMUTE);
323 	eso_set_monoinbypass(sc, 0);
324 	eso_set_preamp(sc, 1);
325 	for (idx = 0; idx < ESO_NGAINDEVS; idx++) {
326 		int v;
327 
328 		switch (idx) {
329 		case ESO_MIC_PLAY_VOL:
330 		case ESO_LINE_PLAY_VOL:
331 		case ESO_CD_PLAY_VOL:
332 		case ESO_MONO_PLAY_VOL:
333 		case ESO_AUXB_PLAY_VOL:
334 		case ESO_DAC_REC_VOL:
335 		case ESO_LINE_REC_VOL:
336 		case ESO_SYNTH_REC_VOL:
337 		case ESO_CD_REC_VOL:
338 		case ESO_MONO_REC_VOL:
339 		case ESO_AUXB_REC_VOL:
340 		case ESO_SPATIALIZER:
341 			v = 0;
342 			break;
343 		case ESO_MASTER_VOL:
344 			v = ESO_GAIN_TO_6BIT(AUDIO_MAX_GAIN / 2);
345 			break;
346 		default:
347 			v = ESO_GAIN_TO_4BIT(AUDIO_MAX_GAIN / 2);
348 			break;
349 		}
350 		sc->sc_gain[idx][ESO_LEFT] = sc->sc_gain[idx][ESO_RIGHT] = v;
351 		eso_set_gain(sc, idx);
352 	}
353 	eso_set_recsrc(sc, ESO_MIXREG_ERS_MIC);
354 
355 	/* Map and establish the interrupt. */
356 	if (pci_intr_map(pa, &ih)) {
357 		aprint_error("%s: couldn't map interrupt\n",
358 		    sc->sc_dev.dv_xname);
359 		return;
360 	}
361 	intrstring = pci_intr_string(pa->pa_pc, ih);
362 	sc->sc_ih  = pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO, eso_intr, sc);
363 	if (sc->sc_ih == NULL) {
364 		aprint_error("%s: couldn't establish interrupt",
365 		    sc->sc_dev.dv_xname);
366 		if (intrstring != NULL)
367 			aprint_normal(" at %s", intrstring);
368 		aprint_normal("\n");
369 		return;
370 	}
371 	aprint_normal("%s: interrupting at %s\n", sc->sc_dev.dv_xname,
372 	    intrstring);
373 
374 	/*
375 	 * Set up the DDMA Control register; a suitable I/O region has been
376 	 * supposedly mapped in the VC base address register.
377 	 *
378 	 * The Solo-1 has an ... interesting silicon bug that causes it to
379 	 * not respond to I/O space accesses to the Audio 1 DMA controller
380 	 * if the latter's mapping base address is aligned on a 1K boundary.
381 	 * As a consequence, it is quite possible for the mapping provided
382 	 * in the VC BAR to be useless.  To work around this, we defer this
383 	 * part until all autoconfiguration on our parent bus is completed
384 	 * and then try to map it ourselves in fulfillment of the constraint.
385 	 *
386 	 * According to the register map we may write to the low 16 bits
387 	 * only, but experimenting has shown we're safe.
388 	 * -kjk
389 	 */
390 	if (ESO_VALID_DDMAC_BASE(vcbase)) {
391 		pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_DDMAC,
392 		    vcbase | ESO_PCI_DDMAC_DE);
393 		sc->sc_dmac_configured = 1;
394 
395 		aprint_normal(
396 		    "%s: mapping Audio 1 DMA using VC I/O space at 0x%lx\n",
397 		    sc->sc_dev.dv_xname, (unsigned long)vcbase);
398 	} else {
399 		DPRINTF(("%s: VC I/O space at 0x%lx not suitable, deferring\n",
400 		    sc->sc_dev.dv_xname, (unsigned long)vcbase));
401 		sc->sc_pa = *pa;
402 		config_defer(self, eso_defer);
403 	}
404 
405 	audio_attach_mi(&eso_hw_if, sc, &sc->sc_dev);
406 
407 	aa.type = AUDIODEV_TYPE_OPL;
408 	aa.hwif = NULL;
409 	aa.hdl = NULL;
410 	(void)config_found(&sc->sc_dev, &aa, audioprint);
411 
412 	aa.type = AUDIODEV_TYPE_MPU;
413 	aa.hwif = NULL;
414 	aa.hdl = NULL;
415 	sc->sc_mpudev = config_found(&sc->sc_dev, &aa, audioprint);
416 	if (sc->sc_mpudev != NULL) {
417 		/* Unmask the MPU irq. */
418 		mvctl = eso_read_mixreg(sc, ESO_MIXREG_MVCTL);
419 		mvctl |= ESO_MIXREG_MVCTL_MPUIRQM;
420 		eso_write_mixreg(sc, ESO_MIXREG_MVCTL, mvctl);
421 	}
422 
423 	aa.type = AUDIODEV_TYPE_AUX;
424 	aa.hwif = NULL;
425 	aa.hdl = NULL;
426 	(void)config_found(&sc->sc_dev, &aa, eso_print);
427 }
428 
429 static void
430 eso_defer(struct device *self)
431 {
432 	struct eso_softc *sc;
433 	struct pci_attach_args *pa;
434 	bus_addr_t addr, start;
435 
436 	sc = (struct eso_softc *)self;
437 	pa = &sc->sc_pa;
438 	aprint_normal("%s: ", sc->sc_dev.dv_xname);
439 
440 	/*
441 	 * This is outright ugly, but since we must not make assumptions
442 	 * on the underlying allocator's behaviour it's the most straight-
443 	 * forward way to implement it.  Note that we skip over the first
444 	 * 1K region, which is typically occupied by an attached ISA bus.
445 	 */
446 	for (start = 0x0400; start < 0xffff; start += 0x0400) {
447 		if (bus_space_alloc(sc->sc_iot,
448 		    start + sc->sc_vcsize, start + 0x0400 - 1,
449 		    sc->sc_vcsize, sc->sc_vcsize, 0, 0, &addr,
450 		    &sc->sc_dmac_ioh) != 0)
451 			continue;
452 
453 		pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_DDMAC,
454 		    addr | ESO_PCI_DDMAC_DE);
455 		sc->sc_dmac_iot = sc->sc_iot;
456 		sc->sc_dmac_configured = 1;
457 		aprint_normal("mapping Audio 1 DMA using I/O space at 0x%lx\n",
458 		    (unsigned long)addr);
459 
460 		return;
461 	}
462 
463 	aprint_error("can't map Audio 1 DMA into I/O space\n");
464 }
465 
466 /* ARGSUSED */
467 static int
468 eso_print(void *aux, const char *pnp)
469 {
470 
471 	/* Only joys can attach via this; easy. */
472 	if (pnp)
473 		aprint_normal("joy at %s:", pnp);
474 
475 	return UNCONF;
476 }
477 
478 static void
479 eso_write_cmd(struct eso_softc *sc, uint8_t cmd)
480 {
481 	int i;
482 
483 	/* Poll for busy indicator to become clear. */
484 	for (i = 0; i < ESO_WDR_TIMEOUT; i++) {
485 		if ((bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_RSR)
486 		    & ESO_SB_RSR_BUSY) == 0) {
487 			bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh,
488 			    ESO_SB_WDR, cmd);
489 			return;
490 		} else {
491 			delay(10);
492 		}
493 	}
494 
495 	printf("%s: WDR timeout\n", sc->sc_dev.dv_xname);
496 	return;
497 }
498 
499 /* Write to a controller register */
500 static void
501 eso_write_ctlreg(struct eso_softc *sc, uint8_t reg, uint8_t val)
502 {
503 
504 	/* DPRINTF(("ctlreg 0x%02x = 0x%02x\n", reg, val)); */
505 
506 	eso_write_cmd(sc, reg);
507 	eso_write_cmd(sc, val);
508 }
509 
510 /* Read out the Read Data Register */
511 static uint8_t
512 eso_read_rdr(struct eso_softc *sc)
513 {
514 	int i;
515 
516 	for (i = 0; i < ESO_RDR_TIMEOUT; i++) {
517 		if (bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh,
518 		    ESO_SB_RBSR) & ESO_SB_RBSR_RDAV) {
519 			return (bus_space_read_1(sc->sc_sb_iot,
520 			    sc->sc_sb_ioh, ESO_SB_RDR));
521 		} else {
522 			delay(10);
523 		}
524 	}
525 
526 	printf("%s: RDR timeout\n", sc->sc_dev.dv_xname);
527 	return (-1);
528 }
529 
530 static uint8_t
531 eso_read_ctlreg(struct eso_softc *sc, uint8_t reg)
532 {
533 
534 	eso_write_cmd(sc, ESO_CMD_RCR);
535 	eso_write_cmd(sc, reg);
536 	return eso_read_rdr(sc);
537 }
538 
539 static void
540 eso_write_mixreg(struct eso_softc *sc, uint8_t reg, uint8_t val)
541 {
542 	int s;
543 
544 	/* DPRINTF(("mixreg 0x%02x = 0x%02x\n", reg, val)); */
545 
546 	s = splaudio();
547 	bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERADDR, reg);
548 	bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERDATA, val);
549 	splx(s);
550 }
551 
552 static uint8_t
553 eso_read_mixreg(struct eso_softc *sc, uint8_t reg)
554 {
555 	int s;
556 	uint8_t val;
557 
558 	s = splaudio();
559 	bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERADDR, reg);
560 	val = bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERDATA);
561 	splx(s);
562 
563 	return val;
564 }
565 
566 static int
567 eso_intr(void *hdl)
568 {
569 	struct eso_softc *sc;
570 	uint8_t irqctl;
571 
572 	sc = hdl;
573 	irqctl = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ESO_IO_IRQCTL);
574 
575 	/* If it wasn't ours, that's all she wrote. */
576 	if ((irqctl & (ESO_IO_IRQCTL_A1IRQ | ESO_IO_IRQCTL_A2IRQ |
577 	    ESO_IO_IRQCTL_HVIRQ | ESO_IO_IRQCTL_MPUIRQ)) == 0)
578 		return 0;
579 
580 	if (irqctl & ESO_IO_IRQCTL_A1IRQ) {
581 		/* Clear interrupt. */
582 		(void)bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh,
583 		    ESO_SB_RBSR);
584 
585 		if (sc->sc_rintr)
586 			sc->sc_rintr(sc->sc_rarg);
587 		else
588 			wakeup(&sc->sc_rintr);
589 	}
590 
591 	if (irqctl & ESO_IO_IRQCTL_A2IRQ) {
592 		/*
593 		 * Clear the A2 IRQ latch: the cached value reflects the
594 		 * current DAC settings with the IRQ latch bit not set.
595 		 */
596 		eso_write_mixreg(sc, ESO_MIXREG_A2C2, sc->sc_a2c2);
597 
598 		if (sc->sc_pintr)
599 			sc->sc_pintr(sc->sc_parg);
600 		else
601 			wakeup(&sc->sc_pintr);
602 	}
603 
604 	if (irqctl & ESO_IO_IRQCTL_HVIRQ) {
605 		/* Clear interrupt. */
606 		eso_write_mixreg(sc, ESO_MIXREG_CHVIR, ESO_MIXREG_CHVIR_CHVIR);
607 
608 		/*
609 		 * Raise a flag to cause a lazy update of the in-softc gain
610 		 * values the next time the software mixer is read to keep
611 		 * interrupt service cost low.  ~0 cannot occur otherwise
612 		 * as the master volume has a precision of 6 bits only.
613 		 */
614 		sc->sc_gain[ESO_MASTER_VOL][ESO_LEFT] = (uint8_t)~0;
615 	}
616 
617 #if NMPU > 0
618 	if ((irqctl & ESO_IO_IRQCTL_MPUIRQ) && sc->sc_mpudev != NULL)
619 		mpu_intr(sc->sc_mpudev);
620 #endif
621 
622 	return 1;
623 }
624 
625 /* Perform a software reset, including DMA FIFOs. */
626 static int
627 eso_reset(struct eso_softc *sc)
628 {
629 	int i;
630 
631 	bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_RESET,
632 	    ESO_SB_RESET_SW | ESO_SB_RESET_FIFO);
633 	/* `Delay' suggested in the data sheet. */
634 	(void)bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_STATUS);
635 	bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_RESET, 0);
636 
637 	/* Wait for reset to take effect. */
638 	for (i = 0; i < ESO_RESET_TIMEOUT; i++) {
639 		/* Poll for data to become available. */
640 		if ((bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh,
641 		    ESO_SB_RBSR) & ESO_SB_RBSR_RDAV) != 0 &&
642 		    bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh,
643 			ESO_SB_RDR) == ESO_SB_RDR_RESETMAGIC) {
644 
645 			/* Activate Solo-1 extension commands. */
646 			eso_write_cmd(sc, ESO_CMD_EXTENB);
647 			/* Reset mixer registers. */
648 			eso_write_mixreg(sc, ESO_MIXREG_RESET,
649 			    ESO_MIXREG_RESET_RESET);
650 
651 			return 0;
652 		} else {
653 			delay(1000);
654 		}
655 	}
656 
657 	printf("%s: reset timeout\n", sc->sc_dev.dv_xname);
658 	return -1;
659 }
660 
661 static int
662 eso_query_encoding(void *hdl, struct audio_encoding *fp)
663 {
664 
665 	switch (fp->index) {
666 	case 0:
667 		strcpy(fp->name, AudioEulinear);
668 		fp->encoding = AUDIO_ENCODING_ULINEAR;
669 		fp->precision = 8;
670 		fp->flags = 0;
671 		break;
672 	case 1:
673 		strcpy(fp->name, AudioEmulaw);
674 		fp->encoding = AUDIO_ENCODING_ULAW;
675 		fp->precision = 8;
676 		fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
677 		break;
678 	case 2:
679 		strcpy(fp->name, AudioEalaw);
680 		fp->encoding = AUDIO_ENCODING_ALAW;
681 		fp->precision = 8;
682 		fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
683 		break;
684 	case 3:
685 		strcpy(fp->name, AudioEslinear);
686 		fp->encoding = AUDIO_ENCODING_SLINEAR;
687 		fp->precision = 8;
688 		fp->flags = 0;
689 		break;
690 	case 4:
691 		strcpy(fp->name, AudioEslinear_le);
692 		fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
693 		fp->precision = 16;
694 		fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
695 		break;
696 	case 5:
697 		strcpy(fp->name, AudioEulinear_le);
698 		fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
699 		fp->precision = 16;
700 		fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
701 		break;
702 	case 6:
703 		strcpy(fp->name, AudioEslinear_be);
704 		fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
705 		fp->precision = 16;
706 		fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
707 		break;
708 	case 7:
709 		strcpy(fp->name, AudioEulinear_be);
710 		fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
711 		fp->precision = 16;
712 		fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
713 		break;
714 	default:
715 		return EINVAL;
716 	}
717 
718 	return 0;
719 }
720 
721 static int
722 eso_set_params(void *hdl, int setmode, int usemode,
723     audio_params_t *play, audio_params_t *rec, stream_filter_list_t *pfil,
724     stream_filter_list_t *rfil)
725 {
726 	struct eso_softc *sc;
727 	struct audio_params *p;
728 	stream_filter_list_t *fil;
729 	int mode, r[2], rd[2], ar[2], clk;
730 	unsigned int srg, fltdiv;
731 	int i;
732 
733 	sc = hdl;
734 	for (mode = AUMODE_RECORD; mode != -1;
735 	     mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
736 		if ((setmode & mode) == 0)
737 			continue;
738 
739 		p = (mode == AUMODE_PLAY) ? play : rec;
740 
741 		if (p->sample_rate < ESO_MINRATE ||
742 		    p->sample_rate > ESO_MAXRATE ||
743 		    (p->precision != 8 && p->precision != 16) ||
744 		    (p->channels != 1 && p->channels != 2))
745 			return EINVAL;
746 
747 		/*
748 		 * We'll compute both possible sample rate dividers and pick
749 		 * the one with the least error.
750 		 */
751 #define ABS(x) ((x) < 0 ? -(x) : (x))
752 		r[0] = ESO_CLK0 /
753 		    (128 - (rd[0] = 128 - ESO_CLK0 / p->sample_rate));
754 		r[1] = ESO_CLK1 /
755 		    (128 - (rd[1] = 128 - ESO_CLK1 / p->sample_rate));
756 
757 		ar[0] = p->sample_rate - r[0];
758 		ar[1] = p->sample_rate - r[1];
759 		clk = ABS(ar[0]) > ABS(ar[1]) ? 1 : 0;
760 		srg = rd[clk] | (clk == 1 ? ESO_CLK1_SELECT : 0x00);
761 
762 		/* Roll-off frequency of 87%, as in the ES1888 driver. */
763 		fltdiv = 256 - 200279L / r[clk];
764 
765 		/* Update to reflect the possibly inexact rate. */
766 		p->sample_rate = r[clk];
767 
768 		fil = (mode == AUMODE_PLAY) ? pfil : rfil;
769 		i = auconv_set_converter(eso_formats, ESO_NFORMATS,
770 					 mode, p, FALSE, fil);
771 		if (i < 0)
772 			return EINVAL;
773 		if (mode == AUMODE_RECORD) {
774 			/* Audio 1 */
775 			DPRINTF(("A1 srg 0x%02x fdiv 0x%02x\n", srg, fltdiv));
776 			eso_write_ctlreg(sc, ESO_CTLREG_SRG, srg);
777 			eso_write_ctlreg(sc, ESO_CTLREG_FLTDIV, fltdiv);
778 		} else {
779 			/* Audio 2 */
780 			DPRINTF(("A2 srg 0x%02x fdiv 0x%02x\n", srg, fltdiv));
781 			eso_write_mixreg(sc, ESO_MIXREG_A2SRG, srg);
782 			eso_write_mixreg(sc, ESO_MIXREG_A2FLTDIV, fltdiv);
783 		}
784 #undef ABS
785 
786 	}
787 
788 	return 0;
789 }
790 
791 static int
792 eso_round_blocksize(void *hdl, int blk, int mode,
793     const audio_params_t *param)
794 {
795 
796 	return blk & -32;	/* keep good alignment; at least 16 req'd */
797 }
798 
799 static int
800 eso_halt_output(void *hdl)
801 {
802 	struct eso_softc *sc;
803 	int error, s;
804 
805 	sc = hdl;
806 	DPRINTF(("%s: halt_output\n", sc->sc_dev.dv_xname));
807 
808 	/*
809 	 * Disable auto-initialize DMA, allowing the FIFO to drain and then
810 	 * stop.  The interrupt callback pointer is cleared at this
811 	 * point so that an outstanding FIFO interrupt for the remaining data
812 	 * will be acknowledged without further processing.
813 	 *
814 	 * This does not immediately `abort' an operation in progress (c.f.
815 	 * audio(9)) but is the method to leave the FIFO behind in a clean
816 	 * state with the least hair.  (Besides, that item needs to be
817 	 * rephrased for trigger_*()-based DMA environments.)
818 	 */
819 	s = splaudio();
820 	eso_write_mixreg(sc, ESO_MIXREG_A2C1,
821 	    ESO_MIXREG_A2C1_FIFOENB | ESO_MIXREG_A2C1_DMAENB);
822 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM,
823 	    ESO_IO_A2DMAM_DMAENB);
824 
825 	sc->sc_pintr = NULL;
826 	error = tsleep(&sc->sc_pintr, PCATCH | PWAIT, "esoho", sc->sc_pdrain);
827 	splx(s);
828 
829 	/* Shut down DMA completely. */
830 	eso_write_mixreg(sc, ESO_MIXREG_A2C1, 0);
831 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM, 0);
832 
833 	return error == EWOULDBLOCK ? 0 : error;
834 }
835 
836 static int
837 eso_halt_input(void *hdl)
838 {
839 	struct eso_softc *sc;
840 	int error, s;
841 
842 	sc = hdl;
843 	DPRINTF(("%s: halt_input\n", sc->sc_dev.dv_xname));
844 
845 	/* Just like eso_halt_output(), but for Audio 1. */
846 	s = splaudio();
847 	eso_write_ctlreg(sc, ESO_CTLREG_A1C2,
848 	    ESO_CTLREG_A1C2_READ | ESO_CTLREG_A1C2_ADC |
849 	    ESO_CTLREG_A1C2_DMAENB);
850 	bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MODE,
851 	    DMA37MD_WRITE | DMA37MD_DEMAND);
852 
853 	sc->sc_rintr = NULL;
854 	error = tsleep(&sc->sc_rintr, PCATCH | PWAIT, "esohi", sc->sc_rdrain);
855 	splx(s);
856 
857 	/* Shut down DMA completely. */
858 	eso_write_ctlreg(sc, ESO_CTLREG_A1C2,
859 	    ESO_CTLREG_A1C2_READ | ESO_CTLREG_A1C2_ADC);
860 	bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK,
861 	    ESO_DMAC_MASK_MASK);
862 
863 	return error == EWOULDBLOCK ? 0 : error;
864 }
865 
866 static int
867 eso_getdev(void *hdl, struct audio_device *retp)
868 {
869 	struct eso_softc *sc;
870 
871 	sc = hdl;
872 	strncpy(retp->name, "ESS Solo-1", sizeof (retp->name));
873 	snprintf(retp->version, sizeof (retp->version), "0x%02x",
874 	    sc->sc_revision);
875 	if (sc->sc_revision <
876 	    sizeof (eso_rev2model) / sizeof (eso_rev2model[0]))
877 		strncpy(retp->config, eso_rev2model[sc->sc_revision],
878 		    sizeof (retp->config));
879 	else
880 		strncpy(retp->config, "unknown", sizeof (retp->config));
881 
882 	return 0;
883 }
884 
885 static int
886 eso_set_port(void *hdl, mixer_ctrl_t *cp)
887 {
888 	struct eso_softc *sc;
889 	unsigned int lgain, rgain;
890 	uint8_t tmp;
891 
892 	sc = hdl;
893 	switch (cp->dev) {
894 	case ESO_DAC_PLAY_VOL:
895 	case ESO_MIC_PLAY_VOL:
896 	case ESO_LINE_PLAY_VOL:
897 	case ESO_SYNTH_PLAY_VOL:
898 	case ESO_CD_PLAY_VOL:
899 	case ESO_AUXB_PLAY_VOL:
900 	case ESO_RECORD_VOL:
901 	case ESO_DAC_REC_VOL:
902 	case ESO_MIC_REC_VOL:
903 	case ESO_LINE_REC_VOL:
904 	case ESO_SYNTH_REC_VOL:
905 	case ESO_CD_REC_VOL:
906 	case ESO_AUXB_REC_VOL:
907 		if (cp->type != AUDIO_MIXER_VALUE)
908 			return EINVAL;
909 
910 		/*
911 		 * Stereo-capable mixer ports: if we get a single-channel
912 		 * gain value passed in, then we duplicate it to both left
913 		 * and right channels.
914 		 */
915 		switch (cp->un.value.num_channels) {
916 		case 1:
917 			lgain = rgain = ESO_GAIN_TO_4BIT(
918 			    cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
919 			break;
920 		case 2:
921 			lgain = ESO_GAIN_TO_4BIT(
922 			    cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
923 			rgain = ESO_GAIN_TO_4BIT(
924 			    cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
925 			break;
926 		default:
927 			return EINVAL;
928 		}
929 
930 		sc->sc_gain[cp->dev][ESO_LEFT] = lgain;
931 		sc->sc_gain[cp->dev][ESO_RIGHT] = rgain;
932 		eso_set_gain(sc, cp->dev);
933 		break;
934 
935 	case ESO_MASTER_VOL:
936 		if (cp->type != AUDIO_MIXER_VALUE)
937 			return EINVAL;
938 
939 		/* Like above, but a precision of 6 bits. */
940 		switch (cp->un.value.num_channels) {
941 		case 1:
942 			lgain = rgain = ESO_GAIN_TO_6BIT(
943 			    cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
944 			break;
945 		case 2:
946 			lgain = ESO_GAIN_TO_6BIT(
947 			    cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
948 			rgain = ESO_GAIN_TO_6BIT(
949 			    cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
950 			break;
951 		default:
952 			return EINVAL;
953 		}
954 
955 		sc->sc_gain[cp->dev][ESO_LEFT] = lgain;
956 		sc->sc_gain[cp->dev][ESO_RIGHT] = rgain;
957 		eso_set_gain(sc, cp->dev);
958 		break;
959 
960 	case ESO_SPATIALIZER:
961 		if (cp->type != AUDIO_MIXER_VALUE ||
962 		    cp->un.value.num_channels != 1)
963 			return EINVAL;
964 
965 		sc->sc_gain[cp->dev][ESO_LEFT] =
966 		    sc->sc_gain[cp->dev][ESO_RIGHT] =
967 		    ESO_GAIN_TO_6BIT(
968 			cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
969 		eso_set_gain(sc, cp->dev);
970 		break;
971 
972 	case ESO_MONO_PLAY_VOL:
973 	case ESO_MONO_REC_VOL:
974 		if (cp->type != AUDIO_MIXER_VALUE ||
975 		    cp->un.value.num_channels != 1)
976 			return EINVAL;
977 
978 		sc->sc_gain[cp->dev][ESO_LEFT] =
979 		    sc->sc_gain[cp->dev][ESO_RIGHT] =
980 		    ESO_GAIN_TO_4BIT(
981 			cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
982 		eso_set_gain(sc, cp->dev);
983 		break;
984 
985 	case ESO_PCSPEAKER_VOL:
986 		if (cp->type != AUDIO_MIXER_VALUE ||
987 		    cp->un.value.num_channels != 1)
988 			return EINVAL;
989 
990 		sc->sc_gain[cp->dev][ESO_LEFT] =
991 		    sc->sc_gain[cp->dev][ESO_RIGHT] =
992 		    ESO_GAIN_TO_3BIT(
993 			cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
994 		eso_set_gain(sc, cp->dev);
995 		break;
996 
997 	case ESO_SPATIALIZER_ENABLE:
998 		if (cp->type != AUDIO_MIXER_ENUM)
999 			return EINVAL;
1000 
1001 		sc->sc_spatializer = (cp->un.ord != 0);
1002 
1003 		tmp = eso_read_mixreg(sc, ESO_MIXREG_SPAT);
1004 		if (sc->sc_spatializer)
1005 			tmp |= ESO_MIXREG_SPAT_ENB;
1006 		else
1007 			tmp &= ~ESO_MIXREG_SPAT_ENB;
1008 		eso_write_mixreg(sc, ESO_MIXREG_SPAT,
1009 		    tmp | ESO_MIXREG_SPAT_RSTREL);
1010 		break;
1011 
1012 	case ESO_MASTER_MUTE:
1013 		if (cp->type != AUDIO_MIXER_ENUM)
1014 			return EINVAL;
1015 
1016 		sc->sc_mvmute = (cp->un.ord != 0);
1017 
1018 		if (sc->sc_mvmute) {
1019 			eso_write_mixreg(sc, ESO_MIXREG_LMVM,
1020 			    eso_read_mixreg(sc, ESO_MIXREG_LMVM) |
1021 			    ESO_MIXREG_LMVM_MUTE);
1022 			eso_write_mixreg(sc, ESO_MIXREG_RMVM,
1023 			    eso_read_mixreg(sc, ESO_MIXREG_RMVM) |
1024 			    ESO_MIXREG_RMVM_MUTE);
1025 		} else {
1026 			eso_write_mixreg(sc, ESO_MIXREG_LMVM,
1027 			    eso_read_mixreg(sc, ESO_MIXREG_LMVM) &
1028 			    ~ESO_MIXREG_LMVM_MUTE);
1029 			eso_write_mixreg(sc, ESO_MIXREG_RMVM,
1030 			    eso_read_mixreg(sc, ESO_MIXREG_RMVM) &
1031 			    ~ESO_MIXREG_RMVM_MUTE);
1032 		}
1033 		break;
1034 
1035 	case ESO_MONOOUT_SOURCE:
1036 		if (cp->type != AUDIO_MIXER_ENUM)
1037 			return EINVAL;
1038 
1039 		return eso_set_monooutsrc(sc, cp->un.ord);
1040 
1041 	case ESO_MONOIN_BYPASS:
1042 		if (cp->type != AUDIO_MIXER_ENUM)
1043 			return EINVAL;
1044 
1045 		return (eso_set_monoinbypass(sc, cp->un.ord));
1046 
1047 	case ESO_RECORD_MONITOR:
1048 		if (cp->type != AUDIO_MIXER_ENUM)
1049 			return EINVAL;
1050 
1051 		sc->sc_recmon = (cp->un.ord != 0);
1052 
1053 		tmp = eso_read_ctlreg(sc, ESO_CTLREG_ACTL);
1054 		if (sc->sc_recmon)
1055 			tmp |= ESO_CTLREG_ACTL_RECMON;
1056 		else
1057 			tmp &= ~ESO_CTLREG_ACTL_RECMON;
1058 		eso_write_ctlreg(sc, ESO_CTLREG_ACTL, tmp);
1059 		break;
1060 
1061 	case ESO_RECORD_SOURCE:
1062 		if (cp->type != AUDIO_MIXER_ENUM)
1063 			return EINVAL;
1064 
1065 		return eso_set_recsrc(sc, cp->un.ord);
1066 
1067 	case ESO_MIC_PREAMP:
1068 		if (cp->type != AUDIO_MIXER_ENUM)
1069 			return EINVAL;
1070 
1071 		return eso_set_preamp(sc, cp->un.ord);
1072 
1073 	default:
1074 		return EINVAL;
1075 	}
1076 
1077 	return 0;
1078 }
1079 
1080 static int
1081 eso_get_port(void *hdl, mixer_ctrl_t *cp)
1082 {
1083 	struct eso_softc *sc;
1084 
1085 	sc = hdl;
1086 	switch (cp->dev) {
1087 	case ESO_MASTER_VOL:
1088 		/* Reload from mixer after hardware volume control use. */
1089 		if (sc->sc_gain[cp->dev][ESO_LEFT] == (uint8_t)~0)
1090 			eso_reload_master_vol(sc);
1091 		/* FALLTHROUGH */
1092 	case ESO_DAC_PLAY_VOL:
1093 	case ESO_MIC_PLAY_VOL:
1094 	case ESO_LINE_PLAY_VOL:
1095 	case ESO_SYNTH_PLAY_VOL:
1096 	case ESO_CD_PLAY_VOL:
1097 	case ESO_AUXB_PLAY_VOL:
1098 	case ESO_RECORD_VOL:
1099 	case ESO_DAC_REC_VOL:
1100 	case ESO_MIC_REC_VOL:
1101 	case ESO_LINE_REC_VOL:
1102 	case ESO_SYNTH_REC_VOL:
1103 	case ESO_CD_REC_VOL:
1104 	case ESO_AUXB_REC_VOL:
1105 		/*
1106 		 * Stereo-capable ports: if a single-channel query is made,
1107 		 * just return the left channel's value (since single-channel
1108 		 * settings themselves are applied to both channels).
1109 		 */
1110 		switch (cp->un.value.num_channels) {
1111 		case 1:
1112 			cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
1113 			    sc->sc_gain[cp->dev][ESO_LEFT];
1114 			break;
1115 		case 2:
1116 			cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
1117 			    sc->sc_gain[cp->dev][ESO_LEFT];
1118 			cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
1119 			    sc->sc_gain[cp->dev][ESO_RIGHT];
1120 			break;
1121 		default:
1122 			return EINVAL;
1123 		}
1124 		break;
1125 
1126 	case ESO_MONO_PLAY_VOL:
1127 	case ESO_PCSPEAKER_VOL:
1128 	case ESO_MONO_REC_VOL:
1129 	case ESO_SPATIALIZER:
1130 		if (cp->un.value.num_channels != 1)
1131 			return EINVAL;
1132 		cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
1133 		    sc->sc_gain[cp->dev][ESO_LEFT];
1134 		break;
1135 
1136 	case ESO_RECORD_MONITOR:
1137 		cp->un.ord = sc->sc_recmon;
1138 		break;
1139 
1140 	case ESO_RECORD_SOURCE:
1141 		cp->un.ord = sc->sc_recsrc;
1142 		break;
1143 
1144 	case ESO_MONOOUT_SOURCE:
1145 		cp->un.ord = sc->sc_monooutsrc;
1146 		break;
1147 
1148 	case ESO_MONOIN_BYPASS:
1149 		cp->un.ord = sc->sc_monoinbypass;
1150 		break;
1151 
1152 	case ESO_SPATIALIZER_ENABLE:
1153 		cp->un.ord = sc->sc_spatializer;
1154 		break;
1155 
1156 	case ESO_MIC_PREAMP:
1157 		cp->un.ord = sc->sc_preamp;
1158 		break;
1159 
1160 	case ESO_MASTER_MUTE:
1161 		/* Reload from mixer after hardware volume control use. */
1162 		if (sc->sc_gain[ESO_MASTER_VOL][ESO_LEFT] == (uint8_t)~0)
1163 			eso_reload_master_vol(sc);
1164 		cp->un.ord = sc->sc_mvmute;
1165 		break;
1166 
1167 	default:
1168 		return EINVAL;
1169 	}
1170 
1171 	return 0;
1172 }
1173 
1174 static int
1175 eso_query_devinfo(void *hdl, mixer_devinfo_t *dip)
1176 {
1177 
1178 	switch (dip->index) {
1179 	case ESO_DAC_PLAY_VOL:
1180 		dip->mixer_class = ESO_INPUT_CLASS;
1181 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1182 		strcpy(dip->label.name, AudioNdac);
1183 		dip->type = AUDIO_MIXER_VALUE;
1184 		dip->un.v.num_channels = 2;
1185 		strcpy(dip->un.v.units.name, AudioNvolume);
1186 		break;
1187 	case ESO_MIC_PLAY_VOL:
1188 		dip->mixer_class = ESO_INPUT_CLASS;
1189 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1190 		strcpy(dip->label.name, AudioNmicrophone);
1191 		dip->type = AUDIO_MIXER_VALUE;
1192 		dip->un.v.num_channels = 2;
1193 		strcpy(dip->un.v.units.name, AudioNvolume);
1194 		break;
1195 	case ESO_LINE_PLAY_VOL:
1196 		dip->mixer_class = ESO_INPUT_CLASS;
1197 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1198 		strcpy(dip->label.name, AudioNline);
1199 		dip->type = AUDIO_MIXER_VALUE;
1200 		dip->un.v.num_channels = 2;
1201 		strcpy(dip->un.v.units.name, AudioNvolume);
1202 		break;
1203 	case ESO_SYNTH_PLAY_VOL:
1204 		dip->mixer_class = ESO_INPUT_CLASS;
1205 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1206 		strcpy(dip->label.name, AudioNfmsynth);
1207 		dip->type = AUDIO_MIXER_VALUE;
1208 		dip->un.v.num_channels = 2;
1209 		strcpy(dip->un.v.units.name, AudioNvolume);
1210 		break;
1211 	case ESO_MONO_PLAY_VOL:
1212 		dip->mixer_class = ESO_INPUT_CLASS;
1213 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1214 		strcpy(dip->label.name, "mono_in");
1215 		dip->type = AUDIO_MIXER_VALUE;
1216 		dip->un.v.num_channels = 1;
1217 		strcpy(dip->un.v.units.name, AudioNvolume);
1218 		break;
1219 	case ESO_CD_PLAY_VOL:
1220 		dip->mixer_class = ESO_INPUT_CLASS;
1221 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1222 		strcpy(dip->label.name, AudioNcd);
1223 		dip->type = AUDIO_MIXER_VALUE;
1224 		dip->un.v.num_channels = 2;
1225 		strcpy(dip->un.v.units.name, AudioNvolume);
1226 		break;
1227 	case ESO_AUXB_PLAY_VOL:
1228 		dip->mixer_class = ESO_INPUT_CLASS;
1229 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1230 		strcpy(dip->label.name, "auxb");
1231 		dip->type = AUDIO_MIXER_VALUE;
1232 		dip->un.v.num_channels = 2;
1233 		strcpy(dip->un.v.units.name, AudioNvolume);
1234 		break;
1235 
1236 	case ESO_MIC_PREAMP:
1237 		dip->mixer_class = ESO_MICROPHONE_CLASS;
1238 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1239 		strcpy(dip->label.name, AudioNpreamp);
1240 		dip->type = AUDIO_MIXER_ENUM;
1241 		dip->un.e.num_mem = 2;
1242 		strcpy(dip->un.e.member[0].label.name, AudioNoff);
1243 		dip->un.e.member[0].ord = 0;
1244 		strcpy(dip->un.e.member[1].label.name, AudioNon);
1245 		dip->un.e.member[1].ord = 1;
1246 		break;
1247 	case ESO_MICROPHONE_CLASS:
1248 		dip->mixer_class = ESO_MICROPHONE_CLASS;
1249 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1250 		strcpy(dip->label.name, AudioNmicrophone);
1251 		dip->type = AUDIO_MIXER_CLASS;
1252 		break;
1253 
1254 	case ESO_INPUT_CLASS:
1255 		dip->mixer_class = ESO_INPUT_CLASS;
1256 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1257 		strcpy(dip->label.name, AudioCinputs);
1258 		dip->type = AUDIO_MIXER_CLASS;
1259 		break;
1260 
1261 	case ESO_MASTER_VOL:
1262 		dip->mixer_class = ESO_OUTPUT_CLASS;
1263 		dip->prev = AUDIO_MIXER_LAST;
1264 		dip->next = ESO_MASTER_MUTE;
1265 		strcpy(dip->label.name, AudioNmaster);
1266 		dip->type = AUDIO_MIXER_VALUE;
1267 		dip->un.v.num_channels = 2;
1268 		strcpy(dip->un.v.units.name, AudioNvolume);
1269 		break;
1270 	case ESO_MASTER_MUTE:
1271 		dip->mixer_class = ESO_OUTPUT_CLASS;
1272 		dip->prev = ESO_MASTER_VOL;
1273 		dip->next = AUDIO_MIXER_LAST;
1274 		strcpy(dip->label.name, AudioNmute);
1275 		dip->type = AUDIO_MIXER_ENUM;
1276 		dip->un.e.num_mem = 2;
1277 		strcpy(dip->un.e.member[0].label.name, AudioNoff);
1278 		dip->un.e.member[0].ord = 0;
1279 		strcpy(dip->un.e.member[1].label.name, AudioNon);
1280 		dip->un.e.member[1].ord = 1;
1281 		break;
1282 
1283 	case ESO_PCSPEAKER_VOL:
1284 		dip->mixer_class = ESO_OUTPUT_CLASS;
1285 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1286 		strcpy(dip->label.name, "pc_speaker");
1287 		dip->type = AUDIO_MIXER_VALUE;
1288 		dip->un.v.num_channels = 1;
1289 		strcpy(dip->un.v.units.name, AudioNvolume);
1290 		break;
1291 	case ESO_MONOOUT_SOURCE:
1292 		dip->mixer_class = ESO_OUTPUT_CLASS;
1293 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1294 		strcpy(dip->label.name, "mono_out");
1295 		dip->type = AUDIO_MIXER_ENUM;
1296 		dip->un.e.num_mem = 3;
1297 		strcpy(dip->un.e.member[0].label.name, AudioNmute);
1298 		dip->un.e.member[0].ord = ESO_MIXREG_MPM_MOMUTE;
1299 		strcpy(dip->un.e.member[1].label.name, AudioNdac);
1300 		dip->un.e.member[1].ord = ESO_MIXREG_MPM_MOA2R;
1301 		strcpy(dip->un.e.member[2].label.name, AudioNmixerout);
1302 		dip->un.e.member[2].ord = ESO_MIXREG_MPM_MOREC;
1303 		break;
1304 
1305 	case ESO_MONOIN_BYPASS:
1306 		dip->mixer_class = ESO_MONOIN_CLASS;
1307 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1308 		strcpy(dip->label.name, "bypass");
1309 		dip->type = AUDIO_MIXER_ENUM;
1310 		dip->un.e.num_mem = 2;
1311 		strcpy(dip->un.e.member[0].label.name, AudioNoff);
1312 		dip->un.e.member[0].ord = 0;
1313 		strcpy(dip->un.e.member[1].label.name, AudioNon);
1314 		dip->un.e.member[1].ord = 1;
1315 		break;
1316 	case ESO_MONOIN_CLASS:
1317 		dip->mixer_class = ESO_MONOIN_CLASS;
1318 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1319 		strcpy(dip->label.name, "mono_in");
1320 		dip->type = AUDIO_MIXER_CLASS;
1321 		break;
1322 
1323 	case ESO_SPATIALIZER:
1324 		dip->mixer_class = ESO_OUTPUT_CLASS;
1325 		dip->prev = AUDIO_MIXER_LAST;
1326 		dip->next = ESO_SPATIALIZER_ENABLE;
1327 		strcpy(dip->label.name, AudioNspatial);
1328 		dip->type = AUDIO_MIXER_VALUE;
1329 		dip->un.v.num_channels = 1;
1330 		strcpy(dip->un.v.units.name, "level");
1331 		break;
1332 	case ESO_SPATIALIZER_ENABLE:
1333 		dip->mixer_class = ESO_OUTPUT_CLASS;
1334 		dip->prev = ESO_SPATIALIZER;
1335 		dip->next = AUDIO_MIXER_LAST;
1336 		strcpy(dip->label.name, "enable");
1337 		dip->type = AUDIO_MIXER_ENUM;
1338 		dip->un.e.num_mem = 2;
1339 		strcpy(dip->un.e.member[0].label.name, AudioNoff);
1340 		dip->un.e.member[0].ord = 0;
1341 		strcpy(dip->un.e.member[1].label.name, AudioNon);
1342 		dip->un.e.member[1].ord = 1;
1343 		break;
1344 
1345 	case ESO_OUTPUT_CLASS:
1346 		dip->mixer_class = ESO_OUTPUT_CLASS;
1347 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1348 		strcpy(dip->label.name, AudioCoutputs);
1349 		dip->type = AUDIO_MIXER_CLASS;
1350 		break;
1351 
1352 	case ESO_RECORD_MONITOR:
1353 		dip->mixer_class = ESO_MONITOR_CLASS;
1354 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1355 		strcpy(dip->label.name, AudioNmute);
1356 		dip->type = AUDIO_MIXER_ENUM;
1357 		dip->un.e.num_mem = 2;
1358 		strcpy(dip->un.e.member[0].label.name, AudioNoff);
1359 		dip->un.e.member[0].ord = 0;
1360 		strcpy(dip->un.e.member[1].label.name, AudioNon);
1361 		dip->un.e.member[1].ord = 1;
1362 		break;
1363 	case ESO_MONITOR_CLASS:
1364 		dip->mixer_class = ESO_MONITOR_CLASS;
1365 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1366 		strcpy(dip->label.name, AudioCmonitor);
1367 		dip->type = AUDIO_MIXER_CLASS;
1368 		break;
1369 
1370 	case ESO_RECORD_VOL:
1371 		dip->mixer_class = ESO_RECORD_CLASS;
1372 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1373 		strcpy(dip->label.name, AudioNrecord);
1374 		dip->type = AUDIO_MIXER_VALUE;
1375 		strcpy(dip->un.v.units.name, AudioNvolume);
1376 		break;
1377 	case ESO_RECORD_SOURCE:
1378 		dip->mixer_class = ESO_RECORD_CLASS;
1379 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1380 		strcpy(dip->label.name, AudioNsource);
1381 		dip->type = AUDIO_MIXER_ENUM;
1382 		dip->un.e.num_mem = 4;
1383 		strcpy(dip->un.e.member[0].label.name, AudioNmicrophone);
1384 		dip->un.e.member[0].ord = ESO_MIXREG_ERS_MIC;
1385 		strcpy(dip->un.e.member[1].label.name, AudioNline);
1386 		dip->un.e.member[1].ord = ESO_MIXREG_ERS_LINE;
1387 		strcpy(dip->un.e.member[2].label.name, AudioNcd);
1388 		dip->un.e.member[2].ord = ESO_MIXREG_ERS_CD;
1389 		strcpy(dip->un.e.member[3].label.name, AudioNmixerout);
1390 		dip->un.e.member[3].ord = ESO_MIXREG_ERS_MIXER;
1391 		break;
1392 	case ESO_DAC_REC_VOL:
1393 		dip->mixer_class = ESO_RECORD_CLASS;
1394 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1395 		strcpy(dip->label.name, AudioNdac);
1396 		dip->type = AUDIO_MIXER_VALUE;
1397 		dip->un.v.num_channels = 2;
1398 		strcpy(dip->un.v.units.name, AudioNvolume);
1399 		break;
1400 	case ESO_MIC_REC_VOL:
1401 		dip->mixer_class = ESO_RECORD_CLASS;
1402 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1403 		strcpy(dip->label.name, AudioNmicrophone);
1404 		dip->type = AUDIO_MIXER_VALUE;
1405 		dip->un.v.num_channels = 2;
1406 		strcpy(dip->un.v.units.name, AudioNvolume);
1407 		break;
1408 	case ESO_LINE_REC_VOL:
1409 		dip->mixer_class = ESO_RECORD_CLASS;
1410 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1411 		strcpy(dip->label.name, AudioNline);
1412 		dip->type = AUDIO_MIXER_VALUE;
1413 		dip->un.v.num_channels = 2;
1414 		strcpy(dip->un.v.units.name, AudioNvolume);
1415 		break;
1416 	case ESO_SYNTH_REC_VOL:
1417 		dip->mixer_class = ESO_RECORD_CLASS;
1418 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1419 		strcpy(dip->label.name, AudioNfmsynth);
1420 		dip->type = AUDIO_MIXER_VALUE;
1421 		dip->un.v.num_channels = 2;
1422 		strcpy(dip->un.v.units.name, AudioNvolume);
1423 		break;
1424 	case ESO_MONO_REC_VOL:
1425 		dip->mixer_class = ESO_RECORD_CLASS;
1426 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1427 		strcpy(dip->label.name, "mono_in");
1428 		dip->type = AUDIO_MIXER_VALUE;
1429 		dip->un.v.num_channels = 1; /* No lies */
1430 		strcpy(dip->un.v.units.name, AudioNvolume);
1431 		break;
1432 	case ESO_CD_REC_VOL:
1433 		dip->mixer_class = ESO_RECORD_CLASS;
1434 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1435 		strcpy(dip->label.name, AudioNcd);
1436 		dip->type = AUDIO_MIXER_VALUE;
1437 		dip->un.v.num_channels = 2;
1438 		strcpy(dip->un.v.units.name, AudioNvolume);
1439 		break;
1440 	case ESO_AUXB_REC_VOL:
1441 		dip->mixer_class = ESO_RECORD_CLASS;
1442 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1443 		strcpy(dip->label.name, "auxb");
1444 		dip->type = AUDIO_MIXER_VALUE;
1445 		dip->un.v.num_channels = 2;
1446 		strcpy(dip->un.v.units.name, AudioNvolume);
1447 		break;
1448 	case ESO_RECORD_CLASS:
1449 		dip->mixer_class = ESO_RECORD_CLASS;
1450 		dip->next = dip->prev = AUDIO_MIXER_LAST;
1451 		strcpy(dip->label.name, AudioCrecord);
1452 		dip->type = AUDIO_MIXER_CLASS;
1453 		break;
1454 
1455 	default:
1456 		return ENXIO;
1457 	}
1458 
1459 	return 0;
1460 }
1461 
1462 static int
1463 eso_allocmem(struct eso_softc *sc, size_t size, size_t align,
1464     size_t boundary, int flags, int direction, struct eso_dma *ed)
1465 {
1466 	int error, wait;
1467 
1468 	wait = (flags & M_NOWAIT) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
1469 	ed->ed_size = size;
1470 
1471 	error = bus_dmamem_alloc(ed->ed_dmat, ed->ed_size, align, boundary,
1472 	    ed->ed_segs, sizeof (ed->ed_segs) / sizeof (ed->ed_segs[0]),
1473 	    &ed->ed_nsegs, wait);
1474 	if (error)
1475 		goto out;
1476 
1477 	error = bus_dmamem_map(ed->ed_dmat, ed->ed_segs, ed->ed_nsegs,
1478 	    ed->ed_size, &ed->ed_kva, wait | BUS_DMA_COHERENT);
1479 	if (error)
1480 		goto free;
1481 
1482 	error = bus_dmamap_create(ed->ed_dmat, ed->ed_size, 1, ed->ed_size, 0,
1483 	    wait, &ed->ed_map);
1484 	if (error)
1485 		goto unmap;
1486 
1487 	error = bus_dmamap_load(ed->ed_dmat, ed->ed_map, ed->ed_kva,
1488 	    ed->ed_size, NULL, wait |
1489 	    (direction == AUMODE_RECORD) ? BUS_DMA_READ : BUS_DMA_WRITE);
1490 	if (error)
1491 		goto destroy;
1492 
1493 	return 0;
1494 
1495  destroy:
1496 	bus_dmamap_destroy(ed->ed_dmat, ed->ed_map);
1497  unmap:
1498 	bus_dmamem_unmap(ed->ed_dmat, ed->ed_kva, ed->ed_size);
1499  free:
1500 	bus_dmamem_free(ed->ed_dmat, ed->ed_segs, ed->ed_nsegs);
1501  out:
1502 	return error;
1503 }
1504 
1505 static void
1506 eso_freemem(struct eso_dma *ed)
1507 {
1508 
1509 	bus_dmamap_unload(ed->ed_dmat, ed->ed_map);
1510 	bus_dmamap_destroy(ed->ed_dmat, ed->ed_map);
1511 	bus_dmamem_unmap(ed->ed_dmat, ed->ed_kva, ed->ed_size);
1512 	bus_dmamem_free(ed->ed_dmat, ed->ed_segs, ed->ed_nsegs);
1513 }
1514 
1515 static struct eso_dma *
1516 eso_kva2dma(const struct eso_softc *sc, const void *kva)
1517 {
1518 	struct eso_dma *p;
1519 
1520 	SLIST_FOREACH(p, &sc->sc_dmas, ed_slist) {
1521 		if (KVADDR(p) == kva)
1522 			return p;
1523 	}
1524 
1525 	panic("%s: kva2dma: bad kva: %p", sc->sc_dev.dv_xname, kva);
1526 	/* NOTREACHED */
1527 }
1528 
1529 static void *
1530 eso_allocm(void *hdl, int direction, size_t size, struct malloc_type *type,
1531     int flags)
1532 {
1533 	struct eso_softc *sc;
1534 	struct eso_dma *ed;
1535 	size_t boundary;
1536 	int error;
1537 
1538 	sc = hdl;
1539 	if ((ed = malloc(sizeof (*ed), type, flags)) == NULL)
1540 		return NULL;
1541 
1542 	/*
1543 	 * Apparently the Audio 1 DMA controller's current address
1544 	 * register can't roll over a 64K address boundary, so we have to
1545 	 * take care of that ourselves.  Similarly, the Audio 2 DMA
1546 	 * controller needs a 1M address boundary.
1547 	 */
1548 	if (direction == AUMODE_RECORD)
1549 		boundary = 0x10000;
1550 	else
1551 		boundary = 0x100000;
1552 
1553 	/*
1554 	 * XXX Work around allocation problems for Audio 1, which
1555 	 * XXX implements the 24 low address bits only, with
1556 	 * XXX machine-specific DMA tag use.
1557 	 */
1558 #ifdef alpha
1559 	/*
1560 	 * XXX Force allocation through the (ISA) SGMAP.
1561 	 */
1562 	if (direction == AUMODE_RECORD)
1563 		ed->ed_dmat = alphabus_dma_get_tag(sc->sc_dmat, ALPHA_BUS_ISA);
1564 	else
1565 #elif defined(amd64) || defined(i386)
1566 	/*
1567 	 * XXX Force allocation through the ISA DMA tag.
1568 	 */
1569 	if (direction == AUMODE_RECORD)
1570 		ed->ed_dmat = &isa_bus_dma_tag;
1571 	else
1572 #endif
1573 		ed->ed_dmat = sc->sc_dmat;
1574 
1575 	error = eso_allocmem(sc, size, 32, boundary, flags, direction, ed);
1576 	if (error) {
1577 		free(ed, type);
1578 		return NULL;
1579 	}
1580 	SLIST_INSERT_HEAD(&sc->sc_dmas, ed, ed_slist);
1581 
1582 	return KVADDR(ed);
1583 }
1584 
1585 static void
1586 eso_freem(void *hdl, void *addr, struct malloc_type *type)
1587 {
1588 	struct eso_softc *sc;
1589 	struct eso_dma *p;
1590 
1591 	sc = hdl;
1592 	p = eso_kva2dma(sc, addr);
1593 
1594 	SLIST_REMOVE(&sc->sc_dmas, p, eso_dma, ed_slist);
1595 	eso_freemem(p);
1596 	free(p, type);
1597 }
1598 
1599 static size_t
1600 eso_round_buffersize(void *hdl, int direction, size_t bufsize)
1601 {
1602 	size_t maxsize;
1603 
1604 	/*
1605 	 * The playback DMA buffer size on the Solo-1 is limited to 0xfff0
1606 	 * bytes.  This is because IO_A2DMAC is a two byte value
1607 	 * indicating the literal byte count, and the 4 least significant
1608 	 * bits are read-only.  Zero is not used as a special case for
1609 	 * 0x10000.
1610 	 *
1611 	 * For recording, DMAC_DMAC is the byte count - 1, so 0x10000 can
1612 	 * be represented.
1613 	 */
1614 	maxsize = (direction == AUMODE_PLAY) ? 0xfff0 : 0x10000;
1615 
1616 	if (bufsize > maxsize)
1617 		bufsize = maxsize;
1618 
1619 	return bufsize;
1620 }
1621 
1622 static paddr_t
1623 eso_mappage(void *hdl, void *addr, off_t offs, int prot)
1624 {
1625 	struct eso_softc *sc;
1626 	struct eso_dma *ed;
1627 
1628 	sc = hdl;
1629 	if (offs < 0)
1630 		return -1;
1631 	ed = eso_kva2dma(sc, addr);
1632 
1633 	return bus_dmamem_mmap(ed->ed_dmat, ed->ed_segs, ed->ed_nsegs,
1634 	    offs, prot, BUS_DMA_WAITOK);
1635 }
1636 
1637 /* ARGSUSED */
1638 static int
1639 eso_get_props(void *hdl)
1640 {
1641 
1642 	return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT |
1643 	    AUDIO_PROP_FULLDUPLEX;
1644 }
1645 
1646 static int
1647 eso_trigger_output(void *hdl, void *start, void *end, int blksize,
1648     void (*intr)(void *), void *arg, const audio_params_t *param)
1649 {
1650 	struct eso_softc *sc;
1651 	struct eso_dma *ed;
1652 	uint8_t a2c1;
1653 
1654 	sc = hdl;
1655 	DPRINTF((
1656 	    "%s: trigger_output: start %p, end %p, blksize %d, intr %p(%p)\n",
1657 	    sc->sc_dev.dv_xname, start, end, blksize, intr, arg));
1658 	DPRINTF(("%s: param: rate %u, encoding %u, precision %u, channels %u\n",
1659 	    sc->sc_dev.dv_xname, param->sample_rate, param->encoding,
1660 	    param->precision, param->channels));
1661 
1662 	/* Find DMA buffer. */
1663 	ed = eso_kva2dma(sc, start);
1664 	DPRINTF(("%s: dmaaddr %lx\n",
1665 	    sc->sc_dev.dv_xname, (unsigned long)DMAADDR(ed)));
1666 
1667 	sc->sc_pintr = intr;
1668 	sc->sc_parg = arg;
1669 
1670 	/* Compute drain timeout. */
1671 	sc->sc_pdrain = (blksize * NBBY * hz) /
1672 	    (param->sample_rate * param->channels *
1673 	     param->precision) + 2;	/* slop */
1674 
1675 	/* DMA transfer count (in `words'!) reload using 2's complement. */
1676 	blksize = -(blksize >> 1);
1677 	eso_write_mixreg(sc, ESO_MIXREG_A2TCRLO, blksize & 0xff);
1678 	eso_write_mixreg(sc, ESO_MIXREG_A2TCRHI, blksize >> 8);
1679 
1680 	/* Update DAC to reflect DMA count and audio parameters. */
1681 	/* Note: we cache A2C2 in order to avoid r/m/w at interrupt time. */
1682 	if (param->precision == 16)
1683 		sc->sc_a2c2 |= ESO_MIXREG_A2C2_16BIT;
1684 	else
1685 		sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_16BIT;
1686 	if (param->channels == 2)
1687 		sc->sc_a2c2 |= ESO_MIXREG_A2C2_STEREO;
1688 	else
1689 		sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_STEREO;
1690 	if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
1691 	    param->encoding == AUDIO_ENCODING_SLINEAR_LE)
1692 		sc->sc_a2c2 |= ESO_MIXREG_A2C2_SIGNED;
1693 	else
1694 		sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_SIGNED;
1695 	/* Unmask IRQ. */
1696 	sc->sc_a2c2 |= ESO_MIXREG_A2C2_IRQM;
1697 	eso_write_mixreg(sc, ESO_MIXREG_A2C2, sc->sc_a2c2);
1698 
1699 	/* Set up DMA controller. */
1700 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAA,
1701 	    DMAADDR(ed));
1702 	bus_space_write_2(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAC,
1703 	    (uint8_t *)end - (uint8_t *)start);
1704 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM,
1705 	    ESO_IO_A2DMAM_DMAENB | ESO_IO_A2DMAM_AUTO);
1706 
1707 	/* Start DMA. */
1708 	a2c1 = eso_read_mixreg(sc, ESO_MIXREG_A2C1);
1709 	a2c1 &= ~ESO_MIXREG_A2C1_RESV0; /* Paranoia? XXX bit 5 */
1710 	a2c1 |= ESO_MIXREG_A2C1_FIFOENB | ESO_MIXREG_A2C1_DMAENB |
1711 	    ESO_MIXREG_A2C1_AUTO;
1712 	eso_write_mixreg(sc, ESO_MIXREG_A2C1, a2c1);
1713 
1714 	return 0;
1715 }
1716 
1717 static int
1718 eso_trigger_input(void *hdl, void *start, void *end, int blksize,
1719     void (*intr)(void *), void *arg, const audio_params_t *param)
1720 {
1721 	struct eso_softc *sc;
1722 	struct eso_dma *ed;
1723 	uint8_t actl, a1c1;
1724 
1725 	sc = hdl;
1726 	DPRINTF((
1727 	    "%s: trigger_input: start %p, end %p, blksize %d, intr %p(%p)\n",
1728 	    sc->sc_dev.dv_xname, start, end, blksize, intr, arg));
1729 	DPRINTF(("%s: param: rate %u, encoding %u, precision %u, channels %u\n",
1730 	    sc->sc_dev.dv_xname, param->sample_rate, param->encoding,
1731 	    param->precision, param->channels));
1732 
1733 	/*
1734 	 * If we failed to configure the Audio 1 DMA controller, bail here
1735 	 * while retaining availability of the DAC direction (in Audio 2).
1736 	 */
1737 	if (!sc->sc_dmac_configured)
1738 		return EIO;
1739 
1740 	/* Find DMA buffer. */
1741 	ed = eso_kva2dma(sc, start);
1742 	DPRINTF(("%s: dmaaddr %lx\n",
1743 	    sc->sc_dev.dv_xname, (unsigned long)DMAADDR(ed)));
1744 
1745 	sc->sc_rintr = intr;
1746 	sc->sc_rarg = arg;
1747 
1748 	/* Compute drain timeout. */
1749 	sc->sc_rdrain = (blksize * NBBY * hz) /
1750 	    (param->sample_rate * param->channels *
1751 	     param->precision) + 2;	/* slop */
1752 
1753 	/* Set up ADC DMA converter parameters. */
1754 	actl = eso_read_ctlreg(sc, ESO_CTLREG_ACTL);
1755 	if (param->channels == 2) {
1756 		actl &= ~ESO_CTLREG_ACTL_MONO;
1757 		actl |= ESO_CTLREG_ACTL_STEREO;
1758 	} else {
1759 		actl &= ~ESO_CTLREG_ACTL_STEREO;
1760 		actl |= ESO_CTLREG_ACTL_MONO;
1761 	}
1762 	eso_write_ctlreg(sc, ESO_CTLREG_ACTL, actl);
1763 
1764 	/* Set up Transfer Type: maybe move to attach time? */
1765 	eso_write_ctlreg(sc, ESO_CTLREG_A1TT, ESO_CTLREG_A1TT_DEMAND4);
1766 
1767 	/* DMA transfer count reload using 2's complement. */
1768 	blksize = -blksize;
1769 	eso_write_ctlreg(sc, ESO_CTLREG_A1TCRLO, blksize & 0xff);
1770 	eso_write_ctlreg(sc, ESO_CTLREG_A1TCRHI, blksize >> 8);
1771 
1772 	/* Set up and enable Audio 1 DMA FIFO. */
1773 	a1c1 = ESO_CTLREG_A1C1_RESV1 | ESO_CTLREG_A1C1_FIFOENB;
1774 	if (param->precision == 16)
1775 		a1c1 |= ESO_CTLREG_A1C1_16BIT;
1776 	if (param->channels == 2)
1777 		a1c1 |= ESO_CTLREG_A1C1_STEREO;
1778 	else
1779 		a1c1 |= ESO_CTLREG_A1C1_MONO;
1780 	if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
1781 	    param->encoding == AUDIO_ENCODING_SLINEAR_LE)
1782 		a1c1 |= ESO_CTLREG_A1C1_SIGNED;
1783 	eso_write_ctlreg(sc, ESO_CTLREG_A1C1, a1c1);
1784 
1785 	/* Set up ADC IRQ/DRQ parameters. */
1786 	eso_write_ctlreg(sc, ESO_CTLREG_LAIC,
1787 	    ESO_CTLREG_LAIC_PINENB | ESO_CTLREG_LAIC_EXTENB);
1788 	eso_write_ctlreg(sc, ESO_CTLREG_DRQCTL,
1789 	    ESO_CTLREG_DRQCTL_ENB1 | ESO_CTLREG_DRQCTL_EXTENB);
1790 
1791 	/* Set up and enable DMA controller. */
1792 	bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_CLEAR, 0);
1793 	bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK,
1794 	    ESO_DMAC_MASK_MASK);
1795 	bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MODE,
1796 	    DMA37MD_WRITE | DMA37MD_LOOP | DMA37MD_DEMAND);
1797 	bus_space_write_4(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_DMAA,
1798 	    DMAADDR(ed));
1799 	bus_space_write_2(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_DMAC,
1800 	    (uint8_t *)end - (uint8_t *)start - 1);
1801 	bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK, 0);
1802 
1803 	/* Start DMA. */
1804 	eso_write_ctlreg(sc, ESO_CTLREG_A1C2,
1805 	    ESO_CTLREG_A1C2_DMAENB | ESO_CTLREG_A1C2_READ |
1806 	    ESO_CTLREG_A1C2_AUTO | ESO_CTLREG_A1C2_ADC);
1807 
1808 	return 0;
1809 }
1810 
1811 /*
1812  * Mixer utility functions.
1813  */
1814 static int
1815 eso_set_recsrc(struct eso_softc *sc, unsigned int recsrc)
1816 {
1817 	mixer_devinfo_t di;
1818 	int i;
1819 
1820 	di.index = ESO_RECORD_SOURCE;
1821 	if (eso_query_devinfo(sc, &di) != 0)
1822 		panic("eso_set_recsrc: eso_query_devinfo failed");
1823 
1824 	for (i = 0; i < di.un.e.num_mem; i++) {
1825 		if (recsrc == di.un.e.member[i].ord) {
1826 			eso_write_mixreg(sc, ESO_MIXREG_ERS, recsrc);
1827 			sc->sc_recsrc = recsrc;
1828 			return 0;
1829 		}
1830 	}
1831 
1832 	return EINVAL;
1833 }
1834 
1835 static int
1836 eso_set_monooutsrc(struct eso_softc *sc, unsigned int monooutsrc)
1837 {
1838 	mixer_devinfo_t di;
1839 	int i;
1840 	uint8_t mpm;
1841 
1842 	di.index = ESO_MONOOUT_SOURCE;
1843 	if (eso_query_devinfo(sc, &di) != 0)
1844 		panic("eso_set_monooutsrc: eso_query_devinfo failed");
1845 
1846 	for (i = 0; i < di.un.e.num_mem; i++) {
1847 		if (monooutsrc == di.un.e.member[i].ord) {
1848 			mpm = eso_read_mixreg(sc, ESO_MIXREG_MPM);
1849 			mpm &= ~ESO_MIXREG_MPM_MOMASK;
1850 			mpm |= monooutsrc;
1851 			eso_write_mixreg(sc, ESO_MIXREG_MPM, mpm);
1852 			sc->sc_monooutsrc = monooutsrc;
1853 			return 0;
1854 		}
1855 	}
1856 
1857 	return EINVAL;
1858 }
1859 
1860 static int
1861 eso_set_monoinbypass(struct eso_softc *sc, unsigned int monoinbypass)
1862 {
1863 	mixer_devinfo_t di;
1864 	int i;
1865 	uint8_t mpm;
1866 
1867 	di.index = ESO_MONOIN_BYPASS;
1868 	if (eso_query_devinfo(sc, &di) != 0)
1869 		panic("eso_set_monoinbypass: eso_query_devinfo failed");
1870 
1871 	for (i = 0; i < di.un.e.num_mem; i++) {
1872 		if (monoinbypass == di.un.e.member[i].ord) {
1873 			mpm = eso_read_mixreg(sc, ESO_MIXREG_MPM);
1874 			mpm &= ~(ESO_MIXREG_MPM_MOMASK | ESO_MIXREG_MPM_RESV0);
1875 			mpm |= (monoinbypass ? ESO_MIXREG_MPM_MIBYPASS : 0);
1876 			eso_write_mixreg(sc, ESO_MIXREG_MPM, mpm);
1877 			sc->sc_monoinbypass = monoinbypass;
1878 			return 0;
1879 		}
1880 	}
1881 
1882 	return EINVAL;
1883 }
1884 
1885 static int
1886 eso_set_preamp(struct eso_softc *sc, unsigned int preamp)
1887 {
1888 	mixer_devinfo_t di;
1889 	int i;
1890 	uint8_t mpm;
1891 
1892 	di.index = ESO_MIC_PREAMP;
1893 	if (eso_query_devinfo(sc, &di) != 0)
1894 		panic("eso_set_preamp: eso_query_devinfo failed");
1895 
1896 	for (i = 0; i < di.un.e.num_mem; i++) {
1897 		if (preamp == di.un.e.member[i].ord) {
1898 			mpm = eso_read_mixreg(sc, ESO_MIXREG_MPM);
1899 			mpm &= ~(ESO_MIXREG_MPM_PREAMP | ESO_MIXREG_MPM_RESV0);
1900 			mpm |= (preamp ? ESO_MIXREG_MPM_PREAMP : 0);
1901 			eso_write_mixreg(sc, ESO_MIXREG_MPM, mpm);
1902 			sc->sc_preamp = preamp;
1903 			return 0;
1904 		}
1905 	}
1906 
1907 	return EINVAL;
1908 }
1909 
1910 /*
1911  * Reload Master Volume and Mute values in softc from mixer; used when
1912  * those have previously been invalidated by use of hardware volume controls.
1913  */
1914 static void
1915 eso_reload_master_vol(struct eso_softc *sc)
1916 {
1917 	uint8_t mv;
1918 
1919 	mv = eso_read_mixreg(sc, ESO_MIXREG_LMVM);
1920 	sc->sc_gain[ESO_MASTER_VOL][ESO_LEFT] =
1921 	    (mv & ~ESO_MIXREG_LMVM_MUTE) << 2;
1922 	mv = eso_read_mixreg(sc, ESO_MIXREG_LMVM);
1923 	sc->sc_gain[ESO_MASTER_VOL][ESO_RIGHT] =
1924 	    (mv & ~ESO_MIXREG_RMVM_MUTE) << 2;
1925 	/* Currently both channels are muted simultaneously; either is OK. */
1926 	sc->sc_mvmute = (mv & ESO_MIXREG_RMVM_MUTE) != 0;
1927 }
1928 
1929 static void
1930 eso_set_gain(struct eso_softc *sc, unsigned int port)
1931 {
1932 	uint8_t mixreg, tmp;
1933 
1934 	switch (port) {
1935 	case ESO_DAC_PLAY_VOL:
1936 		mixreg = ESO_MIXREG_PVR_A2;
1937 		break;
1938 	case ESO_MIC_PLAY_VOL:
1939 		mixreg = ESO_MIXREG_PVR_MIC;
1940 		break;
1941 	case ESO_LINE_PLAY_VOL:
1942 		mixreg = ESO_MIXREG_PVR_LINE;
1943 		break;
1944 	case ESO_SYNTH_PLAY_VOL:
1945 		mixreg = ESO_MIXREG_PVR_SYNTH;
1946 		break;
1947 	case ESO_CD_PLAY_VOL:
1948 		mixreg = ESO_MIXREG_PVR_CD;
1949 		break;
1950 	case ESO_AUXB_PLAY_VOL:
1951 		mixreg = ESO_MIXREG_PVR_AUXB;
1952 		break;
1953 
1954 	case ESO_DAC_REC_VOL:
1955 		mixreg = ESO_MIXREG_RVR_A2;
1956 		break;
1957 	case ESO_MIC_REC_VOL:
1958 		mixreg = ESO_MIXREG_RVR_MIC;
1959 		break;
1960 	case ESO_LINE_REC_VOL:
1961 		mixreg = ESO_MIXREG_RVR_LINE;
1962 		break;
1963 	case ESO_SYNTH_REC_VOL:
1964 		mixreg = ESO_MIXREG_RVR_SYNTH;
1965 		break;
1966 	case ESO_CD_REC_VOL:
1967 		mixreg = ESO_MIXREG_RVR_CD;
1968 		break;
1969 	case ESO_AUXB_REC_VOL:
1970 		mixreg = ESO_MIXREG_RVR_AUXB;
1971 		break;
1972 	case ESO_MONO_PLAY_VOL:
1973 		mixreg = ESO_MIXREG_PVR_MONO;
1974 		break;
1975 	case ESO_MONO_REC_VOL:
1976 		mixreg = ESO_MIXREG_RVR_MONO;
1977 		break;
1978 
1979 	case ESO_PCSPEAKER_VOL:
1980 		/* Special case - only 3-bit, mono, and reserved bits. */
1981 		tmp = eso_read_mixreg(sc, ESO_MIXREG_PCSVR);
1982 		tmp &= ESO_MIXREG_PCSVR_RESV;
1983 		/* Map bits 7:5 -> 2:0. */
1984 		tmp |= (sc->sc_gain[port][ESO_LEFT] >> 5);
1985 		eso_write_mixreg(sc, ESO_MIXREG_PCSVR, tmp);
1986 		return;
1987 
1988 	case ESO_MASTER_VOL:
1989 		/* Special case - separate regs, and 6-bit precision. */
1990 		/* Map bits 7:2 -> 5:0, reflect mute settings. */
1991 		eso_write_mixreg(sc, ESO_MIXREG_LMVM,
1992 		    (sc->sc_gain[port][ESO_LEFT] >> 2) |
1993 		    (sc->sc_mvmute ? ESO_MIXREG_LMVM_MUTE : 0x00));
1994 		eso_write_mixreg(sc, ESO_MIXREG_RMVM,
1995 		    (sc->sc_gain[port][ESO_RIGHT] >> 2) |
1996 		    (sc->sc_mvmute ? ESO_MIXREG_RMVM_MUTE : 0x00));
1997 		return;
1998 
1999 	case ESO_SPATIALIZER:
2000 		/* Special case - only `mono', and higher precision. */
2001 		eso_write_mixreg(sc, ESO_MIXREG_SPATLVL,
2002 		    sc->sc_gain[port][ESO_LEFT]);
2003 		return;
2004 
2005 	case ESO_RECORD_VOL:
2006 		/* Very Special case, controller register. */
2007 		eso_write_ctlreg(sc, ESO_CTLREG_RECLVL,ESO_4BIT_GAIN_TO_STEREO(
2008 		   sc->sc_gain[port][ESO_LEFT], sc->sc_gain[port][ESO_RIGHT]));
2009 		return;
2010 
2011 	default:
2012 #ifdef DIAGNOSTIC
2013 		panic("eso_set_gain: bad port %u", port);
2014 		/* NOTREACHED */
2015 #else
2016 		return;
2017 #endif
2018 	}
2019 
2020 	eso_write_mixreg(sc, mixreg, ESO_4BIT_GAIN_TO_STEREO(
2021 	    sc->sc_gain[port][ESO_LEFT], sc->sc_gain[port][ESO_RIGHT]));
2022 }
2023