Annotation of sys/dev/pci/emuxki.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: emuxki.c,v 1.24 2007/07/10 22:04:28 jakemsr Exp $ */
2: /* $NetBSD: emuxki.c,v 1.1 2001/10/17 18:39:41 jdolecek Exp $ */
3:
4: /*-
5: * Copyright (c) 2001 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Yannick Montulet.
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: * Driver for Creative Labs SBLive! series and probably PCI512.
42: *
43: * Known bugs:
44: * - inversed stereo at ac97 codec level
45: * (XXX jdolecek - don't see the problem? maybe because auvia(4) has
46: * it swapped too?)
47: * - bass disappear when you plug rear jack-in on Cambridge FPS2000 speakers
48: * (and presumably all speakers that support front and rear jack-in)
49: *
50: * TODO:
51: * - Digital Outputs
52: * - (midi/mpu),joystick support
53: * - Multiple voices play (problem with /dev/audio architecture)
54: * - Multiple sources recording (Pb with audio(4))
55: * - Independent modification of each channel's parameters (via mixer ?)
56: * - DSP FX patches (to make fx like chipmunk)
57: */
58:
59: #include <sys/types.h>
60: #include <sys/device.h>
61: #include <sys/errno.h>
62: #include <sys/malloc.h>
63: #include <sys/systm.h>
64: #include <sys/param.h>
65: #include <sys/audioio.h>
66: #include <sys/selinfo.h>
67:
68: #include <dev/pci/pcireg.h>
69: #include <dev/pci/pcivar.h>
70: #include <dev/pci/pcidevs.h>
71:
72: #include <dev/audio_if.h>
73: #include <dev/audiovar.h>
74: #include <dev/auconv.h>
75: #include <dev/mulaw.h>
76: #include <dev/ic/ac97.h>
77:
78: #include <dev/pci/emuxkireg.h>
79: #include <dev/pci/emuxkivar.h>
80:
81: #define slinear16_to_ulinear8_le linear16_to_ulinear8_le;
82:
83: /* autconf goo */
84: int emuxki_match(struct device *, void *, void *);
85: void emuxki_attach(struct device *, struct device *, void *);
86: int emuxki_detach(struct device *, int);
87: int emuxki_scinit(struct emuxki_softc *sc);
88: void emuxki_pci_shutdown(struct emuxki_softc *sc);
89:
90: /* dma mem mgmt */
91: struct dmamem *emuxki_dmamem_alloc(bus_dma_tag_t, size_t, bus_size_t,
92: int, int, int);
93: void emuxki_dmamem_free(struct dmamem *, int);
94: void emuxki_dmamem_delete(struct dmamem *mem, int type);
95:
96: struct emuxki_mem *emuxki_mem_new(struct emuxki_softc *sc, int ptbidx,
97: size_t size, int type, int flags);
98: void emuxki_mem_delete(struct emuxki_mem *mem, int type);
99:
100: /* Emu10k1 init & shutdown */
101: int emuxki_init(struct emuxki_softc *);
102: void emuxki_shutdown(struct emuxki_softc *);
103:
104: /* Emu10k1 mem mgmt */
105: void *emuxki_pmem_alloc(struct emuxki_softc *, size_t,int,int);
106: void *emuxki_rmem_alloc(struct emuxki_softc *, size_t,int,int);
107:
108: /*
109: * Emu10k1 channels funcs : There is no direct access to channels, everything
110: * is done through voices I will at least provide channel based fx params
111: * modification, later...
112: */
113:
114: /* Emu10k1 voice mgmt */
115: struct emuxki_voice *emuxki_voice_new(struct emuxki_softc *, u_int8_t);
116: void emuxki_voice_delete(struct emuxki_voice *);
117: int emuxki_voice_set_audioparms(struct emuxki_voice *, u_int8_t, u_int8_t, u_int32_t);
118: /* emuxki_voice_set_fxparms will come later, it'll need channel distinction */
119: int emuxki_voice_set_bufparms(struct emuxki_voice *, void *, u_int32_t, u_int16_t);
120: int emuxki_voice_set_stereo(struct emuxki_voice *voice, u_int8_t stereo);
121: int emuxki_voice_dataloc_create(struct emuxki_voice *voice);
122: void emuxki_voice_dataloc_destroy(struct emuxki_voice *voice);
123: void emuxki_voice_commit_parms(struct emuxki_voice *);
124: void emuxki_voice_recsrc_release(struct emuxki_softc *sc, emuxki_recsrc_t source);
125: int emuxki_recsrc_reserve(struct emuxki_voice *voice, emuxki_recsrc_t source);
126: int emuxki_voice_adc_rate(struct emuxki_voice *);
127: u_int32_t emuxki_voice_curaddr(struct emuxki_voice *);
128: int emuxki_set_vparms(struct emuxki_voice *voice, struct audio_params *p);
129: int emuxki_voice_set_srate(struct emuxki_voice *voice, u_int32_t srate);
130: void emuxki_voice_start(struct emuxki_voice *, void (*) (void *), void *);
131: void emuxki_voice_halt(struct emuxki_voice *);
132: int emuxki_voice_channel_create(struct emuxki_voice *voice);
133: void emuxki_voice_channel_destroy(struct emuxki_voice *voice);
134:
135: struct emuxki_channel *emuxki_channel_new(struct emuxki_voice *voice, u_int8_t num);
136: void emuxki_channel_delete(struct emuxki_channel *chan);
137: void emuxki_channel_start(struct emuxki_channel *chan);
138: void emuxki_channel_stop(struct emuxki_channel *chan);
139: void emuxki_channel_commit_fx(struct emuxki_channel *chan);
140: void emuxki_channel_commit_parms(struct emuxki_channel *chan);
141: void emuxki_channel_set_bufparms(struct emuxki_channel *chan, u_int32_t start, u_int32_t end);
142: void emuxki_channel_set_srate(struct emuxki_channel *chan, u_int32_t srate);
143: void emuxki_channel_set_fxsend(struct emuxki_channel *chan,
144: struct emuxki_chanparms_fxsend *fxsend);
145: void emuxki_chanparms_set_defaults(struct emuxki_channel *chan);
146:
147: void emuxki_resched_timer(struct emuxki_softc *sc);
148:
149: /*
150: * Emu10k1 stream mgmt : not done yet
151: */
152: #if 0
153: struct emuxki_stream *emuxki_stream_new(struct emu10k1 *);
154: void emuxki_stream_delete(struct emuxki_stream *);
155: int emuxki_stream_set_audio_params(struct emuxki_stream *, u_int8_t,
156: u_int8_t, u_int8_t, u_int16_t);
157: void emuxki_stream_start(struct emuxki_stream *);
158: void emuxki_stream_halt(struct emuxki_stream *);
159: #endif
160:
161: /* fx interface */
162: void emuxki_initfx(struct emuxki_softc *sc);
163: void emuxki_dsp_addop(struct emuxki_softc *sc, u_int16_t *pc, u_int8_t op,
164: u_int16_t r, u_int16_t a, u_int16_t x, u_int16_t y);
165: void emuxki_write_micro(struct emuxki_softc *sc, u_int32_t pc, u_int32_t data);
166:
167: /* audio interface callbacks */
168:
169: int emuxki_open(void *, int);
170: void emuxki_close(void *);
171:
172: int emuxki_query_encoding(void *, struct audio_encoding *);
173: int emuxki_set_params(void *, int, int,
174: struct audio_params *,
175: struct audio_params *);
176:
177: int emuxki_round_blocksize(void *, int);
178: size_t emuxki_round_buffersize(void *, int, size_t);
179:
180: int emuxki_trigger_output(void *, void *, void *, int, void (*)(void *),
181: void *, struct audio_params *);
182: int emuxki_trigger_input(void *, void *, void *, int, void (*) (void *),
183: void *, struct audio_params *);
184: int emuxki_halt_output(void *);
185: int emuxki_halt_input(void *);
186:
187: int emuxki_getdev(void *, struct audio_device *);
188: int emuxki_set_port(void *, mixer_ctrl_t *);
189: int emuxki_get_port(void *, mixer_ctrl_t *);
190: int emuxki_query_devinfo(void *, mixer_devinfo_t *);
191:
192: void *emuxki_allocm(void *, int, size_t, int, int);
193: void emuxki_freem(void *, void *, int);
194:
195: paddr_t emuxki_mappage(void *, void *, off_t, int);
196: int emuxki_get_props(void *);
197:
198: /* Interrupt handler */
199: int emuxki_intr(void *);
200:
201: /* Emu10k1 AC97 interface callbacks */
202: int emuxki_ac97_init(struct emuxki_softc *sc);
203: int emuxki_ac97_attach(void *, struct ac97_codec_if *);
204: int emuxki_ac97_read(void *, u_int8_t, u_int16_t *);
205: int emuxki_ac97_write(void *, u_int8_t, u_int16_t);
206: void emuxki_ac97_reset(void *);
207:
208: const struct pci_matchid emuxki_devices[] = {
209: { PCI_VENDOR_CREATIVELABS, PCI_PRODUCT_CREATIVELABS_SBLIVE },
210: { PCI_VENDOR_CREATIVELABS, PCI_PRODUCT_CREATIVELABS_SBLIVE2 },
211: { PCI_VENDOR_CREATIVELABS, PCI_PRODUCT_CREATIVELABS_AUDIGY },
212: { PCI_VENDOR_CREATIVELABS, PCI_PRODUCT_CREATIVELABS_AUDIGY2 },
213: };
214:
215: /*
216: * Autoconfig goo.
217: */
218: struct cfdriver emu_cd = {
219: NULL, "emu", DV_DULL
220: };
221:
222: struct cfattach emu_ca = {
223: sizeof(struct emuxki_softc),
224: emuxki_match,
225: emuxki_attach,
226: emuxki_detach,
227: NULL /* config activate */
228: };
229:
230: struct audio_hw_if emuxki_hw_if = {
231: emuxki_open,
232: emuxki_close,
233: NULL, /* drain */
234: emuxki_query_encoding,
235: emuxki_set_params,
236: emuxki_round_blocksize,
237: NULL, /* commit settings */
238: NULL, /* init_output */
239: NULL, /* init_input */
240: NULL, /* start_output */
241: NULL, /* start_input */
242: emuxki_halt_output,
243: emuxki_halt_input,
244: NULL, /* speaker_ctl */
245: emuxki_getdev,
246: NULL, /* setfd */
247: emuxki_set_port,
248: emuxki_get_port,
249: emuxki_query_devinfo,
250: emuxki_allocm,
251: emuxki_freem,
252: emuxki_round_buffersize,
253: emuxki_mappage,
254: emuxki_get_props,
255: emuxki_trigger_output,
256: emuxki_trigger_input,
257: };
258:
259: #if 0
260: static const int emuxki_recsrc_intrmasks[EMU_NUMRECSRCS] =
261: { EMU_INTE_MICBUFENABLE, EMU_INTE_ADCBUFENABLE, EMU_INTE_EFXBUFENABLE };
262: #endif
263: static const u_int32_t emuxki_recsrc_bufaddrreg[EMU_NUMRECSRCS] =
264: { EMU_MICBA, EMU_ADCBA, EMU_FXBA };
265: static const u_int32_t emuxki_recsrc_szreg[EMU_NUMRECSRCS] =
266: { EMU_MICBS, EMU_ADCBS, EMU_FXBS };
267: static const int emuxki_recbuf_sz[] = {
268: 0, 384, 448, 512, 640, 768, 896, 1024, 1280, 1536, 1792,
269: 2048, 2560, 3072, 3584, 4096, 5120, 6144, 7168, 8192, 10240,
270: 12288, 14366, 16384, 20480, 24576, 28672, 32768, 40960, 49152,
271: 57344, 65536
272: };
273:
274: /*
275: * DMA memory mgmt
276: */
277:
278: void
279: emuxki_dmamem_delete(struct dmamem *mem, int type)
280: {
281: free(mem->segs, type);
282: free(mem, type);
283: }
284:
285: struct dmamem *
286: emuxki_dmamem_alloc(bus_dma_tag_t dmat, size_t size, bus_size_t align,
287: int nsegs, int type, int flags)
288: {
289: struct dmamem *mem;
290: int bus_dma_flags;
291:
292: /* Allocate memory for structure */
293: if ((mem = malloc(sizeof(*mem), type, flags)) == NULL)
294: return (NULL);
295: mem->dmat = dmat;
296: mem->size = size;
297: mem->align = align;
298: mem->nsegs = nsegs;
299: mem->bound = 0;
300:
301: mem->segs = malloc(mem->nsegs * sizeof(*(mem->segs)), type, flags);
302: if (mem->segs == NULL) {
303: free(mem, type);
304: return (NULL);
305: }
306:
307: bus_dma_flags = (flags & M_NOWAIT) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
308: if (bus_dmamem_alloc(dmat, mem->size, mem->align, mem->bound,
309: mem->segs, mem->nsegs, &(mem->rsegs),
310: bus_dma_flags)) {
311: emuxki_dmamem_delete(mem, type);
312: return (NULL);
313: }
314:
315: if (bus_dmamem_map(dmat, mem->segs, mem->nsegs, mem->size,
316: &(mem->kaddr), bus_dma_flags | BUS_DMA_COHERENT)) {
317: bus_dmamem_free(dmat, mem->segs, mem->nsegs);
318: emuxki_dmamem_delete(mem, type);
319: return (NULL);
320: }
321:
322: if (bus_dmamap_create(dmat, mem->size, mem->nsegs, mem->size,
323: mem->bound, bus_dma_flags, &(mem->map))) {
324: bus_dmamem_unmap(dmat, mem->kaddr, mem->size);
325: bus_dmamem_free(dmat, mem->segs, mem->nsegs);
326: emuxki_dmamem_delete(mem, type);
327: return (NULL);
328: }
329:
330: if (bus_dmamap_load(dmat, mem->map, mem->kaddr,
331: mem->size, NULL, bus_dma_flags)) {
332: bus_dmamap_destroy(dmat, mem->map);
333: bus_dmamem_unmap(dmat, mem->kaddr, mem->size);
334: bus_dmamem_free(dmat, mem->segs, mem->nsegs);
335: emuxki_dmamem_delete(mem, type);
336: return (NULL);
337: }
338:
339: return (mem);
340: }
341:
342: void
343: emuxki_dmamem_free(struct dmamem *mem, int type)
344: {
345: bus_dmamap_unload(mem->dmat, mem->map);
346: bus_dmamap_destroy(mem->dmat, mem->map);
347: bus_dmamem_unmap(mem->dmat, mem->kaddr, mem->size);
348: bus_dmamem_free(mem->dmat, mem->segs, mem->nsegs);
349: emuxki_dmamem_delete(mem, type);
350: }
351:
352:
353: /*
354: * Autoconf device callbacks : attach and detach
355: */
356:
357: void
358: emuxki_pci_shutdown(struct emuxki_softc *sc)
359: {
360: if (sc->sc_ih != NULL)
361: pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
362: if (sc->sc_ios)
363: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
364: }
365:
366: int
367: emuxki_scinit(struct emuxki_softc *sc)
368: {
369: int err;
370:
371: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,
372: /* enable spdif(?) output on non-APS */
373: (sc->sc_type == EMUXKI_APS? 0 : EMU_HCFG_GPOUTPUT0) |
374: EMU_HCFG_LOCKSOUNDCACHE | EMU_HCFG_LOCKTANKCACHE_MASK |
375: EMU_HCFG_MUTEBUTTONENABLE);
376: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE,
377: EMU_INTE_SAMPLERATER | EMU_INTE_PCIERRENABLE);
378:
379: if ((err = emuxki_init(sc)))
380: return (err);
381:
382: if (sc->sc_type & EMUXKI_AUDIGY2) {
383: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,
384: EMU_HCFG_AUDIOENABLE | EMU_HCFG_AC3ENABLE_CDSPDIF |
385: EMU_HCFG_AC3ENABLE_GPSPDIF | EMU_HCFG_AUTOMUTE);
386: } else if (sc->sc_type & EMUXKI_AUDIGY) {
387: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,
388: EMU_HCFG_AUDIOENABLE | EMU_HCFG_AUTOMUTE);
389: } else {
390: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,
391: EMU_HCFG_AUDIOENABLE | EMU_HCFG_JOYENABLE |
392: EMU_HCFG_LOCKTANKCACHE_MASK | EMU_HCFG_AUTOMUTE);
393: }
394: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE,
395: bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_INTE) |
396: EMU_INTE_VOLINCRENABLE | EMU_INTE_VOLDECRENABLE |
397: EMU_INTE_MUTEENABLE);
398:
399: if (sc->sc_type & EMUXKI_AUDIGY2) {
400: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A_IOCFG,
401: EMU_A_IOCFG_GPOUT0 |
402: bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_A_IOCFG));
403: }
404:
405: /* No multiple voice support for now */
406: sc->pvoice = sc->rvoice = NULL;
407:
408: return (0);
409: }
410:
411: int
412: emuxki_ac97_init(struct emuxki_softc *sc)
413: {
414: sc->hostif.arg = sc;
415: sc->hostif.attach = emuxki_ac97_attach;
416: sc->hostif.read = emuxki_ac97_read;
417: sc->hostif.write = emuxki_ac97_write;
418: sc->hostif.reset = emuxki_ac97_reset;
419: sc->hostif.flags = NULL;
420: return (ac97_attach(&(sc->hostif)));
421: }
422:
423: int
424: emuxki_match(struct device *parent, void *match, void *aux)
425: {
426: return (pci_matchbyid((struct pci_attach_args *)aux, emuxki_devices,
427: sizeof(emuxki_devices)/sizeof(emuxki_devices[0])));
428: }
429:
430: void
431: emuxki_attach(struct device *parent, struct device *self, void *aux)
432: {
433: struct emuxki_softc *sc = (struct emuxki_softc *) self;
434: struct pci_attach_args *pa = aux;
435: pci_intr_handle_t ih;
436: const char *intrstr;
437:
438: if (pci_mapreg_map(pa, EMU_PCI_CBIO, PCI_MAPREG_TYPE_IO, 0,
439: &(sc->sc_iot), &(sc->sc_ioh), &(sc->sc_iob), &(sc->sc_ios), 0)) {
440: printf(": can't map iospace\n");
441: return;
442: }
443:
444: sc->sc_pc = pa->pa_pc;
445: sc->sc_dmat = pa->pa_dmat;
446:
447: if (pci_intr_map(pa, &ih)) {
448: printf(": couldn't map interrupt\n");
449: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
450: return;
451: }
452:
453: intrstr = pci_intr_string(pa->pa_pc, ih);
454: sc->sc_ih = pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO, emuxki_intr,
455: sc, sc->sc_dev.dv_xname);
456: if (sc->sc_ih == NULL) {
457: printf(": couldn't establish interrupt");
458: if (intrstr != NULL)
459: printf(" at %s", intrstr);
460: printf("\n");
461: bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
462: return;
463: }
464: printf(": %s\n", intrstr);
465:
466: /* XXX it's unknown whether APS is made from Audigy as well */
467: if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_CREATIVELABS_AUDIGY) {
468: sc->sc_type = EMUXKI_AUDIGY;
469: if (PCI_REVISION(pa->pa_class) == 0x04 ||
470: PCI_REVISION(pa->pa_class) == 0x08) {
471: sc->sc_type |= EMUXKI_AUDIGY2;
472: strlcpy(sc->sc_audv.name, "Audigy2", sizeof sc->sc_audv.name);
473: } else {
474: strlcpy(sc->sc_audv.name, "Audigy", sizeof sc->sc_audv.name);
475: }
476: } else if (pci_conf_read(pa->pa_pc, pa->pa_tag,
477: PCI_SUBSYS_ID_REG) == EMU_SUBSYS_APS) {
478: sc->sc_type = EMUXKI_APS;
479: strlcpy(sc->sc_audv.name, "E-mu APS", sizeof sc->sc_audv.name);
480: } else {
481: sc->sc_type = EMUXKI_SBLIVE;
482: strlcpy(sc->sc_audv.name, "SB Live!", sizeof sc->sc_audv.name);
483: }
484: snprintf(sc->sc_audv.version, sizeof sc->sc_audv.version, "0x%02x",
485: PCI_REVISION(pa->pa_class));
486: strlcpy(sc->sc_audv.config, "emuxki", sizeof sc->sc_audv.config);
487:
488: if (emuxki_scinit(sc) ||
489: /* APS has no ac97 XXX */
490: (sc->sc_type == EMUXKI_APS || emuxki_ac97_init(sc)) ||
491: (sc->sc_audev = audio_attach_mi(&emuxki_hw_if, sc, self)) == NULL) {
492: emuxki_pci_shutdown(sc);
493: return;
494: }
495: }
496:
497: int
498: emuxki_detach(struct device *self, int flags)
499: {
500: struct emuxki_softc *sc = (struct emuxki_softc *) self;
501:
502: if (sc->sc_audev != NULL) /* Test in case audio didn't attach */
503: config_detach(sc->sc_audev, 0);
504:
505: /* All voices should be stopped now but add some code here if not */
506:
507: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,
508: EMU_HCFG_LOCKSOUNDCACHE | EMU_HCFG_LOCKTANKCACHE_MASK |
509: EMU_HCFG_MUTEBUTTONENABLE);
510: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE, 0);
511:
512: emuxki_shutdown(sc);
513:
514: emuxki_pci_shutdown(sc);
515:
516: return (0);
517: }
518:
519:
520: /* Misc stuff relative to emu10k1 */
521:
522: static __inline u_int32_t
523: emuxki_rate_to_pitch(u_int32_t rate)
524: {
525: static const u_int32_t logMagTable[128] = {
526: 0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3,
527: 0x13aa2, 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a,
528: 0x2655d, 0x28ed5, 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb,
529: 0x381b6, 0x3a93d, 0x3d081, 0x3f782, 0x41e42, 0x444c1, 0x46b01,
530: 0x49101, 0x4b6c4, 0x4dc49, 0x50191, 0x5269e, 0x54b6f, 0x57006,
531: 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7, 0x646ee, 0x66a00,
532: 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829, 0x759d4,
533: 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
534: 0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20,
535: 0x93d26, 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec,
536: 0xa11d8, 0xa2f9d, 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241,
537: 0xadf26, 0xafbe7, 0xb1885, 0xb3500, 0xb5157, 0xb6d8c, 0xb899f,
538: 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899, 0xc1404, 0xc2f50, 0xc4a7b,
539: 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c, 0xceaec, 0xd053f,
540: 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3, 0xdba4a,
541: 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
542: 0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a,
543: 0xf2c83, 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57,
544: 0xfd1a7, 0xfe8df
545: };
546: static const u_int8_t logSlopeTable[128] = {
547: 0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
548: 0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
549: 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
550: 0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
551: 0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
552: 0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
553: 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
554: 0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
555: 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
556: 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
557: 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
558: 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
559: 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
560: 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
561: 0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
562: 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
563: };
564: int8_t i;
565:
566: if (rate == 0)
567: return 0; /* Bail out if no leading "1" */
568: rate *= 11185; /* Scale 48000 to 0x20002380 */
569: for (i = 31; i > 0; i--) {
570: if (rate & 0x80000000) { /* Detect leading "1" */
571: return (((u_int32_t) (i - 15) << 20) +
572: logMagTable[0x7f & (rate >> 24)] +
573: (0x7f & (rate >> 17)) *
574: logSlopeTable[0x7f & (rate >> 24)]);
575: }
576: rate <<= 1;
577: }
578:
579: return 0; /* Should never reach this point */
580: }
581:
582: /* Emu10k1 Low level */
583:
584: static __inline u_int32_t
585: emuxki_read(struct emuxki_softc *sc, u_int16_t chano, u_int32_t reg)
586: {
587: u_int32_t ptr, mask = 0xffffffff;
588: u_int8_t size, offset = 0;
589: int s;
590:
591: ptr = ((((u_int32_t) reg) << 16) &
592: (sc->sc_type & EMUXKI_AUDIGY ?
593: EMU_A_PTR_ADDR_MASK : EMU_PTR_ADDR_MASK)) |
594: (chano & EMU_PTR_CHNO_MASK);
595: if (reg & 0xff000000) {
596: size = (reg >> 24) & 0x3f;
597: offset = (reg >> 16) & 0x1f;
598: mask = ((1 << size) - 1) << offset;
599: }
600:
601: s = splaudio();
602: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_PTR, ptr);
603: ptr = (bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_DATA) & mask)
604: >> offset;
605: splx(s);
606:
607: return (ptr);
608: }
609:
610: static __inline void
611: emuxki_write(struct emuxki_softc *sc, u_int16_t chano,
612: u_int32_t reg, u_int32_t data)
613: {
614: u_int32_t ptr, mask;
615: u_int8_t size, offset;
616: int s;
617:
618: ptr = ((((u_int32_t) reg) << 16) &
619: (sc->sc_type & EMUXKI_AUDIGY ?
620: EMU_A_PTR_ADDR_MASK : EMU_PTR_ADDR_MASK)) |
621: (chano & EMU_PTR_CHNO_MASK);
622:
623: /* BE CAREFUL WITH THAT AXE, EUGENE */
624: if (ptr == 0x52 || ptr == 0x53)
625: return;
626:
627: if (reg & 0xff000000) {
628: size = (reg >> 24) & 0x3f;
629: offset = (reg >> 16) & 0x1f;
630: mask = ((1 << size) - 1) << offset;
631: data = ((data << offset) & mask) |
632: (emuxki_read(sc, chano, reg & 0xffff) & ~mask);
633: }
634:
635: s = splaudio();
636: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_PTR, ptr);
637: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_DATA, data);
638: splx(s);
639: }
640:
641: /* Microcode should this go in /sys/dev/microcode ? */
642:
643: void
644: emuxki_write_micro(struct emuxki_softc *sc, u_int32_t pc, u_int32_t data)
645: {
646: emuxki_write(sc, 0,
647: (sc->sc_type & EMUXKI_AUDIGY ?
648: EMU_A_MICROCODEBASE : EMU_MICROCODEBASE) + pc,
649: data);
650: }
651:
652: void
653: emuxki_dsp_addop(struct emuxki_softc *sc, u_int16_t *pc, u_int8_t op,
654: u_int16_t r, u_int16_t a, u_int16_t x, u_int16_t y)
655: {
656: if (sc->sc_type & EMUXKI_AUDIGY) {
657: emuxki_write_micro(sc, *pc << 1,
658: ((x << 12) & EMU_A_DSP_LOWORD_OPX_MASK) |
659: (y & EMU_A_DSP_LOWORD_OPY_MASK));
660: emuxki_write_micro(sc, (*pc << 1) + 1,
661: ((op << 24) & EMU_A_DSP_HIWORD_OPCODE_MASK) |
662: ((r << 12) & EMU_A_DSP_HIWORD_RESULT_MASK) |
663: (a & EMU_A_DSP_HIWORD_OPA_MASK));
664: } else {
665: emuxki_write_micro(sc, *pc << 1,
666: ((x << 10) & EMU_DSP_LOWORD_OPX_MASK) |
667: (y & EMU_DSP_LOWORD_OPY_MASK));
668: emuxki_write_micro(sc, (*pc << 1) + 1,
669: ((op << 20) & EMU_DSP_HIWORD_OPCODE_MASK) |
670: ((r << 10) & EMU_DSP_HIWORD_RESULT_MASK) |
671: (a & EMU_DSP_HIWORD_OPA_MASK));
672: }
673: (*pc)++;
674: }
675:
676: /* init and shutdown */
677:
678: void
679: emuxki_initfx(struct emuxki_softc *sc)
680: {
681: u_int16_t pc;
682:
683: /* Set all GPRs to 0 */
684: for (pc = 0; pc < 256; pc++)
685: emuxki_write(sc, 0, EMU_DSP_GPR(pc), 0);
686: for (pc = 0; pc < 160; pc++) {
687: emuxki_write(sc, 0, EMU_TANKMEMDATAREGBASE + pc, 0);
688: emuxki_write(sc, 0, EMU_TANKMEMADDRREGBASE + pc, 0);
689: }
690: pc = 0;
691:
692: if (sc->sc_type & EMUXKI_AUDIGY) {
693: /* AC97 Out (l/r) = AC97 In (l/r) + FX[0/1] * 4 */
694: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
695: EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_FRONT),
696: EMU_A_DSP_CST(0),
697: EMU_DSP_FX(0), EMU_A_DSP_CST(4));
698: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
699: EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_FRONT),
700: EMU_A_DSP_CST(0),
701: EMU_DSP_FX(1), EMU_A_DSP_CST(4));
702:
703: /* Rear channel OUT (l/r) = FX[2/3] * 4 */
704: #if 0
705: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
706: EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_REAR),
707: EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_FRONT),
708: EMU_DSP_FX(0), EMU_A_DSP_CST(4));
709: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
710: EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_REAR),
711: EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_FRONT),
712: EMU_DSP_FX(1), EMU_A_DSP_CST(4));
713: #endif
714: /* ADC recording (l/r) = AC97 In (l/r) */
715: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
716: EMU_A_DSP_OUTL(EMU_A_DSP_OUT_ADC),
717: EMU_A_DSP_INL(EMU_DSP_IN_AC97),
718: EMU_A_DSP_CST(0), EMU_A_DSP_CST(0));
719: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
720: EMU_A_DSP_OUTR(EMU_A_DSP_OUT_ADC),
721: EMU_A_DSP_INR(EMU_DSP_IN_AC97),
722: EMU_A_DSP_CST(0), EMU_A_DSP_CST(0));
723:
724: /* zero out the rest of the microcode */
725: while (pc < 512)
726: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
727: EMU_A_DSP_CST(0), EMU_A_DSP_CST(0),
728: EMU_A_DSP_CST(0), EMU_A_DSP_CST(0));
729:
730: emuxki_write(sc, 0, EMU_A_DBG, 0); /* Is it really necessary ? */
731: } else {
732: /* AC97 Out (l/r) = AC97 In (l/r) + FX[0/1] * 4 */
733: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
734: EMU_DSP_OUTL(EMU_DSP_OUT_A_FRONT),
735: EMU_DSP_CST(0),
736: EMU_DSP_FX(0), EMU_DSP_CST(4));
737: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
738: EMU_DSP_OUTR(EMU_DSP_OUT_A_FRONT),
739: EMU_DSP_CST(0),
740: EMU_DSP_FX(1), EMU_DSP_CST(4));
741:
742: /* Rear channel OUT (l/r) = FX[2/3] * 4 */
743: #if 0
744: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
745: EMU_DSP_OUTL(EMU_DSP_OUT_AD_REAR),
746: EMU_DSP_OUTL(EMU_DSP_OUT_A_FRONT),
747: EMU_DSP_FX(0), EMU_DSP_CST(4));
748: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
749: EMU_DSP_OUTR(EMU_DSP_OUT_AD_REAR),
750: EMU_DSP_OUTR(EMU_DSP_OUT_A_FRONT),
751: EMU_DSP_FX(1), EMU_DSP_CST(4));
752: #endif
753: /* ADC recording (l/r) = AC97 In (l/r) */
754: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
755: EMU_DSP_OUTL(EMU_DSP_OUT_ADC),
756: EMU_DSP_INL(EMU_DSP_IN_AC97),
757: EMU_DSP_CST(0), EMU_DSP_CST(0));
758: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
759: EMU_DSP_OUTR(EMU_DSP_OUT_ADC),
760: EMU_DSP_INR(EMU_DSP_IN_AC97),
761: EMU_DSP_CST(0), EMU_DSP_CST(0));
762:
763: /* zero out the rest of the microcode */
764: while (pc < 512)
765: emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
766: EMU_DSP_CST(0), EMU_DSP_CST(0),
767: EMU_DSP_CST(0), EMU_DSP_CST(0));
768:
769: emuxki_write(sc, 0, EMU_DBG, 0); /* Is it really necessary ? */
770: }
771: }
772:
773: int
774: emuxki_init(struct emuxki_softc *sc)
775: {
776: u_int16_t i;
777: u_int32_t spcs, *ptb;
778: bus_addr_t silentpage;
779:
780: /* disable any channel interrupt */
781: emuxki_write(sc, 0, EMU_CLIEL, 0);
782: emuxki_write(sc, 0, EMU_CLIEH, 0);
783: emuxki_write(sc, 0, EMU_SOLEL, 0);
784: emuxki_write(sc, 0, EMU_SOLEH, 0);
785:
786: /* Set recording buffers sizes to zero */
787: emuxki_write(sc, 0, EMU_MICBS, EMU_RECBS_BUFSIZE_NONE);
788: emuxki_write(sc, 0, EMU_MICBA, 0);
789: emuxki_write(sc, 0, EMU_FXBS, EMU_RECBS_BUFSIZE_NONE);
790: emuxki_write(sc, 0, EMU_FXBA, 0);
791: emuxki_write(sc, 0, EMU_ADCBS, EMU_RECBS_BUFSIZE_NONE);
792: emuxki_write(sc, 0, EMU_ADCBA, 0);
793:
794: if(sc->sc_type & EMUXKI_AUDIGY) {
795: emuxki_write(sc, 0, EMU_SPBYPASS, EMU_SPBYPASS_24_BITS);
796: emuxki_write(sc, 0, EMU_AC97SLOT, EMU_AC97SLOT_CENTER | EMU_AC97SLOT_LFE);
797: }
798:
799: /* Initialize all channels to stopped and no effects */
800: for (i = 0; i < EMU_NUMCHAN; i++) {
801: emuxki_write(sc, i, EMU_CHAN_DCYSUSV, 0);
802: emuxki_write(sc, i, EMU_CHAN_IP, 0);
803: emuxki_write(sc, i, EMU_CHAN_VTFT, 0xffff);
804: emuxki_write(sc, i, EMU_CHAN_CVCF, 0xffff);
805: emuxki_write(sc, i, EMU_CHAN_PTRX, 0);
806: emuxki_write(sc, i, EMU_CHAN_CPF, 0);
807: emuxki_write(sc, i, EMU_CHAN_CCR, 0);
808: emuxki_write(sc, i, EMU_CHAN_PSST, 0);
809: emuxki_write(sc, i, EMU_CHAN_DSL, 0x10); /* Why 16 ? */
810: emuxki_write(sc, i, EMU_CHAN_CCCA, 0);
811: emuxki_write(sc, i, EMU_CHAN_Z1, 0);
812: emuxki_write(sc, i, EMU_CHAN_Z2, 0);
813: emuxki_write(sc, i, EMU_CHAN_FXRT, 0x32100000);
814: emuxki_write(sc, i, EMU_CHAN_ATKHLDM, 0);
815: emuxki_write(sc, i, EMU_CHAN_DCYSUSM, 0);
816: emuxki_write(sc, i, EMU_CHAN_IFATN, 0xffff);
817: emuxki_write(sc, i, EMU_CHAN_PEFE, 0);
818: emuxki_write(sc, i, EMU_CHAN_FMMOD, 0);
819: emuxki_write(sc, i, EMU_CHAN_TREMFRQ, 24);
820: emuxki_write(sc, i, EMU_CHAN_FM2FRQ2, 24);
821: emuxki_write(sc, i, EMU_CHAN_TEMPENV, 0);
822:
823: /* these are last so OFF prevents writing */
824: emuxki_write(sc, i, EMU_CHAN_LFOVAL2, 0);
825: emuxki_write(sc, i, EMU_CHAN_LFOVAL1, 0);
826: emuxki_write(sc, i, EMU_CHAN_ATKHLDV, 0);
827: emuxki_write(sc, i, EMU_CHAN_ENVVOL, 0);
828: emuxki_write(sc, i, EMU_CHAN_ENVVAL, 0);
829: }
830:
831: /* set digital outputs format */
832: spcs = (EMU_SPCS_CLKACCY_1000PPM | EMU_SPCS_SAMPLERATE_48 |
833: EMU_SPCS_CHANNELNUM_LEFT | EMU_SPCS_SOURCENUM_UNSPEC |
834: EMU_SPCS_GENERATIONSTATUS | 0x00001200 /* Cat code. */ |
835: 0x00000000 /* IEC-958 Mode */ | EMU_SPCS_EMPHASIS_NONE |
836: EMU_SPCS_COPYRIGHT);
837: emuxki_write(sc, 0, EMU_SPCS0, spcs);
838: emuxki_write(sc, 0, EMU_SPCS1, spcs);
839: emuxki_write(sc, 0, EMU_SPCS2, spcs);
840:
841: if(sc->sc_type & EMUXKI_AUDIGY2) {
842: emuxki_write(sc, 0, EMU_A2_SPDIF_SAMPLERATE, EMU_A2_SPDIF_UNKNOWN);
843:
844: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_PTR, EMU_A2_SRCSEL);
845: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_DATA,
846: EMU_A2_SRCSEL_ENABLE_SPDIF | EMU_A2_SRCSEL_ENABLE_SRCMULTI);
847:
848: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_PTR, EMU_A2_SRCMULTI);
849: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_DATA, EMU_A2_SRCMULTI_ENABLE_INPUT);
850: }
851:
852:
853: /* Let's play with sound processor */
854: emuxki_initfx(sc);
855:
856: /* Here is our Page Table */
857: if ((sc->ptb = emuxki_dmamem_alloc(sc->sc_dmat,
858: EMU_MAXPTE * sizeof(u_int32_t),
859: EMU_DMA_ALIGN, EMU_DMAMEM_NSEG,
860: M_DEVBUF, M_WAITOK)) == NULL)
861: return (ENOMEM);
862:
863: /* This is necessary unless you like Metallic noise... */
864: if ((sc->silentpage = emuxki_dmamem_alloc(sc->sc_dmat, EMU_PTESIZE,
865: EMU_DMA_ALIGN, EMU_DMAMEM_NSEG, M_DEVBUF, M_WAITOK))==NULL){
866: emuxki_dmamem_free(sc->ptb, M_DEVBUF);
867: return (ENOMEM);
868: }
869:
870: /* Zero out the silent page */
871: /* This might not be always true, it might be 128 for 8bit channels */
872: memset(KERNADDR(sc->silentpage), 0, DMASIZE(sc->silentpage));
873:
874: /*
875: * Set all the PTB Entries to the silent page We shift the physical
876: * address by one and OR it with the page number. I don't know what
877: * the ORed index is for, might be a very useful unused feature...
878: */
879: silentpage = DMAADDR(sc->silentpage) << 1;
880: ptb = KERNADDR(sc->ptb);
881: for (i = 0; i < EMU_MAXPTE; i++)
882: ptb[i] = htole32(silentpage | i);
883:
884: /* Write PTB address and set TCB to none */
885: emuxki_write(sc, 0, EMU_PTB, DMAADDR(sc->ptb));
886: emuxki_write(sc, 0, EMU_TCBS, 0); /* This means 16K TCB */
887: emuxki_write(sc, 0, EMU_TCB, 0); /* No TCB use for now */
888:
889: /*
890: * Set channels MAPs to the silent page.
891: * I don't know what MAPs are for.
892: */
893: silentpage |= EMU_CHAN_MAP_PTI_MASK;
894: for (i = 0; i < EMU_NUMCHAN; i++) {
895: emuxki_write(sc, i, EMU_CHAN_MAPA, silentpage);
896: emuxki_write(sc, i, EMU_CHAN_MAPB, silentpage);
897: sc->channel[i] = NULL;
898: }
899:
900: /* Init voices list */
901: LIST_INIT(&(sc->voices));
902:
903: /* Timer is stopped */
904: sc->timerstate &= ~EMU_TIMER_STATE_ENABLED;
905: return (0);
906: }
907:
908: void
909: emuxki_shutdown(struct emuxki_softc *sc)
910: {
911: u_int32_t i;
912:
913: /* Disable any Channels interrupts */
914: emuxki_write(sc, 0, EMU_CLIEL, 0);
915: emuxki_write(sc, 0, EMU_CLIEH, 0);
916: emuxki_write(sc, 0, EMU_SOLEL, 0);
917: emuxki_write(sc, 0, EMU_SOLEH, 0);
918:
919: /*
920: * Should do some voice(stream) stopping stuff here, that's what will
921: * stop and deallocate all channels.
922: */
923:
924: /* Stop all channels */
925: /* XXX This shouldn't be necessary, I'll remove once everything works */
926: for (i = 0; i < EMU_NUMCHAN; i++)
927: emuxki_write(sc, i, EMU_CHAN_DCYSUSV, 0);
928: for (i = 0; i < EMU_NUMCHAN; i++) {
929: emuxki_write(sc, i, EMU_CHAN_VTFT, 0);
930: emuxki_write(sc, i, EMU_CHAN_CVCF, 0);
931: emuxki_write(sc, i, EMU_CHAN_PTRX, 0);
932: emuxki_write(sc, i, EMU_CHAN_CPF, 0);
933: }
934:
935: /*
936: * Deallocate Emu10k1 caches and recording buffers. Again it will be
937: * removed because it will be done in voice shutdown.
938: */
939: emuxki_write(sc, 0, EMU_MICBS, EMU_RECBS_BUFSIZE_NONE);
940: emuxki_write(sc, 0, EMU_MICBA, 0);
941: emuxki_write(sc, 0, EMU_FXBS, EMU_RECBS_BUFSIZE_NONE);
942: emuxki_write(sc, 0, EMU_FXBA, 0);
943: if(sc->sc_type & EMUXKI_AUDIGY) {
944: emuxki_write(sc, 0, EMU_A_FXWC1, 0);
945: emuxki_write(sc, 0, EMU_A_FXWC2, 0);
946: } else {
947: emuxki_write(sc, 0, EMU_FXWC, 0);
948: }
949: emuxki_write(sc, 0, EMU_ADCBS, EMU_RECBS_BUFSIZE_NONE);
950: emuxki_write(sc, 0, EMU_ADCBA, 0);
951:
952: /*
953: * XXX I don't know yet how I will handle tank cache buffer,
954: * I don't even clearly know what it is for.
955: */
956: emuxki_write(sc, 0, EMU_TCB, 0); /* 16K again */
957: emuxki_write(sc, 0, EMU_TCBS, 0);
958:
959: emuxki_write(sc, 0, EMU_DBG, 0x8000); /* necessary ? */
960:
961: emuxki_dmamem_free(sc->silentpage, M_DEVBUF);
962: emuxki_dmamem_free(sc->ptb, M_DEVBUF);
963: }
964:
965: /* Emu10k1 Memory management */
966:
967: struct emuxki_mem *
968: emuxki_mem_new(struct emuxki_softc *sc, int ptbidx,
969: size_t size, int type, int flags)
970: {
971: struct emuxki_mem *mem;
972:
973: if ((mem = malloc(sizeof(*mem), type, flags)) == NULL)
974: return (NULL);
975:
976: mem->ptbidx = ptbidx;
977: if ((mem->dmamem = emuxki_dmamem_alloc(sc->sc_dmat, size,
978: EMU_DMA_ALIGN, EMU_DMAMEM_NSEG, type, flags)) == NULL) {
979: free(mem, type);
980: return (NULL);
981: }
982: return (mem);
983: }
984:
985: void
986: emuxki_mem_delete(struct emuxki_mem *mem, int type)
987: {
988: emuxki_dmamem_free(mem->dmamem, type);
989: free(mem, type);
990: }
991:
992: void *
993: emuxki_pmem_alloc(struct emuxki_softc *sc, size_t size, int type, int flags)
994: {
995: int i, j, s;
996: size_t numblocks;
997: struct emuxki_mem *mem;
998: u_int32_t *ptb, silentpage;
999:
1000: ptb = KERNADDR(sc->ptb);
1001: silentpage = DMAADDR(sc->silentpage) << 1;
1002: numblocks = size / EMU_PTESIZE;
1003: if (size % EMU_PTESIZE)
1004: numblocks++;
1005:
1006: for (i = 0; i < EMU_MAXPTE; i++)
1007: if ((letoh32(ptb[i]) & EMU_CHAN_MAP_PTE_MASK) == silentpage) {
1008: /* We look for a free PTE */
1009: s = splaudio();
1010: for (j = 0; j < numblocks; j++)
1011: if ((letoh32(ptb[i + j])
1012: & EMU_CHAN_MAP_PTE_MASK)
1013: != silentpage)
1014: break;
1015: if (j == numblocks) {
1016: if ((mem = emuxki_mem_new(sc, i,
1017: size, type, flags)) == NULL) {
1018: splx(s);
1019: return (NULL);
1020: }
1021: for (j = 0; j < numblocks; j++)
1022: ptb[i + j] =
1023: htole32((((DMAADDR(mem->dmamem) +
1024: j * EMU_PTESIZE)) << 1) | (i + j));
1025: LIST_INSERT_HEAD(&(sc->mem), mem, next);
1026: splx(s);
1027: return (KERNADDR(mem->dmamem));
1028: } else
1029: i += j;
1030: splx(s);
1031: }
1032: return (NULL);
1033: }
1034:
1035: void *
1036: emuxki_rmem_alloc(struct emuxki_softc *sc, size_t size, int type, int flags)
1037: {
1038: struct emuxki_mem *mem;
1039: int s;
1040:
1041: mem = emuxki_mem_new(sc, EMU_RMEM, size, type, flags);
1042: if (mem == NULL)
1043: return (NULL);
1044:
1045: s = splaudio();
1046: LIST_INSERT_HEAD(&(sc->mem), mem, next);
1047: splx(s);
1048:
1049: return (KERNADDR(mem->dmamem));
1050: }
1051:
1052: /*
1053: * emuxki_channel_* : Channel management functions
1054: * emuxki_chanparms_* : Channel parameters modification functions
1055: */
1056:
1057: /*
1058: * is splaudio necessary here, can the same voice be manipulated by two
1059: * different threads at a time ?
1060: */
1061: void
1062: emuxki_chanparms_set_defaults(struct emuxki_channel *chan)
1063: {
1064: chan->fxsend.a.level = chan->fxsend.b.level =
1065: chan->fxsend.c.level = chan->fxsend.d.level =
1066: /* for audigy */
1067: chan->fxsend.e.level = chan->fxsend.f.level =
1068: chan->fxsend.g.level = chan->fxsend.h.level =
1069: chan->voice->sc->sc_type & EMUXKI_AUDIGY ?
1070: 0xc0 : 0xff; /* not max */
1071:
1072: chan->fxsend.a.dest = 0x0;
1073: chan->fxsend.b.dest = 0x1;
1074: chan->fxsend.c.dest = 0x2;
1075: chan->fxsend.d.dest = 0x3;
1076: /* for audigy */
1077: chan->fxsend.e.dest = 0x4;
1078: chan->fxsend.f.dest = 0x5;
1079: chan->fxsend.g.dest = 0x6;
1080: chan->fxsend.h.dest = 0x7;
1081:
1082: chan->pitch.initial = 0x0000; /* shouldn't it be 0xE000 ? */
1083: chan->pitch.current = 0x0000; /* should it be 0x0400 */
1084: chan->pitch.target = 0x0000; /* the unity pitch shift ? */
1085: chan->pitch.envelope_amount = 0x00; /* none */
1086:
1087: chan->initial_attenuation = 0x00; /* no attenuation */
1088: chan->volume.current = 0x0000; /* no volume */
1089: chan->volume.target = 0xffff;
1090: chan->volume.envelope.current_state = 0x8000; /* 0 msec delay */
1091: chan->volume.envelope.hold_time = 0x7f; /* 0 msec */
1092: chan->volume.envelope.attack_time = 0x7F; /* 5.5msec */
1093: chan->volume.envelope.sustain_level = 0x7F; /* full */
1094: chan->volume.envelope.decay_time = 0x7F; /* 22msec */
1095:
1096: chan->filter.initial_cutoff_frequency = 0xff; /* no filter */
1097: chan->filter.current_cutoff_frequency = 0xffff; /* no filtering */
1098: chan->filter.target_cutoff_frequency = 0xffff; /* no filtering */
1099: chan->filter.lowpass_resonance_height = 0x0;
1100: chan->filter.interpolation_ROM = 0x1; /* full band */
1101: chan->filter.envelope_amount = 0x7f; /* none */
1102: chan->filter.LFO_modulation_depth = 0x00; /* none */
1103:
1104: chan->loop.start = 0x000000;
1105: chan->loop.end = 0x000010; /* Why ? */
1106:
1107: chan->modulation.envelope.current_state = 0x8000;
1108: chan->modulation.envelope.hold_time = 0x00; /* 127 better ? */
1109: chan->modulation.envelope.attack_time = 0x00; /* infinite */
1110: chan->modulation.envelope.sustain_level = 0x00; /* off */
1111: chan->modulation.envelope.decay_time = 0x7f; /* 22 msec */
1112: chan->modulation.LFO_state = 0x8000;
1113:
1114: chan->vibrato_LFO.state = 0x8000;
1115: chan->vibrato_LFO.modulation_depth = 0x00; /* none */
1116: chan->vibrato_LFO.vibrato_depth = 0x00;
1117: chan->vibrato_LFO.frequency = 0x00; /* Why set to 24 when
1118: * initialized ? */
1119:
1120: chan->tremolo_depth = 0x00;
1121: }
1122:
1123: /* only call it at splaudio */
1124: struct emuxki_channel *
1125: emuxki_channel_new(struct emuxki_voice *voice, u_int8_t num)
1126: {
1127: struct emuxki_channel *chan;
1128:
1129: chan = malloc(sizeof(struct emuxki_channel), M_DEVBUF, M_WAITOK);
1130: if (chan == NULL)
1131: return (NULL);
1132:
1133: chan->voice = voice;
1134: chan->num = num;
1135: emuxki_chanparms_set_defaults(chan);
1136: chan->voice->sc->channel[num] = chan;
1137: return (chan);
1138: }
1139:
1140: /* only call it at splaudio */
1141: void
1142: emuxki_channel_delete(struct emuxki_channel *chan)
1143: {
1144: chan->voice->sc->channel[chan->num] = NULL;
1145: free(chan, M_DEVBUF);
1146: }
1147:
1148: void
1149: emuxki_channel_set_fxsend(struct emuxki_channel *chan,
1150: struct emuxki_chanparms_fxsend *fxsend)
1151: {
1152: /* Could do a memcpy ...*/
1153: chan->fxsend.a.level = fxsend->a.level;
1154: chan->fxsend.b.level = fxsend->b.level;
1155: chan->fxsend.c.level = fxsend->c.level;
1156: chan->fxsend.d.level = fxsend->d.level;
1157: chan->fxsend.a.dest = fxsend->a.dest;
1158: chan->fxsend.b.dest = fxsend->b.dest;
1159: chan->fxsend.c.dest = fxsend->c.dest;
1160: chan->fxsend.d.dest = fxsend->d.dest;
1161:
1162: /* for audigy */
1163: chan->fxsend.e.level = fxsend->e.level;
1164: chan->fxsend.f.level = fxsend->f.level;
1165: chan->fxsend.g.level = fxsend->g.level;
1166: chan->fxsend.h.level = fxsend->h.level;
1167: chan->fxsend.e.dest = fxsend->e.dest;
1168: chan->fxsend.f.dest = fxsend->f.dest;
1169: chan->fxsend.g.dest = fxsend->g.dest;
1170: chan->fxsend.h.dest = fxsend->h.dest;
1171: }
1172:
1173: void
1174: emuxki_channel_set_srate(struct emuxki_channel *chan, u_int32_t srate)
1175: {
1176: chan->pitch.target = (srate << 8) / 375;
1177: chan->pitch.target = (chan->pitch.target >> 1) +
1178: (chan->pitch.target & 1);
1179: chan->pitch.target &= 0xffff;
1180: chan->pitch.current = chan->pitch.target;
1181: chan->pitch.initial =
1182: (emuxki_rate_to_pitch(srate) >> 8) & EMU_CHAN_IP_MASK;
1183: }
1184:
1185: /* voice params must be set before calling this */
1186: void
1187: emuxki_channel_set_bufparms(struct emuxki_channel *chan,
1188: u_int32_t start, u_int32_t end)
1189: {
1190: chan->loop.start = start & EMU_CHAN_PSST_LOOPSTARTADDR_MASK;
1191: chan->loop.end = end & EMU_CHAN_DSL_LOOPENDADDR_MASK;
1192: }
1193:
1194: void
1195: emuxki_channel_commit_fx(struct emuxki_channel *chan)
1196: {
1197: struct emuxki_softc *sc = chan->voice->sc;
1198: u_int8_t chano = chan->num;
1199:
1200: if(sc->sc_type & EMUXKI_AUDIGY) {
1201: emuxki_write(sc, chano, EMU_A_CHAN_FXRT1,
1202: (chan->fxsend.d.dest << 24) |
1203: (chan->fxsend.c.dest << 16) |
1204: (chan->fxsend.b.dest << 8) |
1205: (chan->fxsend.a.dest));
1206: emuxki_write(sc, chano, EMU_A_CHAN_FXRT2,
1207: (chan->fxsend.h.dest << 24) |
1208: (chan->fxsend.g.dest << 16) |
1209: (chan->fxsend.f.dest << 8) |
1210: (chan->fxsend.e.dest));
1211: emuxki_write(sc, chano, EMU_A_CHAN_SENDAMOUNTS,
1212: (chan->fxsend.e.level << 24) |
1213: (chan->fxsend.f.level << 16) |
1214: (chan->fxsend.g.level << 8) |
1215: (chan->fxsend.h.level));
1216: } else {
1217: emuxki_write(sc, chano, EMU_CHAN_FXRT,
1218: (chan->fxsend.d.dest << 28) |
1219: (chan->fxsend.c.dest << 24) |
1220: (chan->fxsend.b.dest << 20) |
1221: (chan->fxsend.a.dest << 16));
1222: }
1223:
1224: emuxki_write(sc, chano, 0x10000000 | EMU_CHAN_PTRX,
1225: (chan->fxsend.a.level << 8) | chan->fxsend.b.level);
1226: emuxki_write(sc, chano, EMU_CHAN_DSL,
1227: (chan->fxsend.d.level << 24) | chan->loop.end);
1228: emuxki_write(sc, chano, EMU_CHAN_PSST,
1229: (chan->fxsend.c.level << 24) | chan->loop.start);
1230: }
1231:
1232: void
1233: emuxki_channel_commit_parms(struct emuxki_channel *chan)
1234: {
1235: struct emuxki_voice *voice = chan->voice;
1236: struct emuxki_softc *sc = voice->sc;
1237: u_int32_t start, mapval;
1238: u_int8_t chano = chan->num;
1239: int s;
1240:
1241: start = chan->loop.start +
1242: (voice->stereo ? 28 : 30) * (voice->b16 + 1);
1243: mapval = DMAADDR(sc->silentpage) << 1 | EMU_CHAN_MAP_PTI_MASK;
1244:
1245: s = splaudio();
1246: emuxki_write(sc, chano, EMU_CHAN_CPF_STEREO, voice->stereo);
1247:
1248: emuxki_channel_commit_fx(chan);
1249:
1250: emuxki_write(sc, chano, EMU_CHAN_CCCA,
1251: (chan->filter.lowpass_resonance_height << 28) |
1252: (chan->filter.interpolation_ROM << 25) |
1253: (voice->b16 ? 0 : EMU_CHAN_CCCA_8BITSELECT) | start);
1254: emuxki_write(sc, chano, EMU_CHAN_Z1, 0);
1255: emuxki_write(sc, chano, EMU_CHAN_Z2, 0);
1256: emuxki_write(sc, chano, EMU_CHAN_MAPA, mapval);
1257: emuxki_write(sc, chano, EMU_CHAN_MAPB, mapval);
1258: emuxki_write(sc, chano, EMU_CHAN_CVCF_CURRFILTER,
1259: chan->filter.current_cutoff_frequency);
1260: emuxki_write(sc, chano, EMU_CHAN_VTFT_FILTERTARGET,
1261: chan->filter.target_cutoff_frequency);
1262: emuxki_write(sc, chano, EMU_CHAN_ATKHLDM,
1263: (chan->modulation.envelope.hold_time << 8) |
1264: chan->modulation.envelope.attack_time);
1265: emuxki_write(sc, chano, EMU_CHAN_DCYSUSM,
1266: (chan->modulation.envelope.sustain_level << 8) |
1267: chan->modulation.envelope.decay_time);
1268: emuxki_write(sc, chano, EMU_CHAN_LFOVAL1,
1269: chan->modulation.LFO_state);
1270: emuxki_write(sc, chano, EMU_CHAN_LFOVAL2,
1271: chan->vibrato_LFO.state);
1272: emuxki_write(sc, chano, EMU_CHAN_FMMOD,
1273: (chan->vibrato_LFO.modulation_depth << 8) |
1274: chan->filter.LFO_modulation_depth);
1275: emuxki_write(sc, chano, EMU_CHAN_TREMFRQ,
1276: (chan->tremolo_depth << 8));
1277: emuxki_write(sc, chano, EMU_CHAN_FM2FRQ2,
1278: (chan->vibrato_LFO.vibrato_depth << 8) |
1279: chan->vibrato_LFO.frequency);
1280: emuxki_write(sc, chano, EMU_CHAN_ENVVAL,
1281: chan->modulation.envelope.current_state);
1282: emuxki_write(sc, chano, EMU_CHAN_ATKHLDV,
1283: (chan->volume.envelope.hold_time << 8) |
1284: chan->volume.envelope.attack_time);
1285: emuxki_write(sc, chano, EMU_CHAN_ENVVOL,
1286: chan->volume.envelope.current_state);
1287: emuxki_write(sc, chano, EMU_CHAN_PEFE,
1288: (chan->pitch.envelope_amount << 8) |
1289: chan->filter.envelope_amount);
1290: splx(s);
1291: }
1292:
1293: void
1294: emuxki_channel_start(struct emuxki_channel *chan)
1295: {
1296: struct emuxki_voice *voice = chan->voice;
1297: struct emuxki_softc *sc = voice->sc;
1298: u_int8_t cache_sample, cache_invalid_size, chano = chan->num;
1299: u_int32_t sample;
1300: int s;
1301:
1302: cache_sample = voice->stereo ? 4 : 2;
1303: sample = voice->b16 ? 0x00000000 : 0x80808080;
1304: cache_invalid_size = (voice->stereo ? 28 : 30) * (voice->b16 + 1);
1305:
1306: s = splaudio();
1307: while (cache_sample--) {
1308: emuxki_write(sc, chano, EMU_CHAN_CD0 + cache_sample,
1309: sample);
1310: }
1311: emuxki_write(sc, chano, EMU_CHAN_CCR_CACHEINVALIDSIZE, 0);
1312: emuxki_write(sc, chano, EMU_CHAN_CCR_READADDRESS, 64);
1313: emuxki_write(sc, chano, EMU_CHAN_CCR_CACHEINVALIDSIZE,
1314: cache_invalid_size);
1315: emuxki_write(sc, chano, EMU_CHAN_IFATN,
1316: (chan->filter.target_cutoff_frequency << 8) |
1317: chan->initial_attenuation);
1318: emuxki_write(sc, chano, EMU_CHAN_VTFT_VOLUMETARGET,
1319: chan->volume.target);
1320: emuxki_write(sc, chano, EMU_CHAN_CVCF_CURRVOL,
1321: chan->volume.current);
1322: emuxki_write(sc, 0,
1323: EMU_MKSUBREG(1, chano, EMU_SOLEL + (chano >> 5)),
1324: 0); /* Clear stop on loop */
1325: emuxki_write(sc, 0,
1326: EMU_MKSUBREG(1, chano, EMU_CLIEL + (chano >> 5)),
1327: 0); /* Clear loop interrupt */
1328: emuxki_write(sc, chano, EMU_CHAN_DCYSUSV,
1329: (chan->volume.envelope.sustain_level << 8) |
1330: chan->volume.envelope.decay_time);
1331: emuxki_write(sc, chano, EMU_CHAN_PTRX_PITCHTARGET,
1332: chan->pitch.target);
1333: emuxki_write(sc, chano, EMU_CHAN_CPF_PITCH,
1334: chan->pitch.current);
1335: emuxki_write(sc, chano, EMU_CHAN_IP, chan->pitch.initial);
1336:
1337: splx(s);
1338: }
1339:
1340: void
1341: emuxki_channel_stop(struct emuxki_channel *chan)
1342: {
1343: int s;
1344: u_int8_t chano = chan->num;
1345: struct emuxki_softc *sc = chan->voice->sc;
1346:
1347: s = splaudio();
1348: emuxki_write(sc, chano, EMU_CHAN_PTRX_PITCHTARGET, 0);
1349: emuxki_write(sc, chano, EMU_CHAN_CPF_PITCH, 0);
1350: emuxki_write(sc, chano, EMU_CHAN_IFATN_ATTENUATION, 0xff);
1351: emuxki_write(sc, chano, EMU_CHAN_VTFT_VOLUMETARGET, 0);
1352: emuxki_write(sc, chano, EMU_CHAN_CVCF_CURRVOL, 0);
1353: emuxki_write(sc, chano, EMU_CHAN_IP, 0);
1354: splx(s);
1355: }
1356:
1357: /*
1358: * Voices management
1359: * emuxki_voice_dataloc : use(play or rec) independent dataloc union helpers
1360: * emuxki_voice_channel_* : play part of dataloc union helpers
1361: * emuxki_voice_recsrc_* : rec part of dataloc union helpers
1362: */
1363:
1364: /* Allocate channels for voice in case of play voice */
1365: int
1366: emuxki_voice_channel_create(struct emuxki_voice *voice)
1367: {
1368: struct emuxki_channel **channel = voice->sc->channel;
1369: u_int8_t i, stereo = voice->stereo;
1370: int s;
1371:
1372: for (i = 0; i < EMU_NUMCHAN; i += stereo + 1) {
1373: if ((stereo && (channel[i + 1] != NULL)) ||
1374: (channel[i] != NULL)) /* Looking for free channels */
1375: continue;
1376: s = splaudio();
1377: if (stereo) {
1378: voice->dataloc.chan[1] =
1379: emuxki_channel_new(voice, i + 1);
1380: if (voice->dataloc.chan[1] == NULL) {
1381: splx(s);
1382: return (ENOMEM);
1383: }
1384: }
1385: voice->dataloc.chan[0] = emuxki_channel_new(voice, i);
1386: if (voice->dataloc.chan[0] == NULL) {
1387: if (stereo) {
1388: emuxki_channel_delete(voice->dataloc.chan[1]);
1389: voice->dataloc.chan[1] = NULL;
1390: }
1391: splx(s);
1392: return (ENOMEM);
1393: }
1394: splx(s);
1395: return (0);
1396: }
1397: return (EAGAIN);
1398: }
1399:
1400: /* When calling this function we assume no one can access the voice */
1401: void
1402: emuxki_voice_channel_destroy(struct emuxki_voice *voice)
1403: {
1404: emuxki_channel_delete(voice->dataloc.chan[0]);
1405: voice->dataloc.chan[0] = NULL;
1406: if (voice->stereo)
1407: emuxki_channel_delete(voice->dataloc.chan[1]);
1408: voice->dataloc.chan[1] = NULL;
1409: }
1410:
1411: /*
1412: * Will come back when used in voice_dataloc_create
1413: */
1414: int
1415: emuxki_recsrc_reserve(struct emuxki_voice *voice, emuxki_recsrc_t source)
1416: {
1417: if (source < 0 || source >= EMU_NUMRECSRCS) {
1418: #ifdef EMUXKI_DEBUG
1419: printf("Tried to reserve invalid source: %d\n", source);
1420: #endif
1421: return (EINVAL);
1422: }
1423: if (voice->sc->recsrc[source] == voice)
1424: return (0); /* XXX */
1425: if (voice->sc->recsrc[source] != NULL)
1426: return (EBUSY);
1427: voice->sc->recsrc[source] = voice;
1428: return (0);
1429: }
1430:
1431: /* When calling this function we assume the voice is stopped */
1432: void
1433: emuxki_voice_recsrc_release(struct emuxki_softc *sc, emuxki_recsrc_t source)
1434: {
1435: sc->recsrc[source] = NULL;
1436: }
1437:
1438: int
1439: emuxki_voice_dataloc_create(struct emuxki_voice *voice)
1440: {
1441: int error;
1442:
1443: if (voice->use & EMU_VOICE_USE_PLAY) {
1444: if ((error = emuxki_voice_channel_create(voice)))
1445: return (error);
1446: } else {
1447: if ((error =
1448: emuxki_recsrc_reserve(voice, voice->dataloc.source)))
1449: return (error);
1450: }
1451: return (0);
1452: }
1453:
1454: void
1455: emuxki_voice_dataloc_destroy(struct emuxki_voice *voice)
1456: {
1457: if (voice->use & EMU_VOICE_USE_PLAY) {
1458: if (voice->dataloc.chan[0] != NULL)
1459: emuxki_voice_channel_destroy(voice);
1460: } else {
1461: if (voice->dataloc.source != EMU_RECSRC_NOTSET) {
1462: emuxki_voice_recsrc_release(voice->sc,
1463: voice->dataloc.source);
1464: voice->dataloc.source = EMU_RECSRC_NOTSET;
1465: }
1466: }
1467: }
1468:
1469: struct emuxki_voice *
1470: emuxki_voice_new(struct emuxki_softc *sc, u_int8_t use)
1471: {
1472: struct emuxki_voice *voice;
1473: int s;
1474:
1475: s = splaudio();
1476: voice = sc->lvoice;
1477: sc->lvoice = NULL;
1478: splx(s);
1479:
1480: if (!voice) {
1481: if (!(voice = malloc(sizeof(*voice), M_DEVBUF, M_WAITOK)))
1482: return (NULL);
1483: } else if (voice->use != use)
1484: emuxki_voice_dataloc_destroy(voice);
1485: else
1486: goto skip_initialize;
1487:
1488: voice->sc = sc;
1489: voice->state = !EMU_VOICE_STATE_STARTED;
1490: voice->stereo = EMU_VOICE_STEREO_NOTSET;
1491: voice->b16 = 0;
1492: voice->sample_rate = 0;
1493: if (use & EMU_VOICE_USE_PLAY)
1494: voice->dataloc.chan[0] = voice->dataloc.chan[1] = NULL;
1495: else
1496: voice->dataloc.source = EMU_RECSRC_NOTSET;
1497: voice->buffer = NULL;
1498: voice->blksize = 0;
1499: voice->trigblk = 0;
1500: voice->blkmod = 0;
1501: voice->inth = NULL;
1502: voice->inthparam = NULL;
1503: voice->use = use;
1504:
1505: skip_initialize:
1506: s = splaudio();
1507: LIST_INSERT_HEAD((&sc->voices), voice, next);
1508: splx(s);
1509:
1510: return (voice);
1511: }
1512:
1513: void
1514: emuxki_voice_delete(struct emuxki_voice *voice)
1515: {
1516: struct emuxki_softc *sc = voice->sc;
1517: struct emuxki_voice *lvoice;
1518: int s;
1519:
1520: if (voice->state & EMU_VOICE_STATE_STARTED)
1521: emuxki_voice_halt(voice);
1522:
1523: s = splaudio();
1524: LIST_REMOVE(voice, next);
1525: lvoice = sc->lvoice;
1526: sc->lvoice = voice;
1527: splx(s);
1528:
1529: if (lvoice) {
1530: emuxki_voice_dataloc_destroy(lvoice);
1531: free(lvoice, M_DEVBUF);
1532: }
1533: }
1534:
1535: int
1536: emuxki_voice_set_stereo(struct emuxki_voice *voice, u_int8_t stereo)
1537: {
1538: int error;
1539: emuxki_recsrc_t source = 0; /* XXX: gcc */
1540: struct emuxki_chanparms_fxsend fxsend;
1541:
1542: if (! (voice->use & EMU_VOICE_USE_PLAY))
1543: source = voice->dataloc.source;
1544: emuxki_voice_dataloc_destroy(voice);
1545: if (! (voice->use & EMU_VOICE_USE_PLAY))
1546: voice->dataloc.source = source;
1547: voice->stereo = stereo;
1548: if ((error = emuxki_voice_dataloc_create(voice)))
1549: return (error);
1550: if (voice->use & EMU_VOICE_USE_PLAY) {
1551: fxsend.a.dest = 0x0;
1552: fxsend.b.dest = 0x1;
1553: fxsend.c.dest = 0x2;
1554: fxsend.d.dest = 0x3;
1555: /* for audigy */
1556: fxsend.e.dest = 0x4;
1557: fxsend.f.dest = 0x5;
1558: fxsend.g.dest = 0x6;
1559: fxsend.h.dest = 0x7;
1560: if (voice->stereo) {
1561: fxsend.a.level = fxsend.c.level = 0xc0;
1562: fxsend.b.level = fxsend.d.level = 0x00;
1563: fxsend.e.level = fxsend.g.level = 0xc0;
1564: fxsend.f.level = fxsend.h.level = 0x00;
1565: emuxki_channel_set_fxsend(voice->dataloc.chan[0],
1566: &fxsend);
1567: fxsend.a.level = fxsend.c.level = 0x00;
1568: fxsend.b.level = fxsend.d.level = 0xc0;
1569: fxsend.e.level = fxsend.g.level = 0x00;
1570: fxsend.f.level = fxsend.h.level = 0xc0;
1571: emuxki_channel_set_fxsend(voice->dataloc.chan[1],
1572: &fxsend);
1573: } /* No else : default is good for mono */
1574: }
1575: return (0);
1576: }
1577:
1578: int
1579: emuxki_voice_set_srate(struct emuxki_voice *voice, u_int32_t srate)
1580: {
1581: if (voice->use & EMU_VOICE_USE_PLAY) {
1582: if ((srate < 4000) || (srate > 48000))
1583: return (EINVAL);
1584: voice->sample_rate = srate;
1585: emuxki_channel_set_srate(voice->dataloc.chan[0], srate);
1586: if (voice->stereo)
1587: emuxki_channel_set_srate(voice->dataloc.chan[1],
1588: srate);
1589: } else {
1590: if ((srate < 8000) || (srate > 48000))
1591: return (EINVAL);
1592: voice->sample_rate = srate;
1593: if (emuxki_voice_adc_rate(voice) < 0) {
1594: voice->sample_rate = 0;
1595: return (EINVAL);
1596: }
1597: }
1598: return (0);
1599: }
1600:
1601: int
1602: emuxki_voice_set_audioparms(struct emuxki_voice *voice, u_int8_t stereo,
1603: u_int8_t b16, u_int32_t srate)
1604: {
1605: int error = 0;
1606:
1607: /*
1608: * Audio driver tried to set recording AND playing params even if
1609: * device opened in play or record only mode ==>
1610: * modified emuxki_set_params.
1611: * Stays here for now just in case ...
1612: */
1613: if (voice == NULL) {
1614: #ifdef EMUXKI_DEBUG
1615: printf("warning: tried to set unallocated voice params !!\n");
1616: #endif
1617: return (0);
1618: }
1619:
1620: if (voice->stereo == stereo && voice->b16 == b16 &&
1621: voice->sample_rate == srate)
1622: return (0);
1623:
1624: #ifdef EMUXKI_DEBUG
1625: printf("Setting %s voice params : %s, %u bits, %u hz\n",
1626: (voice->use & EMU_VOICE_USE_PLAY) ? "play" : "record",
1627: stereo ? "stereo" : "mono", (b16 + 1) * 8, srate);
1628: #endif
1629:
1630: if (voice->stereo != stereo) {
1631: if ((error = emuxki_voice_set_stereo(voice, stereo)))
1632: return (error);
1633: }
1634: voice->b16 = b16;
1635: if (voice->sample_rate != srate)
1636: error = emuxki_voice_set_srate(voice, srate);
1637: return error;
1638: }
1639:
1640: /* voice audio parms (see just before) must be set prior to this */
1641: int
1642: emuxki_voice_set_bufparms(struct emuxki_voice *voice, void *ptr,
1643: u_int32_t bufsize, u_int16_t blksize)
1644: {
1645: struct emuxki_mem *mem;
1646: struct emuxki_channel **chan;
1647: u_int32_t start, end;
1648: u_int8_t sample_size;
1649: int idx;
1650: int error = EFAULT;
1651:
1652: LIST_FOREACH(mem, &voice->sc->mem, next) {
1653: if (KERNADDR(mem->dmamem) != ptr)
1654: continue;
1655:
1656: voice->buffer = mem;
1657: sample_size = (voice->b16 + 1) * (voice->stereo + 1);
1658: voice->trigblk = 0; /* This shouldn't be needed */
1659: voice->blkmod = bufsize / blksize;
1660: if (bufsize % blksize) /* This should not happen */
1661: voice->blkmod++;
1662: error = 0;
1663:
1664: if (voice->use & EMU_VOICE_USE_PLAY) {
1665: voice->blksize = blksize / sample_size;
1666: chan = voice->dataloc.chan;
1667: start = (mem->ptbidx << 12) / sample_size;
1668: end = start + bufsize / sample_size;
1669: emuxki_channel_set_bufparms(chan[0],
1670: start, end);
1671: if (voice->stereo)
1672: emuxki_channel_set_bufparms(chan[1],
1673: start, end);
1674: voice->timerate = (u_int32_t) 48000 *
1675: voice->blksize / voice->sample_rate;
1676: if (voice->timerate < 5)
1677: error = EINVAL;
1678: } else {
1679: voice->blksize = blksize;
1680: for(idx = sizeof(emuxki_recbuf_sz) /
1681: sizeof(emuxki_recbuf_sz[0]); --idx >= 0;)
1682: if (emuxki_recbuf_sz[idx] == bufsize)
1683: break;
1684: if (idx < 0) {
1685: #ifdef EMUXKI_DEBUG
1686: printf("Invalid bufsize: %d\n", bufsize);
1687: #endif
1688: return (EINVAL);
1689: }
1690: emuxki_write(voice->sc, 0,
1691: emuxki_recsrc_szreg[voice->dataloc.source], idx);
1692: emuxki_write(voice->sc, 0,
1693: emuxki_recsrc_bufaddrreg[voice->dataloc.source],
1694: DMAADDR(mem->dmamem));
1695:
1696: /* Use timer to emulate DMA completion interrupt */
1697: voice->timerate = (u_int32_t) 48000 * blksize /
1698: (voice->sample_rate * sample_size);
1699: if (voice->timerate < 5) {
1700: #ifdef EMUXKI_DEBUG
1701: printf("Invalid timerate: %d, blksize %d\n",
1702: voice->timerate, blksize);
1703: #endif
1704: error = EINVAL;
1705: }
1706: }
1707:
1708: break;
1709: }
1710:
1711: return (error);
1712: }
1713:
1714: void
1715: emuxki_voice_commit_parms(struct emuxki_voice *voice)
1716: {
1717: if (voice->use & EMU_VOICE_USE_PLAY) {
1718: emuxki_channel_commit_parms(voice->dataloc.chan[0]);
1719: if (voice->stereo)
1720: emuxki_channel_commit_parms(voice->dataloc.chan[1]);
1721: }
1722: }
1723:
1724: u_int32_t
1725: emuxki_voice_curaddr(struct emuxki_voice *voice)
1726: {
1727: int idxreg = 0;
1728:
1729: /* XXX different semantics in these cases */
1730: if (voice->use & EMU_VOICE_USE_PLAY) {
1731: /* returns number of samples (an l/r pair counts 1) */
1732: return (emuxki_read(voice->sc,
1733: voice->dataloc.chan[0]->num,
1734: EMU_CHAN_CCCA_CURRADDR) -
1735: voice->dataloc.chan[0]->loop.start);
1736: } else {
1737: /* returns number of bytes */
1738: switch (voice->dataloc.source) {
1739: case EMU_RECSRC_MIC:
1740: idxreg = (voice->sc->sc_type & EMUXKI_AUDIGY) ?
1741: EMU_A_MICIDX : EMU_MICIDX;
1742: break;
1743: case EMU_RECSRC_ADC:
1744: idxreg = (voice->sc->sc_type & EMUXKI_AUDIGY) ?
1745: EMU_A_ADCIDX : EMU_ADCIDX;
1746: break;
1747: case EMU_RECSRC_FX:
1748: idxreg = EMU_FXIDX;
1749: break;
1750: default:
1751: #ifdef EMUXKI_DEBUG
1752: printf("emu: bad recording source!\n");
1753: #endif
1754: break;
1755: }
1756: return (emuxki_read(voice->sc, 0, EMU_RECIDX(idxreg))
1757: & EMU_RECIDX_MASK);
1758: }
1759: return (0);
1760: }
1761:
1762: void
1763: emuxki_resched_timer(struct emuxki_softc *sc)
1764: {
1765: struct emuxki_voice *voice;
1766: u_int16_t timerate = 1024;
1767: u_int8_t active = 0;
1768: int s;
1769:
1770: s = splaudio();
1771: LIST_FOREACH(voice, &sc->voices, next) {
1772: if ((voice->state & EMU_VOICE_STATE_STARTED) == 0)
1773: continue;
1774: active = 1;
1775: if (voice->timerate < timerate)
1776: timerate = voice->timerate;
1777: }
1778:
1779: if (timerate & ~EMU_TIMER_RATE_MASK)
1780: timerate = 0;
1781: bus_space_write_2(sc->sc_iot, sc->sc_ioh, EMU_TIMER, timerate);
1782: if (!active && (sc->timerstate & EMU_TIMER_STATE_ENABLED)) {
1783: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE,
1784: bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_INTE) &
1785: ~EMU_INTE_INTERTIMERENB);
1786: sc->timerstate &= ~EMU_TIMER_STATE_ENABLED;
1787: } else if (active && !(sc->timerstate & EMU_TIMER_STATE_ENABLED)) {
1788: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE,
1789: bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_INTE) |
1790: EMU_INTE_INTERTIMERENB);
1791: sc->timerstate |= EMU_TIMER_STATE_ENABLED;
1792: }
1793: splx(s);
1794: }
1795:
1796: int
1797: emuxki_voice_adc_rate(struct emuxki_voice *voice)
1798: {
1799: switch(voice->sample_rate) {
1800: case 48000:
1801: return EMU_ADCCR_SAMPLERATE_48;
1802: break;
1803: case 44100:
1804: return EMU_ADCCR_SAMPLERATE_44;
1805: break;
1806: case 32000:
1807: return EMU_ADCCR_SAMPLERATE_32;
1808: break;
1809: case 24000:
1810: return EMU_ADCCR_SAMPLERATE_24;
1811: break;
1812: case 22050:
1813: return EMU_ADCCR_SAMPLERATE_22;
1814: break;
1815: case 16000:
1816: return EMU_ADCCR_SAMPLERATE_16;
1817: break;
1818: case 12000:
1819: if(voice->sc->sc_type & EMUXKI_AUDIGY)
1820: return EMU_A_ADCCR_SAMPLERATE_12;
1821: else {
1822: #ifdef EMUXKI_DEBUG
1823: printf("recording sample_rate not supported : %u\n", voice->sample_rate);
1824: #endif
1825: return (-1);
1826: }
1827: break;
1828: case 11000:
1829: if(voice->sc->sc_type & EMUXKI_AUDIGY)
1830: return EMU_A_ADCCR_SAMPLERATE_11;
1831: else
1832: return EMU_ADCCR_SAMPLERATE_11;
1833: break;
1834: case 8000:
1835: if(voice->sc->sc_type & EMUXKI_AUDIGY)
1836: return EMU_A_ADCCR_SAMPLERATE_8;
1837: else
1838: return EMU_ADCCR_SAMPLERATE_8;
1839: break;
1840: default:
1841: #ifdef EMUXKI_DEBUG
1842: printf("recording sample_rate not supported : %u\n", voice->sample_rate);
1843: #endif
1844: return (-1);
1845: }
1846: return (-1); /* shouldn't get here */
1847: }
1848:
1849: void
1850: emuxki_voice_start(struct emuxki_voice *voice,
1851: void (*inth) (void *), void *inthparam)
1852: {
1853: u_int32_t val;
1854:
1855: voice->inth = inth;
1856: voice->inthparam = inthparam;
1857: if (voice->use & EMU_VOICE_USE_PLAY) {
1858: voice->trigblk = 1;
1859: emuxki_channel_start(voice->dataloc.chan[0]);
1860: if (voice->stereo)
1861: emuxki_channel_start(voice->dataloc.chan[1]);
1862: } else {
1863: voice->trigblk = 1;
1864: switch (voice->dataloc.source) {
1865: case EMU_RECSRC_ADC:
1866: /* XXX need to program DSP to output L+R
1867: * XXX in monaural case? */
1868: if (voice->sc->sc_type & EMUXKI_AUDIGY) {
1869: val = EMU_A_ADCCR_LCHANENABLE;
1870: if (voice->stereo)
1871: val |= EMU_A_ADCCR_RCHANENABLE;
1872: } else {
1873: val = EMU_ADCCR_LCHANENABLE;
1874: if (voice->stereo)
1875: val |= EMU_ADCCR_RCHANENABLE;
1876: }
1877: val |= emuxki_voice_adc_rate(voice);
1878: emuxki_write(voice->sc, 0, EMU_ADCCR, 0);
1879: emuxki_write(voice->sc, 0, EMU_ADCCR, val);
1880: break;
1881: case EMU_RECSRC_MIC:
1882: case EMU_RECSRC_FX:
1883: printf("unimplemented\n");
1884: break;
1885: case EMU_RECSRC_NOTSET:
1886: default:
1887: break;
1888: }
1889: #if 0
1890: /* DMA completion interrupt is useless; use timer */
1891: int s;
1892: s = splaudio();
1893: val = emu_rd(sc, INTE, 4);
1894: val |= emuxki_recsrc_intrmasks[voice->dataloc.source];
1895: emu_wr(sc, INTE, val, 4);
1896: splx(s);
1897: #endif
1898: }
1899: voice->state |= EMU_VOICE_STATE_STARTED;
1900: emuxki_resched_timer(voice->sc);
1901: }
1902:
1903: void
1904: emuxki_voice_halt(struct emuxki_voice *voice)
1905: {
1906: if (voice->use & EMU_VOICE_USE_PLAY) {
1907: emuxki_channel_stop(voice->dataloc.chan[0]);
1908: if (voice->stereo)
1909: emuxki_channel_stop(voice->dataloc.chan[1]);
1910: } else {
1911: switch (voice->dataloc.source) {
1912: case EMU_RECSRC_ADC:
1913: emuxki_write(voice->sc, 0, EMU_ADCCR, 0);
1914: break;
1915: case EMU_RECSRC_FX:
1916: case EMU_RECSRC_MIC:
1917: printf("unimplemented\n");
1918: break;
1919: case EMU_RECSRC_NOTSET:
1920: printf("Bad dataloc.source\n");
1921: }
1922: /* This should reset buffer pointer */
1923: emuxki_write(voice->sc, 0,
1924: emuxki_recsrc_szreg[voice->dataloc.source],
1925: EMU_RECBS_BUFSIZE_NONE);
1926: #if 0
1927: int s;
1928: s = splaudio();
1929: val = emu_rd(sc, INTE, 4);
1930: val &= ~emuxki_recsrc_intrmasks[voice->dataloc.source];
1931: emu_wr(sc, INTE, val, 4);
1932: splx(s);
1933: #endif
1934: }
1935: voice->state &= ~EMU_VOICE_STATE_STARTED;
1936: emuxki_resched_timer(voice->sc);
1937: }
1938:
1939: /*
1940: * The interrupt handler
1941: */
1942: int
1943: emuxki_intr(void *arg)
1944: {
1945: struct emuxki_softc *sc = arg;
1946: u_int32_t ipr, curblk, us = 0;
1947: struct emuxki_voice *voice;
1948:
1949: while ((ipr = bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_IPR))) {
1950: if (ipr & EMU_IPR_INTERVALTIMER) {
1951: LIST_FOREACH(voice, &sc->voices, next) {
1952: if ((voice->state &
1953: EMU_VOICE_STATE_STARTED) == 0)
1954: continue;
1955:
1956: curblk = emuxki_voice_curaddr(voice) /
1957: voice->blksize;
1958: #if 0
1959: if (curblk == voice->trigblk) {
1960: voice->inth(voice->inthparam);
1961: voice->trigblk++;
1962: voice->trigblk %= voice->blkmod;
1963: }
1964: #else
1965: while ((curblk >= voice->trigblk &&
1966: curblk < (voice->trigblk + voice->blkmod / 2)) ||
1967: ((int)voice->trigblk - (int)curblk) >
1968: (voice->blkmod / 2 + 1)) {
1969: voice->inth(voice->inthparam);
1970: voice->trigblk++;
1971: voice->trigblk %= voice->blkmod;
1972: }
1973: #endif
1974: }
1975: us = 1;
1976: }
1977:
1978: /* Got interrupt */
1979: bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_IPR, ipr);
1980: }
1981:
1982: return (us);
1983: }
1984:
1985:
1986: /*
1987: * Audio Architecture callbacks
1988: */
1989:
1990: int
1991: emuxki_open(void *addr, int flags)
1992: {
1993: struct emuxki_softc *sc = addr;
1994:
1995: #ifdef EMUXKI_DEBUG
1996: printf("%s: emuxki_open called\n", sc->sc_dev.dv_xname);
1997: #endif
1998:
1999: /*
2000: * Multiple voice support would be added as soon as I find a way to
2001: * trick the audio arch into supporting multiple voices.
2002: * Or I might integrate a modified audio arch supporting
2003: * multiple voices.
2004: */
2005:
2006: /*
2007: * I did this because i have problems identifying the selected
2008: * recording source(s) which is necessary when setting recording
2009: * params. This will be addressed very soon.
2010: */
2011: if (flags & AUOPEN_READ) {
2012: sc->rvoice = emuxki_voice_new(sc, 0 /* EMU_VOICE_USE_RECORD */);
2013: if (sc->rvoice == NULL)
2014: return (EBUSY);
2015:
2016: /* XXX Hardcode RECSRC_ADC for now */
2017: sc->rvoice->dataloc.source = EMU_RECSRC_ADC;
2018: }
2019:
2020: if (flags & AUOPEN_WRITE) {
2021: sc->pvoice = emuxki_voice_new(sc, EMU_VOICE_USE_PLAY);
2022: if (sc->pvoice == NULL) {
2023: if (flags & AUOPEN_READ)
2024: emuxki_voice_delete(sc->rvoice);
2025: return (EBUSY);
2026: }
2027: }
2028:
2029: return (0);
2030: }
2031:
2032: void
2033: emuxki_close(void *addr)
2034: {
2035: struct emuxki_softc *sc = addr;
2036:
2037: #ifdef EMUXKI_DEBUG
2038: printf("%s: emu10K1_close called\n", sc->sc_dev.dv_xname);
2039: #endif
2040:
2041: /* No multiple voice support for now */
2042: if (sc->rvoice != NULL)
2043: emuxki_voice_delete(sc->rvoice);
2044: sc->rvoice = NULL;
2045: if (sc->pvoice != NULL)
2046: emuxki_voice_delete(sc->pvoice);
2047: sc->pvoice = NULL;
2048: }
2049:
2050: int
2051: emuxki_query_encoding(void *addr, struct audio_encoding *fp)
2052: {
2053: #ifdef EMUXKI_DEBUG
2054: struct emuxki_softc *sc = addr;
2055:
2056: printf("%s: emuxki_query_encoding called\n", sc->sc_dev.dv_xname);
2057: #endif
2058:
2059: switch (fp->index) {
2060: case 0:
2061: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
2062: fp->encoding = AUDIO_ENCODING_ULINEAR;
2063: fp->precision = 8;
2064: fp->flags = 0;
2065: break;
2066: case 1:
2067: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
2068: fp->encoding = AUDIO_ENCODING_ULAW;
2069: fp->precision = 8;
2070: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
2071: break;
2072: case 2:
2073: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
2074: fp->encoding = AUDIO_ENCODING_ALAW;
2075: fp->precision = 8;
2076: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
2077: break;
2078: case 3:
2079: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
2080: fp->encoding = AUDIO_ENCODING_SLINEAR;
2081: fp->precision = 8;
2082: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
2083: break;
2084: case 4:
2085: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
2086: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
2087: fp->precision = 16;
2088: fp->flags = 0;
2089: break;
2090: case 5:
2091: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
2092: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
2093: fp->precision = 16;
2094: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
2095: break;
2096: case 6:
2097: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
2098: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
2099: fp->precision = 16;
2100: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
2101: break;
2102: case 7:
2103: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
2104: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
2105: fp->precision = 16;
2106: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
2107: break;
2108: default:
2109: return (EINVAL);
2110: }
2111: return (0);
2112: }
2113:
2114: int
2115: emuxki_set_vparms(struct emuxki_voice *voice, struct audio_params *p)
2116: {
2117: u_int8_t b16, mode;
2118:
2119: mode = (voice->use & EMU_VOICE_USE_PLAY) ?
2120: AUMODE_PLAY : AUMODE_RECORD;
2121: p->factor = 1;
2122: p->sw_code = NULL;
2123: if (p->channels != 1 && p->channels != 2)
2124: return (EINVAL);/* Will change when streams come in use */
2125:
2126: /*
2127: * Always use slinear_le for recording, as how to set otherwise
2128: * isn't known.
2129: */
2130: if (mode == AUMODE_PLAY)
2131: b16 = (p->precision == 16);
2132: else {
2133: b16 = 1;
2134: if (p->precision == 8)
2135: p->factor *= 2;
2136: }
2137:
2138: switch (p->encoding) {
2139: case AUDIO_ENCODING_ULAW:
2140: if (mode == AUMODE_PLAY) {
2141: p->factor = 2;
2142: p->sw_code = mulaw_to_slinear16_le;
2143: b16 = 1;
2144: } else
2145: p->sw_code = slinear16_to_mulaw_le;
2146: break;
2147:
2148: case AUDIO_ENCODING_ALAW:
2149: if (mode == AUMODE_PLAY) {
2150: p->factor = 2;
2151: p->sw_code = alaw_to_slinear16_le;
2152: b16 = 1;
2153: } else
2154: p->sw_code = slinear16_to_alaw_le;
2155: break;
2156:
2157: case AUDIO_ENCODING_SLINEAR_LE:
2158: if (p->precision == 8) {
2159: if (mode == AUMODE_PLAY)
2160: p->sw_code = change_sign8;
2161: else
2162: p->sw_code = linear16_to_linear8_le;
2163: }
2164: break;
2165:
2166: case AUDIO_ENCODING_ULINEAR_LE:
2167: if (p->precision == 16)
2168: p->sw_code = change_sign16_le;
2169: else if (mode == AUMODE_RECORD)
2170: p->sw_code = slinear16_to_ulinear8_le;
2171: break;
2172:
2173: case AUDIO_ENCODING_SLINEAR_BE:
2174: if (p->precision == 16)
2175: p->sw_code = swap_bytes;
2176: else {
2177: if (mode == AUMODE_PLAY)
2178: p->sw_code = change_sign8;
2179: else
2180: p->sw_code = linear16_to_linear8_le;
2181: }
2182: break;
2183:
2184: case AUDIO_ENCODING_ULINEAR_BE:
2185: if (p->precision == 16) {
2186: if (mode == AUMODE_PLAY)
2187: p->sw_code = swap_bytes_change_sign16_le;
2188: else
2189: p->sw_code = change_sign16_swap_bytes_le;
2190: } else if (mode == AUMODE_RECORD)
2191: p->sw_code = slinear16_to_ulinear8_le;
2192: break;
2193:
2194: default:
2195: return (EINVAL);
2196: }
2197:
2198: return (emuxki_voice_set_audioparms(voice, p->channels == 2,
2199: b16, p->sample_rate));
2200: }
2201:
2202: int
2203: emuxki_set_params(void *addr, int setmode, int usemode,
2204: struct audio_params *play, struct audio_params *rec)
2205: {
2206: struct emuxki_softc *sc = addr;
2207: int mode, error;
2208: struct audio_params *p;
2209:
2210: for (mode = AUMODE_RECORD; mode != -1;
2211: mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
2212: if ((usemode & setmode & mode) == 0)
2213: continue;
2214:
2215: p = (mode == AUMODE_PLAY) ? play : rec;
2216:
2217: /* No multiple voice support for now */
2218: if ((error = emuxki_set_vparms((mode == AUMODE_PLAY) ?
2219: sc->pvoice : sc->rvoice, p)))
2220: return (error);
2221: }
2222:
2223: return (0);
2224: }
2225:
2226: int
2227: emuxki_halt_output(void *addr)
2228: {
2229: struct emuxki_softc *sc = addr;
2230:
2231: /* No multiple voice support for now */
2232: if (sc->pvoice == NULL)
2233: return (ENXIO);
2234:
2235: emuxki_voice_halt(sc->pvoice);
2236: return (0);
2237: }
2238:
2239: int
2240: emuxki_halt_input(void *addr)
2241: {
2242: struct emuxki_softc *sc = addr;
2243:
2244: #ifdef EMUXKI_DEBUG
2245: printf("%s: emuxki_halt_input called\n", sc->sc_dev.dv_xname);
2246: #endif
2247:
2248: /* No multiple voice support for now */
2249: if (sc->rvoice == NULL)
2250: return (ENXIO);
2251: emuxki_voice_halt(sc->rvoice);
2252: return (0);
2253: }
2254:
2255: int
2256: emuxki_getdev(void *v, struct audio_device *adp)
2257: {
2258: struct emuxki_softc *sc = v;
2259: *adp = sc->sc_audv;
2260: return 0;
2261: }
2262:
2263: int
2264: emuxki_set_port(void *addr, mixer_ctrl_t *mctl)
2265: {
2266: struct emuxki_softc *sc = addr;
2267:
2268: return sc->codecif->vtbl->mixer_set_port(sc->codecif, mctl);
2269: }
2270:
2271: int
2272: emuxki_get_port(void *addr, mixer_ctrl_t *mctl)
2273: {
2274: struct emuxki_softc *sc = addr;
2275:
2276: return sc->codecif->vtbl->mixer_get_port(sc->codecif, mctl);
2277: }
2278:
2279: int
2280: emuxki_query_devinfo(void *addr, mixer_devinfo_t *minfo)
2281: {
2282: struct emuxki_softc *sc = addr;
2283:
2284: return sc->codecif->vtbl->query_devinfo(sc->codecif, minfo);
2285: }
2286:
2287: void *
2288: emuxki_allocm(void *addr, int direction, size_t size, int type, int flags)
2289: {
2290: struct emuxki_softc *sc = addr;
2291:
2292: if (direction == AUMODE_PLAY)
2293: return emuxki_pmem_alloc(sc, size, type, flags);
2294: else
2295: return emuxki_rmem_alloc(sc, size, type, flags);
2296: }
2297:
2298: void
2299: emuxki_freem(void *addr, void *ptr, int type)
2300: {
2301: struct emuxki_softc *sc = addr;
2302: int i, s;
2303: struct emuxki_mem *mem;
2304: size_t numblocks;
2305: u_int32_t *ptb, silentpage;
2306:
2307: ptb = KERNADDR(sc->ptb);
2308: silentpage = DMAADDR(sc->silentpage) << 1;
2309: LIST_FOREACH(mem, &sc->mem, next) {
2310: if (KERNADDR(mem->dmamem) != ptr)
2311: continue;
2312:
2313: s = splaudio();
2314: if (mem->ptbidx != EMU_RMEM) {
2315: numblocks = DMASIZE(mem->dmamem) / EMU_PTESIZE;
2316: if (DMASIZE(mem->dmamem) % EMU_PTESIZE)
2317: numblocks++;
2318: for (i = 0; i < numblocks; i++)
2319: ptb[mem->ptbidx + i] =
2320: htole32(silentpage | (mem->ptbidx + i));
2321: }
2322: LIST_REMOVE(mem, next);
2323: splx(s);
2324:
2325: emuxki_mem_delete(mem, type);
2326: break;
2327: }
2328: }
2329:
2330: /* blocksize should be a divisor of allowable buffersize */
2331: /* XXX probably this could be done better */
2332: int
2333: emuxki_round_blocksize(void *addr, int blksize)
2334: {
2335: int bufsize = 65536;
2336:
2337: while (bufsize > blksize)
2338: bufsize /= 2;
2339:
2340: return bufsize;
2341: }
2342:
2343: size_t
2344: emuxki_round_buffersize(void *addr, int direction, size_t bsize)
2345: {
2346:
2347: if (direction == AUMODE_PLAY) {
2348: if (bsize < EMU_PTESIZE)
2349: bsize = EMU_PTESIZE;
2350: else if (bsize > (EMU_PTESIZE * EMU_MAXPTE))
2351: bsize = EMU_PTESIZE * EMU_MAXPTE;
2352: /* Would be better if set to max available */
2353: else if (bsize % EMU_PTESIZE)
2354: bsize = bsize -
2355: (bsize % EMU_PTESIZE) +
2356: EMU_PTESIZE;
2357: } else {
2358: int idx;
2359:
2360: /* find nearest lower recbuf size */
2361: for(idx = sizeof(emuxki_recbuf_sz) /
2362: sizeof(emuxki_recbuf_sz[0]); --idx >= 0; ) {
2363: if (bsize >= emuxki_recbuf_sz[idx]) {
2364: bsize = emuxki_recbuf_sz[idx];
2365: break;
2366: }
2367: }
2368:
2369: if (bsize == 0)
2370: bsize = 384;
2371: }
2372:
2373: return (bsize);
2374: }
2375:
2376: paddr_t
2377: emuxki_mappage(void *addr, void *ptr, off_t off, int prot)
2378: {
2379: struct emuxki_softc *sc = addr;
2380: struct emuxki_mem *mem;
2381:
2382: LIST_FOREACH(mem, &sc->mem, next) {
2383: if (KERNADDR(mem->dmamem) == ptr) {
2384: struct dmamem *dm = mem->dmamem;
2385:
2386: return bus_dmamem_mmap(dm->dmat, dm->segs, dm->nsegs,
2387: off, prot, BUS_DMA_WAITOK);
2388: }
2389: }
2390:
2391: return (-1);
2392: }
2393:
2394: int
2395: emuxki_get_props(void *addr)
2396: {
2397: return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT |
2398: AUDIO_PROP_FULLDUPLEX);
2399: }
2400:
2401: int
2402: emuxki_trigger_output(void *addr, void *start, void *end, int blksize,
2403: void (*inth) (void *), void *inthparam,
2404: struct audio_params *params)
2405: {
2406: struct emuxki_softc *sc = addr;
2407: /* No multiple voice support for now */
2408: struct emuxki_voice *voice = sc->pvoice;
2409: int error;
2410:
2411: if (voice == NULL)
2412: return (ENXIO);
2413: if ((error = emuxki_set_vparms(voice, params)))
2414: return (error);
2415: if ((error = emuxki_voice_set_bufparms(voice, start,
2416: (caddr_t)end - (caddr_t)start, blksize)))
2417: return (error);
2418: emuxki_voice_commit_parms(voice);
2419: emuxki_voice_start(voice, inth, inthparam);
2420:
2421: return (0);
2422: }
2423:
2424: int
2425: emuxki_trigger_input(void *addr, void *start, void *end, int blksize,
2426: void (*inth) (void *), void *inthparam,
2427: struct audio_params *params)
2428: {
2429: struct emuxki_softc *sc = addr;
2430: /* No multiple voice support for now */
2431: struct emuxki_voice *voice = sc->rvoice;
2432: int error;
2433:
2434: if (voice == NULL)
2435: return (ENXIO);
2436: if ((error = emuxki_set_vparms(voice, params)))
2437: return (error);
2438: if ((error = emuxki_voice_set_bufparms(voice, start,
2439: (caddr_t)end - (caddr_t)start,
2440: blksize)))
2441: return (error);
2442: emuxki_voice_start(voice, inth, inthparam);
2443:
2444: return (0);
2445: }
2446:
2447:
2448: /*
2449: * AC97 callbacks
2450: */
2451:
2452: int
2453: emuxki_ac97_attach(void *arg, struct ac97_codec_if *codecif)
2454: {
2455: struct emuxki_softc *sc = arg;
2456:
2457: sc->codecif = codecif;
2458: return (0);
2459: }
2460:
2461: int
2462: emuxki_ac97_read(void *arg, u_int8_t reg, u_int16_t *val)
2463: {
2464: struct emuxki_softc *sc = arg;
2465: int s;
2466:
2467: s = splaudio();
2468: bus_space_write_1(sc->sc_iot, sc->sc_ioh, EMU_AC97ADDR, reg);
2469: *val = bus_space_read_2(sc->sc_iot, sc->sc_ioh, EMU_AC97DATA);
2470: splx(s);
2471:
2472: return (0);
2473: }
2474:
2475: int
2476: emuxki_ac97_write(void *arg, u_int8_t reg, u_int16_t val)
2477: {
2478: struct emuxki_softc *sc = arg;
2479: int s;
2480:
2481: s = splaudio();
2482: bus_space_write_1(sc->sc_iot, sc->sc_ioh, EMU_AC97ADDR, reg);
2483: bus_space_write_2(sc->sc_iot, sc->sc_ioh, EMU_AC97DATA, val);
2484: splx(s);
2485:
2486: return (0);
2487: }
2488:
2489: void
2490: emuxki_ac97_reset(void *arg)
2491: {
2492: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to emuxki.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci