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