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