Annotation of sys/dev/pci/eap.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: eap.c,v 1.29 2006/04/07 22:41:33 jsg Exp $ */
2: /* $NetBSD: eap.c,v 1.46 2001/09/03 15:07:37 reinoud Exp $ */
3:
4: /*
5: * Copyright (c) 1998, 1999 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Lennart Augustsson <augustss@netbsd.org> and Charles M. Hannum.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: /*
41: * Debugging: Andreas Gustafsson <gson@araneus.fi>
42: * Testing: Chuck Cranor <chuck@maria.wustl.edu>
43: * Phil Nelson <phil@cs.wwu.edu>
44: *
45: * ES1371/AC97: Ezra Story <ezy@panix.com>
46: */
47:
48: /*
49: * Ensoniq ES1370 + AK4531 and ES1371/ES1373 + AC97
50: *
51: * Documentation links:
52: *
53: * ftp://ftp.alsa-project.org/pub/manuals/ensoniq/
54: * ftp://ftp.alsa-project.org/pub/manuals/asahi_kasei/4531.pdf
55: */
56:
57: #include "midi.h"
58:
59: #include <sys/param.h>
60: #include <sys/systm.h>
61: #include <sys/kernel.h>
62: #include <sys/fcntl.h>
63: #include <sys/malloc.h>
64: #include <sys/device.h>
65: #include <sys/proc.h>
66:
67: #include <dev/pci/pcidevs.h>
68: #include <dev/pci/pcivar.h>
69:
70: #include <sys/audioio.h>
71: #include <dev/audio_if.h>
72: #include <dev/midi_if.h>
73: #include <dev/mulaw.h>
74: #include <dev/auconv.h>
75: #include <dev/ic/ac97.h>
76:
77: #include <machine/bus.h>
78:
79: #include <dev/pci/eapreg.h>
80:
81: struct cfdriver eap_cd = {
82: NULL, "eap", DV_DULL
83: };
84:
85: #define PCI_CBIO 0x10
86:
87: /* Debug */
88: #ifdef AUDIO_DEBUG
89: #define DPRINTF(x) if (eapdebug) printf x
90: #define DPRINTFN(n,x) if (eapdebug>(n)) printf x
91: int eapdebug = 20;
92: #else
93: #define DPRINTF(x)
94: #define DPRINTFN(n,x)
95: #endif
96:
97: int eap_match(struct device *, void *, void *);
98: void eap_attach(struct device *, struct device *, void *);
99: int eap_intr(void *);
100:
101: struct eap_dma {
102: bus_dmamap_t map;
103: caddr_t addr;
104: bus_dma_segment_t segs[1];
105: int nsegs;
106: size_t size;
107: struct eap_dma *next;
108: };
109:
110: #define DMAADDR(p) ((p)->map->dm_segs[0].ds_addr)
111: #define KERNADDR(p) ((void *)((p)->addr))
112:
113: struct eap_softc {
114: struct device sc_dev; /* base device */
115: void *sc_ih; /* interrupt vectoring */
116: bus_space_tag_t iot;
117: bus_space_handle_t ioh;
118: bus_dma_tag_t sc_dmatag; /* DMA tag */
119:
120: struct eap_dma *sc_dmas;
121:
122: void (*sc_pintr)(void *); /* dma completion intr handler */
123: void *sc_parg; /* arg for sc_intr() */
124: #ifdef DIAGNOSTIC
125: char sc_prun;
126: #endif
127:
128: void (*sc_rintr)(void *); /* dma completion intr handler */
129: void *sc_rarg; /* arg for sc_intr() */
130: #ifdef DIAGNOSTIC
131: char sc_rrun;
132: #endif
133:
134: #if NMIDI > 0
135: void (*sc_iintr)(void *, int); /* midi input ready handler */
136: void (*sc_ointr)(void *); /* midi output ready handler */
137: void *sc_arg;
138: struct device *sc_mididev;
139: #endif
140:
141: u_short sc_port[AK_NPORTS]; /* mirror of the hardware setting */
142: u_int sc_record_source; /* recording source mask */
143: u_int sc_output_source; /* output source mask */
144: u_int sc_mic_preamp;
145: char sc_1371; /* Using ES1371/AC97 codec */
146:
147: struct ac97_codec_if *codec_if;
148: struct ac97_host_if host_if;
149:
150: int flags;
151: };
152:
153: enum ac97_host_flags eap_flags_codec(void *);
154: int eap_allocmem(struct eap_softc *, size_t, size_t, struct eap_dma *);
155: int eap_freemem(struct eap_softc *, struct eap_dma *);
156:
157: #define EWRITE1(sc, r, x) bus_space_write_1((sc)->iot, (sc)->ioh, (r), (x))
158: #define EWRITE2(sc, r, x) bus_space_write_2((sc)->iot, (sc)->ioh, (r), (x))
159: #define EWRITE4(sc, r, x) bus_space_write_4((sc)->iot, (sc)->ioh, (r), (x))
160: #define EREAD1(sc, r) bus_space_read_1((sc)->iot, (sc)->ioh, (r))
161: #define EREAD2(sc, r) bus_space_read_2((sc)->iot, (sc)->ioh, (r))
162: #define EREAD4(sc, r) bus_space_read_4((sc)->iot, (sc)->ioh, (r))
163:
164: struct cfattach eap_ca = {
165: sizeof(struct eap_softc), eap_match, eap_attach
166: };
167:
168: int eap_open(void *, int);
169: void eap_close(void *);
170: int eap_query_encoding(void *, struct audio_encoding *);
171: int eap_set_params(void *, int, int, struct audio_params *, struct audio_params *);
172: int eap_round_blocksize(void *, int);
173: int eap_trigger_output(void *, void *, void *, int, void (*)(void *),
174: void *, struct audio_params *);
175: int eap_trigger_input(void *, void *, void *, int, void (*)(void *),
176: void *, struct audio_params *);
177: int eap_halt_output(void *);
178: int eap_halt_input(void *);
179: void eap1370_write_codec(struct eap_softc *, int, int);
180: int eap_getdev(void *, struct audio_device *);
181: int eap1370_mixer_set_port(void *, mixer_ctrl_t *);
182: int eap1370_mixer_get_port(void *, mixer_ctrl_t *);
183: int eap1371_mixer_set_port(void *, mixer_ctrl_t *);
184: int eap1371_mixer_get_port(void *, mixer_ctrl_t *);
185: int eap1370_query_devinfo(void *, mixer_devinfo_t *);
186: void *eap_malloc(void *, int, size_t, int, int);
187: void eap_free(void *, void *, int);
188: paddr_t eap_mappage(void *, void *, off_t, int);
189: int eap_get_props(void *);
190: void eap1370_set_mixer(struct eap_softc *sc, int a, int d);
191: u_int32_t eap1371_src_wait(struct eap_softc *sc);
192: void eap1371_set_adc_rate(struct eap_softc *sc, int rate);
193: void eap1371_set_dac_rate(struct eap_softc *sc, int rate, int which);
194: int eap1371_src_read(struct eap_softc *sc, int a);
195: void eap1371_src_write(struct eap_softc *sc, int a, int d);
196: int eap1371_query_devinfo(void *addr, mixer_devinfo_t *dip);
197:
198: int eap1371_attach_codec(void *sc, struct ac97_codec_if *);
199: int eap1371_read_codec(void *sc, u_int8_t a, u_int16_t *d);
200: int eap1371_write_codec(void *sc, u_int8_t a, u_int16_t d);
201: void eap1371_reset_codec(void *sc);
202: int eap1371_get_portnum_by_name(struct eap_softc *, char *, char *,
203: char *);
204: #if NMIDI > 0
205: void eap_midi_close(void *);
206: void eap_midi_getinfo(void *, struct midi_info *);
207: int eap_midi_open(void *, int, void (*)(void *, int),
208: void (*)(void *), void *);
209: int eap_midi_output(void *, int);
210: #endif
211:
212: struct audio_hw_if eap1370_hw_if = {
213: eap_open,
214: eap_close,
215: NULL,
216: eap_query_encoding,
217: eap_set_params,
218: eap_round_blocksize,
219: NULL,
220: NULL,
221: NULL,
222: NULL,
223: NULL,
224: eap_halt_output,
225: eap_halt_input,
226: NULL,
227: eap_getdev,
228: NULL,
229: eap1370_mixer_set_port,
230: eap1370_mixer_get_port,
231: eap1370_query_devinfo,
232: eap_malloc,
233: eap_free,
234: NULL,
235: eap_mappage,
236: eap_get_props,
237: eap_trigger_output,
238: eap_trigger_input,
239: };
240:
241: struct audio_hw_if eap1371_hw_if = {
242: eap_open,
243: eap_close,
244: NULL,
245: eap_query_encoding,
246: eap_set_params,
247: eap_round_blocksize,
248: NULL,
249: NULL,
250: NULL,
251: NULL,
252: NULL,
253: eap_halt_output,
254: eap_halt_input,
255: NULL,
256: eap_getdev,
257: NULL,
258: eap1371_mixer_set_port,
259: eap1371_mixer_get_port,
260: eap1371_query_devinfo,
261: eap_malloc,
262: eap_free,
263: NULL,
264: eap_mappage,
265: eap_get_props,
266: eap_trigger_output,
267: eap_trigger_input,
268: };
269:
270: #if NMIDI > 0
271: struct midi_hw_if eap_midi_hw_if = {
272: eap_midi_open,
273: eap_midi_close,
274: eap_midi_output,
275: 0, /* flush */
276: eap_midi_getinfo,
277: 0, /* ioctl */
278: };
279: #endif
280:
281: struct audio_device eap_device = {
282: "Ensoniq AudioPCI",
283: "",
284: "eap"
285: };
286:
287: const struct pci_matchid eap_devices[] = {
288: { PCI_VENDOR_CREATIVELABS, PCI_PRODUCT_CREATIVELABS_EV1938 },
289: { PCI_VENDOR_ENSONIQ, PCI_PRODUCT_ENSONIQ_AUDIOPCI },
290: { PCI_VENDOR_ENSONIQ, PCI_PRODUCT_ENSONIQ_AUDIOPCI97 },
291: { PCI_VENDOR_ENSONIQ, PCI_PRODUCT_ENSONIQ_CT5880 },
292: };
293:
294: int
295: eap_match(struct device *parent, void *match, void *aux)
296: {
297: return (pci_matchbyid((struct pci_attach_args *)aux, eap_devices,
298: sizeof(eap_devices)/sizeof(eap_devices[0])));
299: }
300:
301: void
302: eap1370_write_codec(struct eap_softc *sc, int a, int d)
303: {
304: int icss, to;
305:
306: to = EAP_WRITE_TIMEOUT;
307: do {
308: icss = EREAD4(sc, EAP_ICSS);
309: DPRINTFN(5,("eap: codec %d prog: icss=0x%08x\n", a, icss));
310: if (!to--) {
311: printf("%s: timeout writing to codec\n",
312: sc->sc_dev.dv_xname);
313: return;
314: }
315: } while (icss & EAP_CWRIP); /* XXX could use CSTAT here */
316: EWRITE4(sc, EAP_CODEC, EAP_SET_CODEC(a, d));
317: }
318:
319: /*
320: * Reading and writing the CODEC is very convoluted. This mimics the
321: * FreeBSD and Linux drivers.
322: */
323:
324: static __inline void
325: eap1371_ready_codec(struct eap_softc *sc, u_int8_t a, u_int32_t wd)
326: {
327: int to, s;
328: u_int32_t src, t;
329:
330: for (to = 0; to < EAP_WRITE_TIMEOUT; to++) {
331: if (!(EREAD4(sc, E1371_CODEC) & E1371_CODEC_WIP))
332: break;
333: delay(1);
334: }
335: if (to == EAP_WRITE_TIMEOUT)
336: printf("%s: eap1371_ready_codec timeout 1\n",
337: sc->sc_dev.dv_xname);
338:
339: s = splaudio();
340: src = eap1371_src_wait(sc) & E1371_SRC_CTLMASK;
341: EWRITE4(sc, E1371_SRC, src | E1371_SRC_STATE_OK);
342:
343: for (to = 0; to < EAP_READ_TIMEOUT; to++) {
344: t = EREAD4(sc, E1371_SRC);
345: if ((t & E1371_SRC_STATE_MASK) == 0)
346: break;
347: delay(1);
348: }
349: if (to == EAP_READ_TIMEOUT)
350: printf("%s: eap1371_ready_codec timeout 2\n",
351: sc->sc_dev.dv_xname);
352:
353: for (to = 0; to < EAP_READ_TIMEOUT; to++) {
354: t = EREAD4(sc, E1371_SRC);
355: if ((t & E1371_SRC_STATE_MASK) == E1371_SRC_STATE_OK)
356: break;
357: delay(1);
358: }
359: if (to == EAP_READ_TIMEOUT)
360: printf("%s: eap1371_ready_codec timeout 3\n",
361: sc->sc_dev.dv_xname);
362:
363: EWRITE4(sc, E1371_CODEC, wd);
364:
365: eap1371_src_wait(sc);
366: EWRITE4(sc, E1371_SRC, src);
367:
368: splx(s);
369: }
370:
371: int
372: eap1371_read_codec(void *sc_, u_int8_t a, u_int16_t *d)
373: {
374: struct eap_softc *sc = sc_;
375: int to;
376: u_int32_t t;
377:
378: eap1371_ready_codec(sc, a, E1371_SET_CODEC(a, 0) | E1371_CODEC_READ);
379:
380: for (to = 0; to < EAP_WRITE_TIMEOUT; to++) {
381: if (!(EREAD4(sc, E1371_CODEC) & E1371_CODEC_WIP))
382: break;
383: delay(1);
384: }
385: if (to == EAP_WRITE_TIMEOUT)
386: printf("%s: eap1371_read_codec timeout 1\n",
387: sc->sc_dev.dv_xname);
388:
389: for (to = 0; to < EAP_WRITE_TIMEOUT; to++) {
390: t = EREAD4(sc, E1371_CODEC);
391: if (t & E1371_CODEC_VALID)
392: break;
393: delay(1);
394: }
395: if (to == EAP_WRITE_TIMEOUT)
396: printf("%s: eap1371_read_codec timeout 2\n",
397: sc->sc_dev.dv_xname);
398:
399: *d = (u_int16_t)t;
400:
401: DPRINTFN(10, ("eap1371: reading codec (%x) = %x\n", a, *d));
402:
403: return (0);
404: }
405:
406: int
407: eap1371_write_codec(void *sc_, u_int8_t a, u_int16_t d)
408: {
409: struct eap_softc *sc = sc_;
410:
411: eap1371_ready_codec(sc, a, E1371_SET_CODEC(a, d));
412:
413: DPRINTFN(10, ("eap1371: writing codec %x --> %x\n", d, a));
414:
415: return (0);
416: }
417:
418: u_int32_t
419: eap1371_src_wait(struct eap_softc *sc)
420: {
421: int to;
422: u_int32_t src;
423:
424: for (to = 0; to < EAP_READ_TIMEOUT; to++) {
425: src = EREAD4(sc, E1371_SRC);
426: if (!(src & E1371_SRC_RBUSY))
427: return (src);
428: delay(1);
429: }
430: printf("%s: eap1371_src_wait timeout\n", sc->sc_dev.dv_xname);
431: return (src);
432: }
433:
434: int
435: eap1371_src_read(struct eap_softc *sc, int a)
436: {
437: int to;
438: u_int32_t src, t;
439:
440: src = eap1371_src_wait(sc) & E1371_SRC_CTLMASK;
441: src |= E1371_SRC_ADDR(a);
442: EWRITE4(sc, E1371_SRC, src | E1371_SRC_STATE_OK);
443:
444: if ((eap1371_src_wait(sc) & E1371_SRC_STATE_MASK) != E1371_SRC_STATE_OK) {
445: for (to = 0; to < EAP_READ_TIMEOUT; to++) {
446: t = EREAD4(sc, E1371_SRC);
447: if ((t & E1371_SRC_STATE_MASK) == E1371_SRC_STATE_OK)
448: break;
449: delay(1);
450: }
451: }
452:
453: EWRITE4(sc, E1371_SRC, src);
454:
455: return t & E1371_SRC_DATAMASK;
456: }
457:
458: void
459: eap1371_src_write(struct eap_softc *sc, int a, int d)
460: {
461: u_int32_t r;
462:
463: r = eap1371_src_wait(sc) & E1371_SRC_CTLMASK;
464: r |= E1371_SRC_RAMWE | E1371_SRC_ADDR(a) | E1371_SRC_DATA(d);
465: EWRITE4(sc, E1371_SRC, r);
466: }
467:
468: void
469: eap1371_set_adc_rate(struct eap_softc *sc, int rate)
470: {
471: int freq, n, truncm;
472: int out;
473: int s;
474:
475: /* Whatever, it works, so I'll leave it :) */
476:
477: if (rate > 48000)
478: rate = 48000;
479: if (rate < 4000)
480: rate = 4000;
481: n = rate / 3000;
482: if ((1 << n) & SRC_MAGIC)
483: n--;
484: truncm = ((21 * n) - 1) | 1;
485: freq = ((48000 << 15) / rate) * n;
486: if (rate >= 24000) {
487: if (truncm > 239)
488: truncm = 239;
489: out = ESRC_SET_TRUNC((239 - truncm) / 2);
490: } else {
491: if (truncm > 119)
492: truncm = 119;
493: out = ESRC_SMF | ESRC_SET_TRUNC((119 - truncm) / 2);
494: }
495: out |= ESRC_SET_N(n);
496: s = splaudio();
497: eap1371_src_write(sc, ESRC_ADC+ESRC_TRUNC_N, out);
498:
499:
500: out = eap1371_src_read(sc, ESRC_ADC+ESRC_IREGS) & 0xff;
501: eap1371_src_write(sc, ESRC_ADC+ESRC_IREGS, out |
502: ESRC_SET_VFI(freq >> 15));
503: eap1371_src_write(sc, ESRC_ADC+ESRC_VFF, freq & 0x7fff);
504: eap1371_src_write(sc, ESRC_ADC_VOLL, ESRC_SET_ADC_VOL(n));
505: eap1371_src_write(sc, ESRC_ADC_VOLR, ESRC_SET_ADC_VOL(n));
506: splx(s);
507: }
508:
509: void
510: eap1371_set_dac_rate(struct eap_softc *sc, int rate, int which)
511: {
512: int dac = which == 1 ? ESRC_DAC1 : ESRC_DAC2;
513: int freq, r;
514: int s;
515:
516: /* Whatever, it works, so I'll leave it :) */
517:
518: if (rate > 48000)
519: rate = 48000;
520: if (rate < 4000)
521: rate = 4000;
522: freq = ((rate << 15) + 1500) / 3000;
523:
524: s = splaudio();
525: eap1371_src_wait(sc);
526: r = EREAD4(sc, E1371_SRC) & (E1371_SRC_DISABLE |
527: E1371_SRC_DISP2 | E1371_SRC_DISP1 | E1371_SRC_DISREC);
528: r |= (which == 1) ? E1371_SRC_DISP1 : E1371_SRC_DISP2;
529: EWRITE4(sc, E1371_SRC, r);
530: r = eap1371_src_read(sc, dac + ESRC_IREGS) & 0x00ff;
531: eap1371_src_write(sc, dac + ESRC_IREGS, r | ((freq >> 5) & 0xfc00));
532: eap1371_src_write(sc, dac + ESRC_VFF, freq & 0x7fff);
533: r = EREAD4(sc, E1371_SRC) & (E1371_SRC_DISABLE |
534: E1371_SRC_DISP2 | E1371_SRC_DISP1 | E1371_SRC_DISREC);
535: r &= ~(which == 1 ? E1371_SRC_DISP1 : E1371_SRC_DISP2);
536: EWRITE4(sc, E1371_SRC, r);
537: splx(s);
538: }
539:
540: void
541: eap_attach(struct device *parent, struct device *self, void *aux)
542: {
543: struct eap_softc *sc = (struct eap_softc *)self;
544: struct pci_attach_args *pa = (struct pci_attach_args *)aux;
545: pci_chipset_tag_t pc = pa->pa_pc;
546: struct audio_hw_if *eap_hw_if;
547: char const *intrstr;
548: pci_intr_handle_t ih;
549: mixer_ctrl_t ctl;
550: int i;
551: int revision, ct5880;
552:
553: /* Flag if we're "creative" */
554: sc->sc_1371 = !(PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ENSONIQ &&
555: PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ENSONIQ_AUDIOPCI);
556:
557: revision = PCI_REVISION(pa->pa_class);
558: if (sc->sc_1371) {
559: if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ENSONIQ &&
560: ((PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ENSONIQ_AUDIOPCI97 &&
561: (revision == EAP_ES1373_8 || revision == EAP_CT5880_A)) ||
562: PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ENSONIQ_CT5880))
563: ct5880 = 1;
564: else
565: ct5880 = 0;
566: }
567:
568: /* Map I/O register */
569: if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0,
570: &sc->iot, &sc->ioh, NULL, NULL, 0)) {
571: return;
572: }
573:
574: sc->sc_dmatag = pa->pa_dmat;
575:
576: /* Map and establish the interrupt. */
577: if (pci_intr_map(pa, &ih)) {
578: printf(": couldn't map interrupt\n");
579: return;
580: }
581: intrstr = pci_intr_string(pc, ih);
582: sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, eap_intr, sc,
583: sc->sc_dev.dv_xname);
584: if (sc->sc_ih == NULL) {
585: printf(": couldn't establish interrupt");
586: if (intrstr != NULL)
587: printf(" at %s", intrstr);
588: printf("\n");
589: return;
590: }
591: printf(": %s\n", intrstr);
592:
593: if (!sc->sc_1371) {
594: /* Enable interrupts and looping mode. */
595: /* enable the parts we need */
596: EWRITE4(sc, EAP_SIC, EAP_P2_INTR_EN | EAP_R1_INTR_EN);
597: EWRITE4(sc, EAP_ICSC, EAP_CDC_EN);
598:
599: /* reset codec */
600: /* normal operation */
601: /* select codec clocks */
602: eap1370_write_codec(sc, AK_RESET, AK_PD);
603: eap1370_write_codec(sc, AK_RESET, AK_PD | AK_NRST);
604: eap1370_write_codec(sc, AK_CS, 0x0);
605:
606: eap_hw_if = &eap1370_hw_if;
607:
608: /* Enable all relevant mixer switches. */
609: ctl.dev = EAP_OUTPUT_SELECT;
610: ctl.type = AUDIO_MIXER_SET;
611: ctl.un.mask = 1 << EAP_VOICE_VOL | 1 << EAP_FM_VOL |
612: 1 << EAP_CD_VOL | 1 << EAP_LINE_VOL | 1 << EAP_AUX_VOL |
613: 1 << EAP_MIC_VOL;
614: eap_hw_if->set_port(sc, &ctl);
615:
616: ctl.type = AUDIO_MIXER_VALUE;
617: ctl.un.value.num_channels = 1;
618: for (ctl.dev = EAP_MASTER_VOL; ctl.dev < EAP_MIC_VOL;
619: ctl.dev++) {
620: ctl.un.value.level[AUDIO_MIXER_LEVEL_MONO] = VOL_0DB;
621: eap_hw_if->set_port(sc, &ctl);
622: }
623: ctl.un.value.level[AUDIO_MIXER_LEVEL_MONO] = 0;
624: eap_hw_if->set_port(sc, &ctl);
625: ctl.dev = EAP_MIC_PREAMP;
626: ctl.type = AUDIO_MIXER_ENUM;
627: ctl.un.ord = 0;
628: eap_hw_if->set_port(sc, &ctl);
629: ctl.dev = EAP_RECORD_SOURCE;
630: ctl.type = AUDIO_MIXER_SET;
631: ctl.un.mask = 1 << EAP_MIC_VOL;
632: eap_hw_if->set_port(sc, &ctl);
633: } else {
634: /* clean slate */
635:
636: EWRITE4(sc, EAP_SIC, 0);
637: EWRITE4(sc, EAP_ICSC, 0);
638: EWRITE4(sc, E1371_LEGACY, 0);
639:
640: if (ct5880) {
641: EWRITE4(sc, EAP_ICSS, EAP_CT5880_AC97_RESET);
642: /* Let codec wake up */
643: delay(20000);
644: }
645:
646: /* Reset from es1371's perspective */
647: EWRITE4(sc, EAP_ICSC, E1371_SYNC_RES);
648: delay(20);
649: EWRITE4(sc, EAP_ICSC, 0);
650:
651: /*
652: * Must properly reprogram sample rate converter,
653: * or it locks up. Set some defaults for the life of the
654: * machine, and set up a sb default sample rate.
655: */
656: EWRITE4(sc, E1371_SRC, E1371_SRC_DISABLE);
657: for (i = 0; i < 0x80; i++)
658: eap1371_src_write(sc, i, 0);
659: eap1371_src_write(sc, ESRC_DAC1+ESRC_TRUNC_N, ESRC_SET_N(16));
660: eap1371_src_write(sc, ESRC_DAC2+ESRC_TRUNC_N, ESRC_SET_N(16));
661: eap1371_src_write(sc, ESRC_DAC1+ESRC_IREGS, ESRC_SET_VFI(16));
662: eap1371_src_write(sc, ESRC_DAC2+ESRC_IREGS, ESRC_SET_VFI(16));
663: eap1371_src_write(sc, ESRC_ADC_VOLL, ESRC_SET_ADC_VOL(16));
664: eap1371_src_write(sc, ESRC_ADC_VOLR, ESRC_SET_ADC_VOL(16));
665: eap1371_src_write(sc, ESRC_DAC1_VOLL, ESRC_SET_DAC_VOLI(1));
666: eap1371_src_write(sc, ESRC_DAC1_VOLR, ESRC_SET_DAC_VOLI(1));
667: eap1371_src_write(sc, ESRC_DAC2_VOLL, ESRC_SET_DAC_VOLI(1));
668: eap1371_src_write(sc, ESRC_DAC2_VOLR, ESRC_SET_DAC_VOLI(1));
669: eap1371_set_adc_rate(sc, 22050);
670: eap1371_set_dac_rate(sc, 22050, 1);
671: eap1371_set_dac_rate(sc, 22050, 2);
672:
673: EWRITE4(sc, E1371_SRC, 0);
674:
675: /* Reset codec */
676:
677: /* Interrupt enable */
678: sc->host_if.arg = sc;
679: sc->host_if.attach = eap1371_attach_codec;
680: sc->host_if.read = eap1371_read_codec;
681: sc->host_if.write = eap1371_write_codec;
682: sc->host_if.reset = eap1371_reset_codec;
683: sc->host_if.flags = eap_flags_codec;
684: sc->flags = AC97_HOST_DONT_READ;
685:
686: if (ac97_attach(&sc->host_if) == 0) {
687: /* Interrupt enable */
688: EWRITE4(sc, EAP_SIC, EAP_P2_INTR_EN | EAP_R1_INTR_EN);
689: } else
690: return;
691:
692: eap_hw_if = &eap1371_hw_if;
693:
694: /* Just enable the DAC and master volumes by default */
695: ctl.type = AUDIO_MIXER_ENUM;
696: ctl.un.ord = 0; /* off */
697: ctl.dev = eap1371_get_portnum_by_name(sc, AudioCoutputs,
698: AudioNmaster, AudioNmute);
699: eap1371_mixer_set_port(sc, &ctl);
700: ctl.dev = eap1371_get_portnum_by_name(sc, AudioCinputs,
701: AudioNdac, AudioNmute);
702: eap1371_mixer_set_port(sc, &ctl);
703: ctl.dev = eap1371_get_portnum_by_name(sc, AudioCrecord,
704: AudioNvolume, AudioNmute);
705: eap1371_mixer_set_port(sc, &ctl);
706:
707: ctl.dev = eap1371_get_portnum_by_name(sc, AudioCrecord,
708: AudioNsource, NULL);
709: ctl.type = AUDIO_MIXER_ENUM;
710: ctl.un.ord = 0;
711: eap1371_mixer_set_port(sc, &ctl);
712:
713: }
714:
715: audio_attach_mi(eap_hw_if, sc, &sc->sc_dev);
716: #if NMIDI > 0
717: sc->sc_mididev = midi_attach_mi(&eap_midi_hw_if, sc, &sc->sc_dev);
718: #endif
719: }
720:
721: int
722: eap1371_attach_codec(void *sc_, struct ac97_codec_if *codec_if)
723: {
724: struct eap_softc *sc = sc_;
725:
726: sc->codec_if = codec_if;
727: return (0);
728: }
729:
730: void
731: eap1371_reset_codec(void *sc_)
732: {
733: struct eap_softc *sc = sc_;
734: u_int32_t icsc;
735: int s;
736:
737: s = splaudio();
738: icsc = EREAD4(sc, EAP_ICSC);
739: EWRITE4(sc, EAP_ICSC, icsc | E1371_SYNC_RES);
740: delay(20);
741: EWRITE4(sc, EAP_ICSC, icsc & ~E1371_SYNC_RES);
742: delay(1);
743: splx(s);
744:
745: return;
746: }
747:
748: int
749: eap_intr(void *p)
750: {
751: struct eap_softc *sc = p;
752: u_int32_t intr, sic;
753:
754: intr = EREAD4(sc, EAP_ICSS);
755: if (!(intr & EAP_INTR))
756: return (0);
757: sic = EREAD4(sc, EAP_SIC);
758: DPRINTFN(5, ("eap_intr: ICSS=0x%08x, SIC=0x%08x\n", intr, sic));
759: if (intr & EAP_I_ADC) {
760: #if 0
761: /*
762: * XXX This is a hack!
763: * The EAP chip sometimes generates the recording interrupt
764: * while it is still transferring the data. To make sure
765: * it has all arrived we busy wait until the count is right.
766: * The transfer we are waiting for is 8 longwords.
767: */
768: int s, nw, n;
769:
770: EWRITE4(sc, EAP_MEMPAGE, EAP_ADC_PAGE);
771: s = EREAD4(sc, EAP_ADC_CSR);
772: nw = ((s & 0xffff) + 1) >> 2; /* # of words in DMA */
773: n = 0;
774: while (((EREAD4(sc, EAP_ADC_SIZE) >> 16) + 8) % nw == 0) {
775: delay(10);
776: if (++n > 100) {
777: printf("eapintr: dma fix timeout");
778: break;
779: }
780: }
781: /* Continue with normal interrupt handling. */
782: #endif
783: EWRITE4(sc, EAP_SIC, sic & ~EAP_R1_INTR_EN);
784: EWRITE4(sc, EAP_SIC, sic | EAP_R1_INTR_EN);
785: if (sc->sc_rintr)
786: sc->sc_rintr(sc->sc_rarg);
787: }
788: if (intr & EAP_I_DAC2) {
789: EWRITE4(sc, EAP_SIC, sic & ~EAP_P2_INTR_EN);
790: EWRITE4(sc, EAP_SIC, sic | EAP_P2_INTR_EN);
791: if (sc->sc_pintr)
792: sc->sc_pintr(sc->sc_parg);
793: }
794: #if NMIDI > 0
795: if ((intr & EAP_I_UART) && sc->sc_iintr != NULL) {
796: u_int32_t data;
797:
798: if (EREAD1(sc, EAP_UART_STATUS) & EAP_US_RXINT) {
799: while (EREAD1(sc, EAP_UART_STATUS) & EAP_US_RXRDY) {
800: data = EREAD1(sc, EAP_UART_DATA);
801: sc->sc_iintr(sc->sc_arg, data);
802: }
803: }
804: }
805: #endif
806: return (1);
807: }
808:
809: int
810: eap_allocmem(struct eap_softc *sc, size_t size, size_t align, struct eap_dma *p)
811: {
812: int error;
813:
814: p->size = size;
815: error = bus_dmamem_alloc(sc->sc_dmatag, p->size, align, 0,
816: p->segs, sizeof(p->segs)/sizeof(p->segs[0]),
817: &p->nsegs, BUS_DMA_NOWAIT);
818: if (error)
819: return (error);
820:
821: error = bus_dmamem_map(sc->sc_dmatag, p->segs, p->nsegs, p->size,
822: &p->addr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
823: if (error)
824: goto free;
825:
826: error = bus_dmamap_create(sc->sc_dmatag, p->size, 1, p->size,
827: 0, BUS_DMA_NOWAIT, &p->map);
828: if (error)
829: goto unmap;
830:
831: error = bus_dmamap_load(sc->sc_dmatag, p->map, p->addr, p->size, NULL,
832: BUS_DMA_NOWAIT);
833: if (error)
834: goto destroy;
835: return (0);
836:
837: destroy:
838: bus_dmamap_destroy(sc->sc_dmatag, p->map);
839: unmap:
840: bus_dmamem_unmap(sc->sc_dmatag, p->addr, p->size);
841: free:
842: bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs);
843: return (error);
844: }
845:
846: int
847: eap_freemem(struct eap_softc *sc, struct eap_dma *p)
848: {
849: bus_dmamap_unload(sc->sc_dmatag, p->map);
850: bus_dmamap_destroy(sc->sc_dmatag, p->map);
851: bus_dmamem_unmap(sc->sc_dmatag, p->addr, p->size);
852: bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs);
853: return (0);
854: }
855:
856: int
857: eap_open(void *addr, int flags)
858: {
859: return (0);
860: }
861:
862: /*
863: * Close function is called at splaudio().
864: */
865: void
866: eap_close(void *addr)
867: {
868: struct eap_softc *sc = addr;
869:
870: eap_halt_output(sc);
871: eap_halt_input(sc);
872:
873: sc->sc_pintr = 0;
874: sc->sc_rintr = 0;
875: }
876:
877: int
878: eap_query_encoding(void *addr, struct audio_encoding *fp)
879: {
880: switch (fp->index) {
881: case 0:
882: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
883: fp->encoding = AUDIO_ENCODING_ULINEAR;
884: fp->precision = 8;
885: fp->flags = 0;
886: return (0);
887: case 1:
888: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
889: fp->encoding = AUDIO_ENCODING_ULAW;
890: fp->precision = 8;
891: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
892: return (0);
893: case 2:
894: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
895: fp->encoding = AUDIO_ENCODING_ALAW;
896: fp->precision = 8;
897: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
898: return (0);
899: case 3:
900: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
901: fp->encoding = AUDIO_ENCODING_SLINEAR;
902: fp->precision = 8;
903: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
904: return (0);
905: case 4:
906: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
907: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
908: fp->precision = 16;
909: fp->flags = 0;
910: return (0);
911: case 5:
912: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
913: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
914: fp->precision = 16;
915: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
916: return (0);
917: case 6:
918: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
919: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
920: fp->precision = 16;
921: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
922: return (0);
923: case 7:
924: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
925: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
926: fp->precision = 16;
927: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
928: return (0);
929: default:
930: return (EINVAL);
931: }
932: }
933:
934: int
935: eap_set_params(void *addr, int setmode, int usemode,
936: struct audio_params *play, struct audio_params *rec)
937: {
938: struct eap_softc *sc = addr;
939: struct audio_params *p;
940: int mode;
941: u_int32_t div;
942:
943: /*
944: * The es1370 only has one clock, so make the sample rates match.
945: */
946: if (!sc->sc_1371) {
947: if (play->sample_rate != rec->sample_rate &&
948: usemode == (AUMODE_PLAY | AUMODE_RECORD)) {
949: if (setmode == AUMODE_PLAY) {
950: rec->sample_rate = play->sample_rate;
951: setmode |= AUMODE_RECORD;
952: } else if (setmode == AUMODE_RECORD) {
953: play->sample_rate = rec->sample_rate;
954: setmode |= AUMODE_PLAY;
955: } else
956: return (EINVAL);
957: }
958: }
959:
960: for (mode = AUMODE_RECORD; mode != -1;
961: mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
962: if ((setmode & mode) == 0)
963: continue;
964:
965: p = mode == AUMODE_PLAY ? play : rec;
966:
967: if (p->sample_rate < 4000 || p->sample_rate > 48000 ||
968: (p->precision != 8 && p->precision != 16) ||
969: (p->channels != 1 && p->channels != 2))
970: return (EINVAL);
971:
972: p->factor = 1;
973: p->sw_code = 0;
974: switch (p->encoding) {
975: case AUDIO_ENCODING_SLINEAR_BE:
976: if (p->precision == 16)
977: p->sw_code = swap_bytes;
978: else
979: p->sw_code = change_sign8;
980: break;
981: case AUDIO_ENCODING_SLINEAR_LE:
982: if (p->precision != 16)
983: p->sw_code = change_sign8;
984: break;
985: case AUDIO_ENCODING_ULINEAR_BE:
986: if (p->precision == 16) {
987: if (mode == AUMODE_PLAY)
988: p->sw_code = swap_bytes_change_sign16_le;
989: else
990: p->sw_code = change_sign16_swap_bytes_le;
991: }
992: break;
993: case AUDIO_ENCODING_ULINEAR_LE:
994: if (p->precision == 16)
995: p->sw_code = change_sign16_le;
996: break;
997: case AUDIO_ENCODING_ULAW:
998: if (mode == AUMODE_PLAY) {
999: p->factor = 2;
1000: p->sw_code = mulaw_to_slinear16_le;
1001: } else
1002: p->sw_code = ulinear8_to_mulaw;
1003: break;
1004: case AUDIO_ENCODING_ALAW:
1005: if (mode == AUMODE_PLAY) {
1006: p->factor = 2;
1007: p->sw_code = alaw_to_slinear16_le;
1008: } else
1009: p->sw_code = ulinear8_to_alaw;
1010: break;
1011: default:
1012: return (EINVAL);
1013: }
1014: }
1015:
1016: if (sc->sc_1371) {
1017: eap1371_set_dac_rate(sc, play->sample_rate, 1);
1018: eap1371_set_dac_rate(sc, play->sample_rate, 2);
1019: eap1371_set_adc_rate(sc, rec->sample_rate);
1020: } else {
1021: /* Set the speed */
1022: DPRINTFN(2, ("eap_set_params: old ICSC = 0x%08x\n",
1023: EREAD4(sc, EAP_ICSC)));
1024: div = EREAD4(sc, EAP_ICSC) & ~EAP_PCLKBITS;
1025: /*
1026: * XXX
1027: * The -2 isn't documented, but seemed to make the wall
1028: * time match
1029: * what I expect. - mycroft
1030: */
1031: if (usemode == AUMODE_RECORD)
1032: div |= EAP_SET_PCLKDIV(EAP_XTAL_FREQ /
1033: rec->sample_rate - 2);
1034: else
1035: div |= EAP_SET_PCLKDIV(EAP_XTAL_FREQ /
1036: play->sample_rate - 2);
1037: div |= EAP_CCB_INTRM;
1038: EWRITE4(sc, EAP_ICSC, div);
1039: DPRINTFN(2, ("eap_set_params: set ICSC = 0x%08x\n", div));
1040: }
1041:
1042: return (0);
1043: }
1044:
1045: int
1046: eap_round_blocksize(void *addr, int blk)
1047: {
1048: return ((blk + 31) & -32); /* keep good alignment */
1049: }
1050:
1051: int
1052: eap_trigger_output(
1053: void *addr,
1054: void *start,
1055: void *end,
1056: int blksize,
1057: void (*intr)(void *),
1058: void *arg,
1059: struct audio_params *param)
1060: {
1061: struct eap_softc *sc = addr;
1062: struct eap_dma *p;
1063: u_int32_t icsc, sic;
1064: int sampshift;
1065:
1066: #ifdef DIAGNOSTIC
1067: if (sc->sc_prun)
1068: panic("eap_trigger_output: already running");
1069: sc->sc_prun = 1;
1070: #endif
1071:
1072: DPRINTFN(1, ("eap_trigger_output: sc=%p start=%p end=%p "
1073: "blksize=%d intr=%p(%p)\n", addr, start, end, blksize, intr, arg));
1074: sc->sc_pintr = intr;
1075: sc->sc_parg = arg;
1076:
1077: sic = EREAD4(sc, EAP_SIC);
1078: sic &= ~(EAP_P2_S_EB | EAP_P2_S_MB | EAP_INC_BITS);
1079: sic |= EAP_SET_P2_ST_INC(0) | EAP_SET_P2_END_INC(param->precision * param->factor / 8);
1080: sampshift = 0;
1081: if (param->precision * param->factor == 16) {
1082: sic |= EAP_P2_S_EB;
1083: sampshift++;
1084: }
1085: if (param->channels == 2) {
1086: sic |= EAP_P2_S_MB;
1087: sampshift++;
1088: }
1089: EWRITE4(sc, EAP_SIC, sic & ~EAP_P2_INTR_EN);
1090: EWRITE4(sc, EAP_SIC, sic | EAP_P2_INTR_EN);
1091:
1092: for (p = sc->sc_dmas; p && KERNADDR(p) != start; p = p->next)
1093: ;
1094: if (!p) {
1095: printf("eap_trigger_output: bad addr %p\n", start);
1096: return (EINVAL);
1097: }
1098:
1099: DPRINTF(("eap_trigger_output: DAC2_ADDR=0x%x, DAC2_SIZE=0x%x\n",
1100: (int)DMAADDR(p),
1101: (int)EAP_SET_SIZE(0, (((char *)end - (char *)start) >> 2) - 1)));
1102: EWRITE4(sc, EAP_MEMPAGE, EAP_DAC_PAGE);
1103: EWRITE4(sc, EAP_DAC2_ADDR, DMAADDR(p));
1104: EWRITE4(sc, EAP_DAC2_SIZE,
1105: EAP_SET_SIZE(0, (((char *)end - (char *)start) >> 2) - 1));
1106:
1107: EWRITE4(sc, EAP_DAC2_CSR, (blksize >> sampshift) - 1);
1108:
1109: if (sc->sc_1371)
1110: EWRITE4(sc, E1371_SRC, 0);
1111:
1112: icsc = EREAD4(sc, EAP_ICSC);
1113: EWRITE4(sc, EAP_ICSC, icsc | EAP_DAC2_EN);
1114:
1115: DPRINTFN(1, ("eap_trigger_output: set ICSC = 0x%08x\n", icsc));
1116:
1117: return (0);
1118: }
1119:
1120: int
1121: eap_trigger_input(
1122: void *addr,
1123: void *start,
1124: void *end,
1125: int blksize,
1126: void (*intr)(void *),
1127: void *arg,
1128: struct audio_params *param)
1129: {
1130: struct eap_softc *sc = addr;
1131: struct eap_dma *p;
1132: u_int32_t icsc, sic;
1133: int sampshift;
1134:
1135: #ifdef DIAGNOSTIC
1136: if (sc->sc_rrun)
1137: panic("eap_trigger_input: already running");
1138: sc->sc_rrun = 1;
1139: #endif
1140:
1141: DPRINTFN(1, ("eap_trigger_input: sc=%p start=%p end=%p blksize=%d intr=%p(%p)\n",
1142: addr, start, end, blksize, intr, arg));
1143: sc->sc_rintr = intr;
1144: sc->sc_rarg = arg;
1145:
1146: sic = EREAD4(sc, EAP_SIC);
1147: sic &= ~(EAP_R1_S_EB | EAP_R1_S_MB);
1148: sampshift = 0;
1149: if (param->precision * param->factor == 16) {
1150: sic |= EAP_R1_S_EB;
1151: sampshift++;
1152: }
1153: if (param->channels == 2) {
1154: sic |= EAP_R1_S_MB;
1155: sampshift++;
1156: }
1157: EWRITE4(sc, EAP_SIC, sic & ~EAP_R1_INTR_EN);
1158: EWRITE4(sc, EAP_SIC, sic | EAP_R1_INTR_EN);
1159:
1160: for (p = sc->sc_dmas; p && KERNADDR(p) != start; p = p->next)
1161: ;
1162: if (!p) {
1163: printf("eap_trigger_input: bad addr %p\n", start);
1164: return (EINVAL);
1165: }
1166:
1167: DPRINTF(("eap_trigger_input: ADC_ADDR=0x%x, ADC_SIZE=0x%x\n",
1168: (int)DMAADDR(p),
1169: (int)EAP_SET_SIZE(0, (((char *)end - (char *)start) >> 2) - 1)));
1170: EWRITE4(sc, EAP_MEMPAGE, EAP_ADC_PAGE);
1171: EWRITE4(sc, EAP_ADC_ADDR, DMAADDR(p));
1172: EWRITE4(sc, EAP_ADC_SIZE,
1173: EAP_SET_SIZE(0, (((char *)end - (char *)start) >> 2) - 1));
1174:
1175: EWRITE4(sc, EAP_ADC_CSR, (blksize >> sampshift) - 1);
1176:
1177: if (sc->sc_1371)
1178: EWRITE4(sc, E1371_SRC, 0);
1179:
1180: icsc = EREAD4(sc, EAP_ICSC);
1181: EWRITE4(sc, EAP_ICSC, icsc | EAP_ADC_EN);
1182:
1183: DPRINTFN(1, ("eap_trigger_input: set ICSC = 0x%08x\n", icsc));
1184:
1185: return (0);
1186: }
1187:
1188: int
1189: eap_halt_output(void *addr)
1190: {
1191: struct eap_softc *sc = addr;
1192: u_int32_t icsc;
1193:
1194: DPRINTF(("eap: eap_halt_output\n"));
1195: icsc = EREAD4(sc, EAP_ICSC);
1196: EWRITE4(sc, EAP_ICSC, icsc & ~EAP_DAC2_EN);
1197: #ifdef DIAGNOSTIC
1198: sc->sc_prun = 0;
1199: #endif
1200: return (0);
1201: }
1202:
1203: int
1204: eap_halt_input(void *addr)
1205: {
1206: struct eap_softc *sc = addr;
1207: u_int32_t icsc;
1208:
1209: DPRINTF(("eap: eap_halt_input\n"));
1210: icsc = EREAD4(sc, EAP_ICSC);
1211: EWRITE4(sc, EAP_ICSC, icsc & ~EAP_ADC_EN);
1212: #ifdef DIAGNOSTIC
1213: sc->sc_rrun = 0;
1214: #endif
1215: return (0);
1216: }
1217:
1218: int
1219: eap_getdev(void *addr, struct audio_device *retp)
1220: {
1221: *retp = eap_device;
1222: return (0);
1223: }
1224:
1225: int
1226: eap1371_mixer_set_port(void *addr, mixer_ctrl_t *cp)
1227: {
1228: struct eap_softc *sc = addr;
1229:
1230: return (sc->codec_if->vtbl->mixer_set_port(sc->codec_if, cp));
1231: }
1232:
1233: int
1234: eap1371_mixer_get_port(void *addr, mixer_ctrl_t *cp)
1235: {
1236: struct eap_softc *sc = addr;
1237:
1238: return (sc->codec_if->vtbl->mixer_get_port(sc->codec_if, cp));
1239: }
1240:
1241: int
1242: eap1371_query_devinfo(void *addr, mixer_devinfo_t *dip)
1243: {
1244: struct eap_softc *sc = addr;
1245:
1246: return (sc->codec_if->vtbl->query_devinfo(sc->codec_if, dip));
1247: }
1248:
1249: int
1250: eap1371_get_portnum_by_name(struct eap_softc *sc,
1251: char *class, char *device, char *qualifier)
1252: {
1253: return (sc->codec_if->vtbl->get_portnum_by_name(sc->codec_if, class,
1254: device, qualifier));
1255: }
1256:
1257: void
1258: eap1370_set_mixer(struct eap_softc *sc, int a, int d)
1259: {
1260: eap1370_write_codec(sc, a, d);
1261:
1262: sc->sc_port[a] = d;
1263: DPRINTFN(1, ("eap1370_mixer_set_port port 0x%02x = 0x%02x\n", a, d));
1264: }
1265:
1266: int
1267: eap1370_mixer_set_port(void *addr, mixer_ctrl_t *cp)
1268: {
1269: struct eap_softc *sc = addr;
1270: int lval, rval, l, r, la, ra;
1271: int l1, r1, l2, r2, m, o1, o2;
1272:
1273: if (cp->dev == EAP_RECORD_SOURCE) {
1274: if (cp->type != AUDIO_MIXER_SET)
1275: return (EINVAL);
1276: m = sc->sc_record_source = cp->un.mask;
1277: l1 = l2 = r1 = r2 = 0;
1278: if (m & (1 << EAP_VOICE_VOL))
1279: l2 |= AK_M_VOICE, r2 |= AK_M_VOICE;
1280: if (m & (1 << EAP_FM_VOL))
1281: l1 |= AK_M_FM_L, r1 |= AK_M_FM_R;
1282: if (m & (1 << EAP_CD_VOL))
1283: l1 |= AK_M_CD_L, r1 |= AK_M_CD_R;
1284: if (m & (1 << EAP_LINE_VOL))
1285: l1 |= AK_M_LINE_L, r1 |= AK_M_LINE_R;
1286: if (m & (1 << EAP_AUX_VOL))
1287: l2 |= AK_M2_AUX_L, r2 |= AK_M2_AUX_R;
1288: if (m & (1 << EAP_MIC_VOL))
1289: l2 |= AK_M_TMIC, r2 |= AK_M_TMIC;
1290: eap1370_set_mixer(sc, AK_IN_MIXER1_L, l1);
1291: eap1370_set_mixer(sc, AK_IN_MIXER1_R, r1);
1292: eap1370_set_mixer(sc, AK_IN_MIXER2_L, l2);
1293: eap1370_set_mixer(sc, AK_IN_MIXER2_R, r2);
1294: return (0);
1295: }
1296: if (cp->dev == EAP_OUTPUT_SELECT) {
1297: if (cp->type != AUDIO_MIXER_SET)
1298: return (EINVAL);
1299: m = sc->sc_output_source = cp->un.mask;
1300: o1 = o2 = 0;
1301: if (m & (1 << EAP_VOICE_VOL))
1302: o2 |= AK_M_VOICE_L | AK_M_VOICE_R;
1303: if (m & (1 << EAP_FM_VOL))
1304: o1 |= AK_M_FM_L | AK_M_FM_R;
1305: if (m & (1 << EAP_CD_VOL))
1306: o1 |= AK_M_CD_L | AK_M_CD_R;
1307: if (m & (1 << EAP_LINE_VOL))
1308: o1 |= AK_M_LINE_L | AK_M_LINE_R;
1309: if (m & (1 << EAP_AUX_VOL))
1310: o2 |= AK_M_AUX_L | AK_M_AUX_R;
1311: if (m & (1 << EAP_MIC_VOL))
1312: o1 |= AK_M_MIC;
1313: eap1370_set_mixer(sc, AK_OUT_MIXER1, o1);
1314: eap1370_set_mixer(sc, AK_OUT_MIXER2, o2);
1315: return (0);
1316: }
1317: if (cp->dev == EAP_MIC_PREAMP) {
1318: if (cp->type != AUDIO_MIXER_ENUM)
1319: return (EINVAL);
1320: if (cp->un.ord != 0 && cp->un.ord != 1)
1321: return (EINVAL);
1322: sc->sc_mic_preamp = cp->un.ord;
1323: eap1370_set_mixer(sc, AK_MGAIN, cp->un.ord);
1324: return (0);
1325: }
1326: if (cp->type != AUDIO_MIXER_VALUE)
1327: return (EINVAL);
1328: if (cp->un.value.num_channels == 1)
1329: lval = rval = cp->un.value.level[AUDIO_MIXER_LEVEL_MONO];
1330: else if (cp->un.value.num_channels == 2) {
1331: lval = cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
1332: rval = cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
1333: } else
1334: return (EINVAL);
1335: ra = -1;
1336: switch (cp->dev) {
1337: case EAP_MASTER_VOL:
1338: l = VOL_TO_ATT5(lval);
1339: r = VOL_TO_ATT5(rval);
1340: la = AK_MASTER_L;
1341: ra = AK_MASTER_R;
1342: break;
1343: case EAP_MIC_VOL:
1344: if (cp->un.value.num_channels != 1)
1345: return (EINVAL);
1346: la = AK_MIC;
1347: goto lr;
1348: case EAP_VOICE_VOL:
1349: la = AK_VOICE_L;
1350: ra = AK_VOICE_R;
1351: goto lr;
1352: case EAP_FM_VOL:
1353: la = AK_FM_L;
1354: ra = AK_FM_R;
1355: goto lr;
1356: case EAP_CD_VOL:
1357: la = AK_CD_L;
1358: ra = AK_CD_R;
1359: goto lr;
1360: case EAP_LINE_VOL:
1361: la = AK_LINE_L;
1362: ra = AK_LINE_R;
1363: goto lr;
1364: case EAP_AUX_VOL:
1365: la = AK_AUX_L;
1366: ra = AK_AUX_R;
1367: lr:
1368: l = VOL_TO_GAIN5(lval);
1369: r = VOL_TO_GAIN5(rval);
1370: break;
1371: default:
1372: return (EINVAL);
1373: }
1374: eap1370_set_mixer(sc, la, l);
1375: if (ra >= 0) {
1376: eap1370_set_mixer(sc, ra, r);
1377: }
1378: return (0);
1379: }
1380:
1381: int
1382: eap1370_mixer_get_port(void *addr, mixer_ctrl_t *cp)
1383: {
1384: struct eap_softc *sc = addr;
1385: int la, ra, l, r;
1386:
1387: switch (cp->dev) {
1388: case EAP_RECORD_SOURCE:
1389: if (cp->type != AUDIO_MIXER_SET)
1390: return (EINVAL);
1391: cp->un.mask = sc->sc_record_source;
1392: return (0);
1393: case EAP_OUTPUT_SELECT:
1394: if (cp->type != AUDIO_MIXER_SET)
1395: return (EINVAL);
1396: cp->un.mask = sc->sc_output_source;
1397: return (0);
1398: case EAP_MIC_PREAMP:
1399: if (cp->type != AUDIO_MIXER_ENUM)
1400: return (EINVAL);
1401: cp->un.ord = sc->sc_mic_preamp;
1402: return (0);
1403: case EAP_MASTER_VOL:
1404: l = ATT5_TO_VOL(sc->sc_port[AK_MASTER_L]);
1405: r = ATT5_TO_VOL(sc->sc_port[AK_MASTER_R]);
1406: break;
1407: case EAP_MIC_VOL:
1408: if (cp->un.value.num_channels != 1)
1409: return (EINVAL);
1410: la = ra = AK_MIC;
1411: goto lr;
1412: case EAP_VOICE_VOL:
1413: la = AK_VOICE_L;
1414: ra = AK_VOICE_R;
1415: goto lr;
1416: case EAP_FM_VOL:
1417: la = AK_FM_L;
1418: ra = AK_FM_R;
1419: goto lr;
1420: case EAP_CD_VOL:
1421: la = AK_CD_L;
1422: ra = AK_CD_R;
1423: goto lr;
1424: case EAP_LINE_VOL:
1425: la = AK_LINE_L;
1426: ra = AK_LINE_R;
1427: goto lr;
1428: case EAP_AUX_VOL:
1429: la = AK_AUX_L;
1430: ra = AK_AUX_R;
1431: lr:
1432: l = GAIN5_TO_VOL(sc->sc_port[la]);
1433: r = GAIN5_TO_VOL(sc->sc_port[ra]);
1434: break;
1435: default:
1436: return (EINVAL);
1437: }
1438: if (cp->un.value.num_channels == 1)
1439: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = (l+r) / 2;
1440: else if (cp->un.value.num_channels == 2) {
1441: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l;
1442: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r;
1443: } else
1444: return (EINVAL);
1445: return (0);
1446: }
1447:
1448: int
1449: eap1370_query_devinfo(void *addr, mixer_devinfo_t *dip)
1450: {
1451: switch (dip->index) {
1452: case EAP_MASTER_VOL:
1453: dip->type = AUDIO_MIXER_VALUE;
1454: dip->mixer_class = EAP_OUTPUT_CLASS;
1455: dip->prev = dip->next = AUDIO_MIXER_LAST;
1456: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
1457: dip->un.v.num_channels = 2;
1458: strlcpy(dip->un.v.units.name, AudioNvolume,
1459: sizeof dip->un.v.units.name);
1460: return (0);
1461: case EAP_VOICE_VOL:
1462: dip->type = AUDIO_MIXER_VALUE;
1463: dip->mixer_class = EAP_INPUT_CLASS;
1464: dip->prev = AUDIO_MIXER_LAST;
1465: dip->next = AUDIO_MIXER_LAST;
1466: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
1467: dip->un.v.num_channels = 2;
1468: strlcpy(dip->un.v.units.name, AudioNvolume,
1469: sizeof dip->un.v.units.name);
1470: return (0);
1471: case EAP_FM_VOL:
1472: dip->type = AUDIO_MIXER_VALUE;
1473: dip->mixer_class = EAP_INPUT_CLASS;
1474: dip->prev = AUDIO_MIXER_LAST;
1475: dip->next = AUDIO_MIXER_LAST;
1476: strlcpy(dip->label.name, AudioNfmsynth,
1477: sizeof dip->label.name);
1478: dip->un.v.num_channels = 2;
1479: strlcpy(dip->un.v.units.name, AudioNvolume,
1480: sizeof dip->un.v.units.name);
1481: return (0);
1482: case EAP_CD_VOL:
1483: dip->type = AUDIO_MIXER_VALUE;
1484: dip->mixer_class = EAP_INPUT_CLASS;
1485: dip->prev = AUDIO_MIXER_LAST;
1486: dip->next = AUDIO_MIXER_LAST;
1487: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
1488: dip->un.v.num_channels = 2;
1489: strlcpy(dip->un.v.units.name, AudioNvolume,
1490: sizeof dip->un.v.units.name);
1491: return (0);
1492: case EAP_LINE_VOL:
1493: dip->type = AUDIO_MIXER_VALUE;
1494: dip->mixer_class = EAP_INPUT_CLASS;
1495: dip->prev = AUDIO_MIXER_LAST;
1496: dip->next = AUDIO_MIXER_LAST;
1497: strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
1498: dip->un.v.num_channels = 2;
1499: strlcpy(dip->un.v.units.name, AudioNvolume,
1500: sizeof dip->un.v.units.name);
1501: return (0);
1502: case EAP_AUX_VOL:
1503: dip->type = AUDIO_MIXER_VALUE;
1504: dip->mixer_class = EAP_INPUT_CLASS;
1505: dip->prev = AUDIO_MIXER_LAST;
1506: dip->next = AUDIO_MIXER_LAST;
1507: strlcpy(dip->label.name, AudioNaux, sizeof dip->label.name);
1508: dip->un.v.num_channels = 2;
1509: strlcpy(dip->un.v.units.name, AudioNvolume,
1510: sizeof dip->un.v.units.name);
1511: return (0);
1512: case EAP_MIC_VOL:
1513: dip->type = AUDIO_MIXER_VALUE;
1514: dip->mixer_class = EAP_INPUT_CLASS;
1515: dip->prev = AUDIO_MIXER_LAST;
1516: dip->next = EAP_MIC_PREAMP;
1517: strlcpy(dip->label.name, AudioNmicrophone,
1518: sizeof dip->label.name);
1519: dip->un.v.num_channels = 1;
1520: strlcpy(dip->un.v.units.name, AudioNvolume,
1521: sizeof dip->un.v.units.name);
1522: return (0);
1523: case EAP_RECORD_SOURCE:
1524: dip->mixer_class = EAP_RECORD_CLASS;
1525: dip->prev = dip->next = AUDIO_MIXER_LAST;
1526: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
1527: dip->type = AUDIO_MIXER_SET;
1528: dip->un.s.num_mem = 6;
1529: strlcpy(dip->un.s.member[0].label.name, AudioNmicrophone,
1530: sizeof dip->un.s.member[0].label.name);
1531: dip->un.s.member[0].mask = 1 << EAP_MIC_VOL;
1532: strlcpy(dip->un.s.member[1].label.name, AudioNcd,
1533: sizeof dip->un.s.member[1].label.name);
1534: dip->un.s.member[1].mask = 1 << EAP_CD_VOL;
1535: strlcpy(dip->un.s.member[2].label.name, AudioNline,
1536: sizeof dip->un.s.member[2].label.name);
1537: dip->un.s.member[2].mask = 1 << EAP_LINE_VOL;
1538: strlcpy(dip->un.s.member[3].label.name, AudioNfmsynth,
1539: sizeof dip->un.s.member[3].label.name);
1540: dip->un.s.member[3].mask = 1 << EAP_FM_VOL;
1541: strlcpy(dip->un.s.member[4].label.name, AudioNaux,
1542: sizeof dip->un.s.member[4].label.name);
1543: dip->un.s.member[4].mask = 1 << EAP_AUX_VOL;
1544: strlcpy(dip->un.s.member[5].label.name, AudioNdac,
1545: sizeof dip->un.s.member[5].label.name);
1546: dip->un.s.member[5].mask = 1 << EAP_VOICE_VOL;
1547: return (0);
1548: case EAP_OUTPUT_SELECT:
1549: dip->mixer_class = EAP_OUTPUT_CLASS;
1550: dip->prev = dip->next = AUDIO_MIXER_LAST;
1551: strlcpy(dip->label.name, AudioNselect, sizeof dip->label.name);
1552: dip->type = AUDIO_MIXER_SET;
1553: dip->un.s.num_mem = 6;
1554: strlcpy(dip->un.s.member[0].label.name, AudioNmicrophone,
1555: sizeof dip->un.s.member[0].label.name);
1556: dip->un.s.member[0].mask = 1 << EAP_MIC_VOL;
1557: strlcpy(dip->un.s.member[1].label.name, AudioNcd,
1558: sizeof dip->un.s.member[1].label.name);
1559: dip->un.s.member[1].mask = 1 << EAP_CD_VOL;
1560: strlcpy(dip->un.s.member[2].label.name, AudioNline,
1561: sizeof dip->un.s.member[2].label.name);
1562: dip->un.s.member[2].mask = 1 << EAP_LINE_VOL;
1563: strlcpy(dip->un.s.member[3].label.name, AudioNfmsynth,
1564: sizeof dip->un.s.member[3].label.name);
1565: dip->un.s.member[3].mask = 1 << EAP_FM_VOL;
1566: strlcpy(dip->un.s.member[4].label.name, AudioNaux,
1567: sizeof dip->un.s.member[4].label.name);
1568: dip->un.s.member[4].mask = 1 << EAP_AUX_VOL;
1569: strlcpy(dip->un.s.member[5].label.name, AudioNdac,
1570: sizeof dip->un.s.member[5].label.name);
1571: dip->un.s.member[5].mask = 1 << EAP_VOICE_VOL;
1572: return (0);
1573: case EAP_MIC_PREAMP:
1574: dip->type = AUDIO_MIXER_ENUM;
1575: dip->mixer_class = EAP_INPUT_CLASS;
1576: dip->prev = EAP_MIC_VOL;
1577: dip->next = AUDIO_MIXER_LAST;
1578: strlcpy(dip->label.name, AudioNpreamp, sizeof dip->label.name);
1579: dip->un.e.num_mem = 2;
1580: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
1581: sizeof dip->un.e.member[0].label.name);
1582: dip->un.e.member[0].ord = 0;
1583: strlcpy(dip->un.e.member[1].label.name, AudioNon,
1584: sizeof dip->un.e.member[1].label.name);
1585: dip->un.e.member[1].ord = 1;
1586: return (0);
1587: case EAP_OUTPUT_CLASS:
1588: dip->type = AUDIO_MIXER_CLASS;
1589: dip->mixer_class = EAP_OUTPUT_CLASS;
1590: dip->next = dip->prev = AUDIO_MIXER_LAST;
1591: strlcpy(dip->label.name, AudioCoutputs,
1592: sizeof dip->label.name);
1593: return (0);
1594: case EAP_RECORD_CLASS:
1595: dip->type = AUDIO_MIXER_CLASS;
1596: dip->mixer_class = EAP_RECORD_CLASS;
1597: dip->next = dip->prev = AUDIO_MIXER_LAST;
1598: strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
1599: return (0);
1600: case EAP_INPUT_CLASS:
1601: dip->type = AUDIO_MIXER_CLASS;
1602: dip->mixer_class = EAP_INPUT_CLASS;
1603: dip->next = dip->prev = AUDIO_MIXER_LAST;
1604: strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
1605: return (0);
1606: }
1607: return (ENXIO);
1608: }
1609:
1610: void *
1611: eap_malloc(void *addr, int direction, size_t size, int pool, int flags)
1612: {
1613: struct eap_softc *sc = addr;
1614: struct eap_dma *p;
1615: int error;
1616:
1617: p = malloc(sizeof(*p), pool, flags);
1618: if (!p)
1619: return (0);
1620: error = eap_allocmem(sc, size, 16, p);
1621: if (error) {
1622: free(p, pool);
1623: return (0);
1624: }
1625: p->next = sc->sc_dmas;
1626: sc->sc_dmas = p;
1627: return (KERNADDR(p));
1628: }
1629:
1630: void
1631: eap_free(void *addr, void *ptr, int pool)
1632: {
1633: struct eap_softc *sc = addr;
1634: struct eap_dma **pp, *p;
1635:
1636: for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &p->next) {
1637: if (KERNADDR(p) == ptr) {
1638: eap_freemem(sc, p);
1639: *pp = p->next;
1640: free(p, pool);
1641: return;
1642: }
1643: }
1644: }
1645:
1646: paddr_t
1647: eap_mappage(void *addr, void *mem, off_t off, int prot)
1648: {
1649: struct eap_softc *sc = addr;
1650: struct eap_dma *p;
1651:
1652: if (off < 0)
1653: return (-1);
1654: for (p = sc->sc_dmas; p && KERNADDR(p) != mem; p = p->next)
1655: ;
1656: if (!p)
1657: return (-1);
1658: return (bus_dmamem_mmap(sc->sc_dmatag, p->segs, p->nsegs,
1659: off, prot, BUS_DMA_WAITOK));
1660: }
1661:
1662: int
1663: eap_get_props(void *addr)
1664: {
1665: return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT |
1666: AUDIO_PROP_FULLDUPLEX);
1667: }
1668:
1669: enum ac97_host_flags
1670: eap_flags_codec(void *v)
1671: {
1672: struct eap_softc *sc = v;
1673:
1674: return (sc->flags);
1675: }
1676: #if NMIDI > 0
1677: int
1678: eap_midi_open(void *addr, int flags,
1679: void (*iintr)(void *, int),
1680: void (*ointr)(void *),
1681: void *arg)
1682: {
1683: struct eap_softc *sc = addr;
1684: u_int32_t uctrl;
1685:
1686: sc->sc_iintr = iintr;
1687: sc->sc_ointr = ointr;
1688: sc->sc_arg = arg;
1689:
1690: EWRITE4(sc, EAP_ICSC, EREAD4(sc, EAP_ICSC) | EAP_UART_EN);
1691: uctrl = 0;
1692: if (flags & FREAD)
1693: uctrl |= EAP_UC_RXINTEN;
1694: #if 0
1695: /* I don't understand ../midi.c well enough to use output interrupts */
1696: if (flags & FWRITE)
1697: uctrl |= EAP_UC_TXINTEN; */
1698: #endif
1699: EWRITE1(sc, EAP_UART_CONTROL, uctrl);
1700:
1701: return (0);
1702: }
1703:
1704: void
1705: eap_midi_close(void *addr)
1706: {
1707: struct eap_softc *sc = addr;
1708:
1709: tsleep(sc, PWAIT, "eapclm", hz/10); /* give uart a chance to drain */
1710: EWRITE1(sc, EAP_UART_CONTROL, 0);
1711: EWRITE4(sc, EAP_ICSC, EREAD4(sc, EAP_ICSC) & ~EAP_UART_EN);
1712:
1713: sc->sc_iintr = 0;
1714: sc->sc_ointr = 0;
1715: }
1716:
1717: int
1718: eap_midi_output(void *addr, int d)
1719: {
1720: struct eap_softc *sc = addr;
1721: int x;
1722:
1723: for (x = 0; x != MIDI_BUSY_WAIT; x++) {
1724: if (EREAD1(sc, EAP_UART_STATUS) & EAP_US_TXRDY) {
1725: EWRITE1(sc, EAP_UART_DATA, d);
1726: return (0);
1727: }
1728: delay(MIDI_BUSY_DELAY);
1729: }
1730: return (EIO);
1731: }
1732:
1733: void
1734: eap_midi_getinfo(void *addr, struct midi_info *mi)
1735: {
1736: mi->name = "AudioPCI MIDI UART";
1737: mi->props = MIDI_PROP_CAN_INPUT;
1738: }
1739:
1740: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to eap.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci