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