/usr/src/sys/dev/pci/emuxki.c

Bug Summary

File:	dev/pci/emuxki.c
Warning:	line 1931, column 3 3rd function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name emuxki.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -D CONFIG_DRM_AMD_DC_DCN3_0 -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /usr/obj/sys/arch/amd64/compile/GENERIC.MP/scan-build/2022-01-12-131800-47421-1 -x c /usr/src/sys/dev/pci/emuxki.c
1/*	$OpenBSD: emuxki.c,v 1.55 2022/01/09 05:42:45 jsg Exp $	*/
2/*	$NetBSD: emuxki.c,v 1.1 2001/10/17 18:39:41 jdolecek Exp $	*/

4/*-
* Copyright (c) 2001 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Yannick Montulet.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

33/*
* Driver for Creative Labs SBLive! series and probably PCI512.
* 
* Known bugs:
* - inversed stereo at ac97 codec level
*   (XXX jdolecek - don't see the problem? maybe because auvia(4) has
*    it swapped too?)
* - bass disappear when you plug rear jack-in on Cambridge FPS2000 speakers
*   (and presumably all speakers that support front and rear jack-in)
*
* TODO:
* - Digital Outputs
* - (midi/mpu),joystick support
* - Multiple voices play (problem with /dev/audio architecture)
* - Multiple sources recording (Pb with audio(4))
* - Independent modification of each channel's parameters (via mixer ?)
* - DSP FX patches (to make fx like chipmunk)
*/

52#include <sys/param.h>
53#include <sys/device.h>
54#include <sys/errno.h>
55#include <sys/fcntl.h>
56#include <sys/malloc.h>
57#include <sys/systm.h>
58#include <sys/audioio.h>

60#include <dev/pci/pcireg.h>
61#include <dev/pci/pcivar.h>
62#include <dev/pci/pcidevs.h>

64#include <dev/audio_if.h>
65#include <dev/ic/ac97.h>

67#include <dev/pci/emuxkireg.h>
68#include <dev/pci/emuxkivar.h>

70/* autoconf goo */
71int  emuxki_match(struct device *, void *, void *);
72void emuxki_attach(struct device *, struct device *, void *);
73int  emuxki_detach(struct device *, int);
74int  emuxki_activate(struct device *, int);
75int  emuxki_scinit(struct emuxki_softc *sc, int);
76void emuxki_pci_shutdown(struct emuxki_softc *sc);

78/* dma mem mgmt */
79struct dmamem *emuxki_dmamem_alloc(bus_dma_tag_t, size_t, bus_size_t,
		 int, int, int);
81void	emuxki_dmamem_free(struct dmamem *, int);
82void	emuxki_dmamem_delete(struct dmamem *mem, int type);

84struct emuxki_mem *emuxki_mem_new(struct emuxki_softc *sc, int ptbidx,
size_t size, int type, int flags);
86void emuxki_mem_delete(struct emuxki_mem *mem, int type);

88/* Emu10k1 init & shutdown */
89int  emuxki_init(struct emuxki_softc *, int);
90void emuxki_shutdown(struct emuxki_softc *);

92/* Emu10k1 mem mgmt */
93void   *emuxki_pmem_alloc(struct emuxki_softc *, size_t,int,int);
94void   *emuxki_rmem_alloc(struct emuxki_softc *, size_t,int,int);

96/*
* Emu10k1 channels funcs : There is no direct access to channels, everything
* is done through voices I will at least provide channel based fx params
* modification, later...
*/

102/* Emu10k1 voice mgmt */
103struct emuxki_voice *emuxki_voice_new(struct emuxki_softc *, u_int8_t);
104void   emuxki_voice_delete(struct emuxki_voice *);
105int    emuxki_voice_set_audioparms(struct emuxki_voice *, u_int8_t, u_int8_t, u_int32_t);
106/* emuxki_voice_set_fxparms will come later, it'll need channel distinction */
107int emuxki_voice_set_bufparms(struct emuxki_voice *, void *, u_int32_t, u_int16_t);
108int emuxki_voice_set_stereo(struct emuxki_voice *voice, u_int8_t stereo);
109int emuxki_voice_dataloc_create(struct emuxki_voice *voice);
110void emuxki_voice_dataloc_destroy(struct emuxki_voice *voice);
111void emuxki_voice_commit_parms(struct emuxki_voice *);
112void emuxki_voice_recsrc_release(struct emuxki_softc *sc, emuxki_recsrc_t source);
113int emuxki_recsrc_reserve(struct emuxki_voice *voice, emuxki_recsrc_t source);
114int emuxki_voice_adc_rate(struct emuxki_voice *);
115u_int32_t emuxki_voice_curaddr(struct emuxki_voice *);
116int emuxki_set_vparms(struct emuxki_voice *voice, struct audio_params *p);
117int emuxki_voice_set_srate(struct emuxki_voice *voice, u_int32_t srate);
118void emuxki_voice_start(struct emuxki_voice *, void (*) (void *), void *);
119void emuxki_voice_halt(struct emuxki_voice *);
120int emuxki_voice_channel_create(struct emuxki_voice *voice);
121void emuxki_voice_channel_destroy(struct emuxki_voice *voice);

123struct emuxki_channel *emuxki_channel_new(struct emuxki_voice *voice, u_int8_t num);
124void emuxki_channel_delete(struct emuxki_channel *chan);
125void emuxki_channel_start(struct emuxki_channel *chan);
126void emuxki_channel_stop(struct emuxki_channel *chan);
127void emuxki_channel_commit_fx(struct emuxki_channel *chan);
128void emuxki_channel_commit_parms(struct emuxki_channel *chan);
129void emuxki_channel_set_bufparms(struct emuxki_channel *chan, u_int32_t start, u_int32_t end);
130void emuxki_channel_set_srate(struct emuxki_channel *chan, u_int32_t srate);
131void emuxki_channel_set_fxsend(struct emuxki_channel *chan,
struct emuxki_chanparms_fxsend *fxsend);
133void emuxki_chanparms_set_defaults(struct emuxki_channel *chan);

135void emuxki_resched_timer(struct emuxki_softc *sc);

137/*
* Emu10k1 stream mgmt : not done yet
*/
140#if 0
141struct emuxki_stream *emuxki_stream_new(struct emu10k1 *);
142void   emuxki_stream_delete(struct emuxki_stream *);
143int    emuxki_stream_set_audio_params(struct emuxki_stream *, u_int8_t,
			    u_int8_t, u_int8_t, u_int16_t);
145void   emuxki_stream_start(struct emuxki_stream *);
146void   emuxki_stream_halt(struct emuxki_stream *);
147#endif

149/* fx interface */
150void emuxki_initfx(struct emuxki_softc *sc);
151void emuxki_dsp_addop(struct emuxki_softc *sc, u_int16_t *pc, u_int8_t op,
u_int16_t r, u_int16_t a, u_int16_t x, u_int16_t y);
153void emuxki_write_micro(struct emuxki_softc *sc, u_int32_t pc, u_int32_t data);

155/* audio interface callbacks */

157int	emuxki_open(void *, int);
158void	emuxki_close(void *);

160int	emuxki_set_params(void *, int, int,
		      struct audio_params *,
		      struct audio_params *);

164int	emuxki_round_blocksize(void *, int);
165size_t	emuxki_round_buffersize(void *, int, size_t);

167int	emuxki_trigger_output(void *, void *, void *, int, void (*)(void *),
   void *, struct audio_params *);
169int	emuxki_trigger_input(void *, void *, void *, int, void (*) (void *),
   void *, struct audio_params *);
171int	emuxki_halt_output(void *);
172int	emuxki_halt_input(void *);

174int	emuxki_set_port(void *, mixer_ctrl_t *);
175int	emuxki_get_port(void *, mixer_ctrl_t *);
176int	emuxki_query_devinfo(void *, mixer_devinfo_t *);

178void   *emuxki_allocm(void *, int, size_t, int, int);
179void	emuxki_freem(void *, void *, int);

181int	emuxki_get_props(void *);

183/* Interrupt handler */
184int  emuxki_intr(void *);

186/* Emu10k1 AC97 interface callbacks */
187int  emuxki_ac97_init(struct emuxki_softc *sc);
188int  emuxki_ac97_attach(void *, struct ac97_codec_if *);
189int  emuxki_ac97_read(void *, u_int8_t, u_int16_t *);
190int  emuxki_ac97_write(void *, u_int8_t, u_int16_t);
191void emuxki_ac97_reset(void *);

193const struct pci_matchid emuxki_devices[] = {
{ PCI_VENDOR_CREATIVELABS0x1102, PCI_PRODUCT_CREATIVELABS_SBLIVE0x0002 },
{ PCI_VENDOR_CREATIVELABS0x1102, PCI_PRODUCT_CREATIVELABS_AUDIGY0x0004 },
{ PCI_VENDOR_CREATIVELABS0x1102, PCI_PRODUCT_CREATIVELABS_AUDIGY20x0008 },
197};

199/*
* Autoconfig goo.
*/
202struct cfdriver emu_cd = {
NULL((void *)0), "emu", DV_DULL
204};

206struct cfattach emu_ca = {
      sizeof(struct emuxki_softc),
      emuxki_match,
      emuxki_attach,
emuxki_detach,
emuxki_activate
212};

214struct audio_hw_if emuxki_hw_if = {
emuxki_open,
emuxki_close,
emuxki_set_params,
emuxki_round_blocksize,
NULL((void *)0),			/* commit settings */
NULL((void *)0),			/* init_output */
NULL((void *)0),			/* init_input */
NULL((void *)0),			/* start_output */
NULL((void *)0),			/* start_input */
emuxki_halt_output,
emuxki_halt_input,
NULL((void *)0),			/* speaker_ctl */
NULL((void *)0),			/* setfd */
emuxki_set_port,
emuxki_get_port,
emuxki_query_devinfo,
emuxki_allocm,
emuxki_freem,
emuxki_round_buffersize,
emuxki_get_props,
emuxki_trigger_output,
emuxki_trigger_input
237};

239#if 0
240static const int emuxki_recsrc_intrmasks[EMU_NUMRECSRCS3] =
  { EMU_INTE_MICBUFENABLE0x00000080, EMU_INTE_ADCBUFENABLE0x00000040, EMU_INTE_EFXBUFENABLE0x00000020 };
242#endif
243static const u_int32_t emuxki_recsrc_bufaddrreg[EMU_NUMRECSRCS3] =
  { EMU_MICBA0x45, EMU_ADCBA0x46, EMU_FXBA0x47 };
245static const u_int32_t emuxki_recsrc_szreg[EMU_NUMRECSRCS3] =
  { EMU_MICBS0x49, EMU_ADCBS0x4a, EMU_FXBS0x4b };
247static const int emuxki_recbuf_sz[] = {
0, 384, 448, 512, 640, 768, 896, 1024, 1280, 1536, 1792,
2048, 2560, 3072, 3584, 4096, 5120, 6144, 7168, 8192, 10240,
12288, 14366, 16384, 20480, 24576, 28672, 32768, 40960, 49152,
57344, 65536
252};

254/*
* DMA memory mgmt
*/

258void
259emuxki_dmamem_delete(struct dmamem *mem, int type)
260{
free(mem->segs, type, 0);
free(mem, type, 0);
263}

265struct dmamem *
266emuxki_dmamem_alloc(bus_dma_tag_t dmat, size_t size, bus_size_t align,
    int nsegs, int type, int flags)
268{
struct dmamem	*mem;
int		bus_dma_flags;

/* Allocate memory for structure */
if ((mem = malloc(sizeof(*mem), type, flags)) == NULL((void *)0))
return (NULL((void *)0));
mem->dmat = dmat;
mem->size = size;
mem->align = align;
mem->nsegs = nsegs;
mem->bound = 0;

mem->segs = mallocarray(mem->nsegs, sizeof(*(mem->segs)), type, flags);
if (mem->segs == NULL((void *)0)) {
free(mem, type, 0);
return (NULL((void *)0));
}

bus_dma_flags = (flags & M_NOWAIT0x0002) ? BUS_DMA_NOWAIT0x0001 : BUS_DMA_WAITOK0x0000;
if (bus_dmamem_alloc(dmat, mem->size, mem->align, mem->bound,(*(dmat)->_dmamem_alloc)((dmat), (mem->size), (mem->
align), (mem->bound), (mem->segs), (mem->nsegs), (&
(mem->rsegs)), (bus_dma_flags))
	     mem->segs, mem->nsegs, &(mem->rsegs),(*(dmat)->_dmamem_alloc)((dmat), (mem->size), (mem->
align), (mem->bound), (mem->segs), (mem->nsegs), (&
(mem->rsegs)), (bus_dma_flags))
	     bus_dma_flags)(*(dmat)->_dmamem_alloc)((dmat), (mem->size), (mem->
align), (mem->bound), (mem->segs), (mem->nsegs), (&
(mem->rsegs)), (bus_dma_flags))) {
emuxki_dmamem_delete(mem, type);
return (NULL((void *)0));
}

if (bus_dmamem_map(dmat, mem->segs, mem->nsegs, mem->size,(*(dmat)->_dmamem_map)((dmat), (mem->segs), (mem->nsegs
), (mem->size), (&(mem->kaddr)), (bus_dma_flags | 0x0004
))
	   &(mem->kaddr), bus_dma_flags | BUS_DMA_COHERENT)(*(dmat)->_dmamem_map)((dmat), (mem->segs), (mem->nsegs
), (mem->size), (&(mem->kaddr)), (bus_dma_flags | 0x0004
))) {
bus_dmamem_free(dmat, mem->segs, mem->nsegs)(*(dmat)->_dmamem_free)((dmat), (mem->segs), (mem->nsegs
));
emuxki_dmamem_delete(mem, type);
return (NULL((void *)0));
}

if (bus_dmamap_create(dmat, mem->size, mem->nsegs, mem->size,(*(dmat)->_dmamap_create)((dmat), (mem->size), (mem->
nsegs), (mem->size), (mem->bound), (bus_dma_flags), (&
(mem->map)))
	      mem->bound, bus_dma_flags, &(mem->map))(*(dmat)->_dmamap_create)((dmat), (mem->size), (mem->
nsegs), (mem->size), (mem->bound), (bus_dma_flags), (&
(mem->map)))) {
bus_dmamem_unmap(dmat, mem->kaddr, mem->size)(*(dmat)->_dmamem_unmap)((dmat), (mem->kaddr), (mem->
size));
bus_dmamem_free(dmat, mem->segs, mem->nsegs)(*(dmat)->_dmamem_free)((dmat), (mem->segs), (mem->nsegs
));
emuxki_dmamem_delete(mem, type);
return (NULL((void *)0));
}

if (bus_dmamap_load(dmat, mem->map, mem->kaddr,(*(dmat)->_dmamap_load)((dmat), (mem->map), (mem->kaddr
), (mem->size), (((void *)0)), (bus_dma_flags)) 
	    mem->size, NULL, bus_dma_flags)(*(dmat)->_dmamap_load)((dmat), (mem->map), (mem->kaddr
), (mem->size), (((void *)0)), (bus_dma_flags))) {
bus_dmamap_destroy(dmat, mem->map)(*(dmat)->_dmamap_destroy)((dmat), (mem->map));
bus_dmamem_unmap(dmat, mem->kaddr, mem->size)(*(dmat)->_dmamem_unmap)((dmat), (mem->kaddr), (mem->
size));
bus_dmamem_free(dmat, mem->segs, mem->nsegs)(*(dmat)->_dmamem_free)((dmat), (mem->segs), (mem->nsegs
));
emuxki_dmamem_delete(mem, type);
return (NULL((void *)0));
}

return (mem);
320}

322void
323emuxki_dmamem_free(struct dmamem *mem, int type)
324{
bus_dmamap_unload(mem->dmat, mem->map)(*(mem->dmat)->_dmamap_unload)((mem->dmat), (mem->
map));
bus_dmamap_destroy(mem->dmat, mem->map)(*(mem->dmat)->_dmamap_destroy)((mem->dmat), (mem->
map));
bus_dmamem_unmap(mem->dmat, mem->kaddr, mem->size)(*(mem->dmat)->_dmamem_unmap)((mem->dmat), (mem->
kaddr), (mem->size));
bus_dmamem_free(mem->dmat, mem->segs, mem->nsegs)(*(mem->dmat)->_dmamem_free)((mem->dmat), (mem->segs
), (mem->nsegs));
emuxki_dmamem_delete(mem, type);
330}


333/*
* Autoconf device callbacks : attach and detach
*/

337void
338emuxki_pci_shutdown(struct emuxki_softc *sc)
339{
if (sc->sc_ih != NULL((void *)0))
pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
if (sc->sc_ios)
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
344}

346int
347emuxki_scinit(struct emuxki_softc *sc, int resuming)
348{
int             err;

bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), ((sc->
sc_flags & 0x0010? 0 : 0x00001000) | 0x00000008 | 0x00000004
 | 0x00000002)))
/* enable spdif(?) output on non-APS */((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), ((sc->
sc_flags & 0x0010? 0 : 0x00001000) | 0x00000008 | 0x00000004
 | 0x00000002)))
(sc->sc_flags & EMUXKI_APS? 0 : EMU_HCFG_GPOUTPUT0) |((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), ((sc->
sc_flags & 0x0010? 0 : 0x00001000) | 0x00000008 | 0x00000004
 | 0x00000002)))
EMU_HCFG_LOCKSOUNDCACHE | EMU_HCFG_LOCKTANKCACHE_MASK |((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), ((sc->
sc_flags & 0x0010? 0 : 0x00001000) | 0x00000008 | 0x00000004
 | 0x00000002)))
EMU_HCFG_MUTEBUTTONENABLE)((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), ((sc->
sc_flags & 0x0010? 0 : 0x00001000) | 0x00000008 | 0x00000004
 | 0x00000002)));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE,((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (0x00002000
 | 0x00000800)))
EMU_INTE_SAMPLERATER | EMU_INTE_PCIERRENABLE)((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (0x00002000
 | 0x00000800)));

if ((err = emuxki_init(sc, resuming)))
return (err);

if (sc->sc_flags & EMUXKI_AUDIGY20x0004) {
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000001
 | 0x00000040 | 0x00000020 | 0x00000010)))
	EMU_HCFG_AUDIOENABLE | EMU_HCFG_AC3ENABLE_CDSPDIF |((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000001
 | 0x00000040 | 0x00000020 | 0x00000010)))
	EMU_HCFG_AC3ENABLE_GPSPDIF | EMU_HCFG_AUTOMUTE)((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000001
 | 0x00000040 | 0x00000020 | 0x00000010)));
} else if (sc->sc_flags & EMUXKI_AUDIGY0x0002) {
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000001
 | 0x00000010)))
	EMU_HCFG_AUDIOENABLE | EMU_HCFG_AUTOMUTE)((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000001
 | 0x00000010)));
} else {
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000001
 | 0x00000200 | 0x00000004 | 0x00000010)))
	EMU_HCFG_AUDIOENABLE | EMU_HCFG_JOYENABLE |((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000001
 | 0x00000200 | 0x00000004 | 0x00000010)))
	EMU_HCFG_LOCKTANKCACHE_MASK | EMU_HCFG_AUTOMUTE)((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000001
 | 0x00000200 | 0x00000004 | 0x00000010)));
}
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE,((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) | 0x00000400 | 0x00000200
 | 0x00000100)))
bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_INTE) |((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) | 0x00000400 | 0x00000200
 | 0x00000100)))
EMU_INTE_VOLINCRENABLE | EMU_INTE_VOLDECRENABLE |((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) | 0x00000400 | 0x00000200
 | 0x00000100)))
EMU_INTE_MUTEENABLE)((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) | 0x00000400 | 0x00000200
 | 0x00000100)));

if (sc->sc_flags & EMUXKI_AUDIGY20x0004) {
if (sc->sc_flags & EMUXKI_CA01080x0020) {
	bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A_IOCFG,((sc->sc_iot)->write_4((sc->sc_ioh), (0x18), (0x0060
 | ((sc->sc_iot)->read_4((sc->sc_ioh), (0x18))))))
	    0x0060 | bus_space_read_4(sc->sc_iot, sc->sc_ioh,((sc->sc_iot)->write_4((sc->sc_ioh), (0x18), (0x0060
 | ((sc->sc_iot)->read_4((sc->sc_ioh), (0x18))))))
	    EMU_A_IOCFG))((sc->sc_iot)->write_4((sc->sc_ioh), (0x18), (0x0060
 | ((sc->sc_iot)->read_4((sc->sc_ioh), (0x18))))));
} else {
	bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A_IOCFG,((sc->sc_iot)->write_4((sc->sc_ioh), (0x18), (0x0040
 | ((sc->sc_iot)->read_4((sc->sc_ioh), (0x18))))))
	    EMU_A_IOCFG_GPOUT0 | bus_space_read_4(sc->sc_iot,((sc->sc_iot)->write_4((sc->sc_ioh), (0x18), (0x0040
 | ((sc->sc_iot)->read_4((sc->sc_ioh), (0x18))))))
	    sc->sc_ioh, EMU_A_IOCFG))((sc->sc_iot)->write_4((sc->sc_ioh), (0x18), (0x0040
 | ((sc->sc_iot)->read_4((sc->sc_ioh), (0x18))))));
}
}

if (!resuming) {
/* No multiple voice support for now */
sc->pvoice = sc->rvoice = NULL((void *)0);
}

return (0);
397}

399int
400emuxki_ac97_init(struct emuxki_softc *sc)
401{
sc->hostif.arg = sc;
sc->hostif.attach = emuxki_ac97_attach;
sc->hostif.read = emuxki_ac97_read;
sc->hostif.write = emuxki_ac97_write;
sc->hostif.reset = emuxki_ac97_reset;
sc->hostif.flags = NULL((void *)0);
return (ac97_attach(&(sc->hostif)));
409}

411int
412emuxki_match(struct device *parent, void *match, void *aux)
413{
return (pci_matchbyid((struct pci_attach_args *)aux, emuxki_devices,
   nitems(emuxki_devices)(sizeof((emuxki_devices)) / sizeof((emuxki_devices)[0]))));
416}

418void
419emuxki_attach(struct device *parent, struct device *self, void *aux)
420{
struct emuxki_softc *sc = (struct emuxki_softc *) self;
struct pci_attach_args *pa = aux;
pci_intr_handle_t ih;
const char     *intrstr;

if (pci_mapreg_map(pa, EMU_PCI_CBIO0x10, PCI_MAPREG_TYPE_IO0x00000001, 0,
   &(sc->sc_iot), &(sc->sc_ioh), &(sc->sc_iob), &(sc->sc_ios), 0)) {
printf(": can't map i/o space\n");
return;
}

sc->sc_pc   = pa->pa_pc;
sc->sc_dmat = pa->pa_dmat;

if (pci_intr_map(pa, &ih)) {
printf(": can't map interrupt\n");
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
return;
}

intrstr = pci_intr_string(pa->pa_pc, ih);
sc->sc_ih = pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO0xb | IPL_MPSAFE0x100,
   emuxki_intr, sc, sc->sc_dev.dv_xname);
if (sc->sc_ih == NULL((void *)0)) {
printf(": can't establish interrupt");
if (intrstr != NULL((void *)0))
	printf(" at %s", intrstr);
printf("\n");
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
return;
}
printf(": %s\n", intrstr);

/* XXX it's unknown whether APS is made from Audigy as well */
if (PCI_PRODUCT(pa->pa_id)(((pa->pa_id) >> 16) & 0xffff) == PCI_PRODUCT_CREATIVELABS_AUDIGY0x0004) {
sc->sc_flags |= EMUXKI_AUDIGY0x0002;
              if (PCI_REVISION(pa->pa_class)(((pa->pa_class) >> 0) & 0xff) == 0x04 ||
    PCI_REVISION(pa->pa_class)(((pa->pa_class) >> 0) & 0xff) == 0x08) {
	sc->sc_flags |= EMUXKI_AUDIGY20x0004;
}
} else if (PCI_PRODUCT(pa->pa_id)(((pa->pa_id) >> 16) & 0xffff) == PCI_PRODUCT_CREATIVELABS_AUDIGY20x0008) {
sc->sc_flags |= EMUXKI_AUDIGY0x0002 | EMUXKI_AUDIGY20x0004;
if (pci_conf_read(pa->pa_pc, pa->pa_tag,
    PCI_SUBSYS_ID_REG0x2c) == 0x10011102) {
	sc->sc_flags |= EMUXKI_CA01080x0020;
}
} else if (pci_conf_read(pa->pa_pc, pa->pa_tag,
   PCI_SUBSYS_ID_REG0x2c) == EMU_SUBSYS_APS0x40011102) {
sc->sc_flags |= EMUXKI_APS0x0010;
} else {
sc->sc_flags |= EMUXKI_SBLIVE0x0001;
}

if (emuxki_scinit(sc, 0) ||
   /* APS has no ac97 XXX */
   (sc->sc_flags & EMUXKI_APS0x0010 || emuxki_ac97_init(sc)) ||
   (sc->sc_audev = audio_attach_mi(&emuxki_hw_if, sc, self)) == NULL((void *)0)) {
emuxki_pci_shutdown(sc);
return;
}
481}

483int
484emuxki_detach(struct device *self, int flags)
485{
struct emuxki_softc *sc = (struct emuxki_softc *) self;

      if (sc->sc_audev != NULL((void *)0)) /* Test in case audio didn't attach */
config_detach(sc->sc_audev, 0);

/* All voices should be stopped now but add some code here if not */

bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_HCFG,((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000008
 | 0x00000004 | 0x00000002)))
EMU_HCFG_LOCKSOUNDCACHE | EMU_HCFG_LOCKTANKCACHE_MASK |((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000008
 | 0x00000004 | 0x00000002)))
EMU_HCFG_MUTEBUTTONENABLE)((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (0x00000008
 | 0x00000004 | 0x00000002)));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE, 0)((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (0)));

emuxki_shutdown(sc);

emuxki_pci_shutdown(sc);

return (0);
503}

505int
506emuxki_activate(struct device *self, int act)
507{
struct emuxki_softc *sc = (struct emuxki_softc *)self;

switch (act) {
case DVACT_RESUME4:
emuxki_scinit(sc, 1);
ac97_resume(&sc->hostif, sc->codecif);
break;
default:
break;
}
return (config_activate_children(self, act));
519}

521/* Misc stuff relative to emu10k1 */

523static u_int32_t
524emuxki_rate_to_pitch(u_int32_t rate)
525{
static const u_int32_t logMagTable[128] = {
0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3,
0x13aa2, 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a,
0x2655d, 0x28ed5, 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb,
0x381b6, 0x3a93d, 0x3d081, 0x3f782, 0x41e42, 0x444c1, 0x46b01,
0x49101, 0x4b6c4, 0x4dc49, 0x50191, 0x5269e, 0x54b6f, 0x57006,
0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7, 0x646ee, 0x66a00,
0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829, 0x759d4,
0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20,
0x93d26, 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec,
0xa11d8, 0xa2f9d, 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241,
0xadf26, 0xafbe7, 0xb1885, 0xb3500, 0xb5157, 0xb6d8c, 0xb899f,
0xba58f, 0xbc15e, 0xbdd0c, 0xbf899, 0xc1404, 0xc2f50, 0xc4a7b,
0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c, 0xceaec, 0xd053f,
0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3, 0xdba4a,
0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a,
0xf2c83, 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57,
0xfd1a7, 0xfe8df
};
static const u_int8_t logSlopeTable[128] = {
0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
};
int8_t          i;

if (rate == 0)
return 0;	/* Bail out if no leading "1" */
rate *= 11185;		/* Scale 48000 to 0x20002380 */
for (i = 31; i > 0; i--) {
if (rate & 0x80000000) {	/* Detect leading "1" */
	return (((u_int32_t) (i - 15) << 20) +
		logMagTable[0x7f & (rate >> 24)] +
		(0x7f & (rate >> 17)) *
		logSlopeTable[0x7f & (rate >> 24)]);
}
rate <<= 1;
}

return 0;		/* Should never reach this point */
581}

583/* Emu10k1 Low level */

585static u_int32_t
586emuxki_read(struct emuxki_softc *sc, u_int16_t chano, u_int32_t reg)
587{
u_int32_t       ptr, mask = 0xffffffff;
u_int8_t        size, offset = 0;

ptr = ((((u_int32_t) reg) << 16) &
(sc->sc_flags & EMUXKI_AUDIGY0x0002 ?
	EMU_A_PTR_ADDR_MASK0x0fff0000 : EMU_PTR_ADDR_MASK0x07ff0000)) |
(chano & EMU_PTR_CHNO_MASK0x0000003f);
if (reg & 0xff000000) {
size = (reg >> 24) & 0x3f;
offset = (reg >> 16) & 0x1f;
mask = ((1 << size) - 1) << offset;
}

bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_PTR, ptr)((sc->sc_iot)->write_4((sc->sc_ioh), (0x00), (ptr)));
ptr = (bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_DATA)((sc->sc_iot)->read_4((sc->sc_ioh), (0x04))) & mask)
>> offset;
return (ptr);
605}

607static void
608emuxki_write(struct emuxki_softc *sc, u_int16_t chano,
     u_int32_t reg, u_int32_t data)
610{
u_int32_t       ptr, mask;
u_int8_t        size, offset;

ptr = ((((u_int32_t) reg) << 16) &
(sc->sc_flags & EMUXKI_AUDIGY0x0002 ?
	EMU_A_PTR_ADDR_MASK0x0fff0000 : EMU_PTR_ADDR_MASK0x07ff0000)) |
(chano & EMU_PTR_CHNO_MASK0x0000003f);

/* BE CAREFUL WITH THAT AXE, EUGENE */
if (ptr == 0x52 || ptr == 0x53)
return;

if (reg & 0xff000000) {
size = (reg >> 24) & 0x3f;
offset = (reg >> 16) & 0x1f;
mask = ((1 << size) - 1) << offset;
data = ((data << offset) & mask) |
	(emuxki_read(sc, chano, reg & 0xffff) & ~mask);
}

bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_PTR, ptr)((sc->sc_iot)->write_4((sc->sc_ioh), (0x00), (ptr)));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_DATA, data)((sc->sc_iot)->write_4((sc->sc_ioh), (0x04), (data))
);
633}

635/* Microcode should this go in /sys/dev/microcode ? */

637void
638emuxki_write_micro(struct emuxki_softc *sc, u_int32_t pc, u_int32_t data)
639{
emuxki_write(sc, 0,
(sc->sc_flags & EMUXKI_AUDIGY0x0002 ?
	EMU_A_MICROCODEBASE0x600 : EMU_MICROCODEBASE0x400) + pc,
 data);
644}

646void
647emuxki_dsp_addop(struct emuxki_softc *sc, u_int16_t *pc, u_int8_t op,
  u_int16_t r, u_int16_t a, u_int16_t x, u_int16_t y)
649{
if (sc->sc_flags & EMUXKI_AUDIGY0x0002) {
emuxki_write_micro(sc, *pc << 1,
	((x << 12) & EMU_A_DSP_LOWORD_OPX_MASK0x007ff000) |
	(y & EMU_A_DSP_LOWORD_OPY_MASK0x000007ff));
emuxki_write_micro(sc, (*pc << 1) + 1,
	((op << 24) & EMU_A_DSP_HIWORD_OPCODE_MASK0x0f000000) |
	((r << 12) & EMU_A_DSP_HIWORD_RESULT_MASK0x007ff000) |
	(a & EMU_A_DSP_HIWORD_OPA_MASK0x000007ff));
} else {
emuxki_write_micro(sc, *pc << 1,
	((x << 10) & EMU_DSP_LOWORD_OPX_MASK0x000ffc00) |
	(y & EMU_DSP_LOWORD_OPY_MASK0x000003ff));
emuxki_write_micro(sc, (*pc << 1) + 1,
	((op << 20) & EMU_DSP_HIWORD_OPCODE_MASK0x00f00000) |
	((r << 10) & EMU_DSP_HIWORD_RESULT_MASK0x000ffc00) |
	(a & EMU_DSP_HIWORD_OPA_MASK0x000003ff));
}
(*pc)++;
668}

670/* init and shutdown */

672void
673emuxki_initfx(struct emuxki_softc *sc)
674{
u_int16_t       pc;

/* Set all GPRs to 0 */
for (pc = 0; pc < 256; pc++)
emuxki_write(sc, 0, EMU_DSP_GPR(pc)(0x100 + pc), 0);
for (pc = 0; pc < 160; pc++) {
emuxki_write(sc, 0, EMU_TANKMEMDATAREGBASE0x200 + pc, 0);
emuxki_write(sc, 0, EMU_TANKMEMADDRREGBASE0x300 + pc, 0);
}
pc = 0;

if (sc->sc_flags & EMUXKI_AUDIGY0x0002) {
/* AC97 Out (l/r) = AC97 In (l/r) + FX[0/1] * 4 */
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS0x4,
		  EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_FRONT)((0x060 + (4 << 1))),
		  EMU_A_DSP_CST(0)(0xc0 + 0),
		  EMU_DSP_FX(0)(0), EMU_A_DSP_CST(4)(0xc0 + 4));
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS0x4,
		  EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_FRONT)(((0x060 + (4 << 1)) + 1)),
		  EMU_A_DSP_CST(0)(0xc0 + 0),
		  EMU_DSP_FX(1)(1), EMU_A_DSP_CST(4)(0xc0 + 4));

/* Rear channel OUT (l/r) = FX[2/3] * 4 */
698#if 0
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS0x4,
		  EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_REAR)((0x060 + (7 << 1))),
		  EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_FRONT)((0x060 + (4 << 1))),
		  EMU_DSP_FX(0)(0), EMU_A_DSP_CST(4)(0xc0 + 4));
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS0x4,
		  EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_REAR)(((0x060 + (7 << 1)) + 1)),
		  EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_FRONT)(((0x060 + (4 << 1)) + 1)),
		  EMU_DSP_FX(1)(1), EMU_A_DSP_CST(4)(0xc0 + 4));
707#endif
/* ADC recording (l/r) = AC97 In (l/r) */
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC30x6,
		  EMU_A_DSP_OUTL(EMU_A_DSP_OUT_ADC)((0x060 + (11 << 1))),
		  EMU_A_DSP_INL(EMU_DSP_IN_AC97)((0x040 + (0 << 1))),
		  EMU_A_DSP_CST(0)(0xc0 + 0), EMU_A_DSP_CST(0)(0xc0 + 0));
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC30x6,
		  EMU_A_DSP_OUTR(EMU_A_DSP_OUT_ADC)(((0x060 + (11 << 1)) + 1)),
		  EMU_A_DSP_INR(EMU_DSP_IN_AC97)(((0x040 + (0 << 1)) + 1)),
		  EMU_A_DSP_CST(0)(0xc0 + 0), EMU_A_DSP_CST(0)(0xc0 + 0));

/* zero out the rest of the microcode */
while (pc < 512)
	emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC30x6,
			  EMU_A_DSP_CST(0)(0xc0 + 0), EMU_A_DSP_CST(0)(0xc0 + 0),
			  EMU_A_DSP_CST(0)(0xc0 + 0), EMU_A_DSP_CST(0)(0xc0 + 0));

emuxki_write(sc, 0, EMU_A_DBG0x53, 0);	/* Is it really necessary ? */
} else {
/* AC97 Out (l/r) = AC97 In (l/r) + FX[0/1] * 4 */
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS0x4,
		  EMU_DSP_OUTL(EMU_DSP_OUT_A_FRONT)((0x020 + (0 << 1))),
		  EMU_DSP_CST(0)(0x40 + 0),
		  EMU_DSP_FX(0)(0), EMU_DSP_CST(4)(0x40 + 4));
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS0x4,
		  EMU_DSP_OUTR(EMU_DSP_OUT_A_FRONT)(((0x020 + (0 << 1)) + 1)),
		  EMU_DSP_CST(0)(0x40 + 0),
		  EMU_DSP_FX(1)(1), EMU_DSP_CST(4)(0x40 + 4));

/* Rear channel OUT (l/r) = FX[2/3] * 4 */
737#if 0
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS0x4,
		  EMU_DSP_OUTL(EMU_DSP_OUT_AD_REAR)((0x020 + (4 << 1))),
		  EMU_DSP_OUTL(EMU_DSP_OUT_A_FRONT)((0x020 + (0 << 1))),
		  EMU_DSP_FX(0)(0), EMU_DSP_CST(4)(0x40 + 4));
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS0x4,
		  EMU_DSP_OUTR(EMU_DSP_OUT_AD_REAR)(((0x020 + (4 << 1)) + 1)),
		  EMU_DSP_OUTR(EMU_DSP_OUT_A_FRONT)(((0x020 + (0 << 1)) + 1)),
		  EMU_DSP_FX(1)(1), EMU_DSP_CST(4)(0x40 + 4));
746#endif
/* ADC recording (l/r) = AC97 In (l/r) */
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC30x6,
		  EMU_DSP_OUTL(EMU_DSP_OUT_ADC)((0x020 + (5 << 1))),
		  EMU_DSP_INL(EMU_DSP_IN_AC97)((0x010 + (0 << 1))),
		  EMU_DSP_CST(0)(0x40 + 0), EMU_DSP_CST(0)(0x40 + 0));
emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC30x6,
		  EMU_DSP_OUTR(EMU_DSP_OUT_ADC)(((0x020 + (5 << 1)) + 1)),
		  EMU_DSP_INR(EMU_DSP_IN_AC97)(((0x010 + (0 << 1)) + 1)),
		  EMU_DSP_CST(0)(0x40 + 0), EMU_DSP_CST(0)(0x40 + 0));

/* zero out the rest of the microcode */
while (pc < 512)
	emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC30x6,
			  EMU_DSP_CST(0)(0x40 + 0), EMU_DSP_CST(0)(0x40 + 0),
			  EMU_DSP_CST(0)(0x40 + 0), EMU_DSP_CST(0)(0x40 + 0));

emuxki_write(sc, 0, EMU_DBG0x52, 0);	/* Is it really necessary ? */
}
765}

767int
768emuxki_init(struct emuxki_softc *sc, int resuming)
769{
u_int16_t       i;
u_int32_t       spcs, *ptb;
bus_addr_t      silentpage;

/* disable any channel interrupt */
emuxki_write(sc, 0, EMU_CLIEL0x58, 0);
emuxki_write(sc, 0, EMU_CLIEH0x59, 0);
emuxki_write(sc, 0, EMU_SOLEL0x5c, 0);
emuxki_write(sc, 0, EMU_SOLEH0x5d, 0);

/* Set recording buffers sizes to zero */
emuxki_write(sc, 0, EMU_MICBS0x49, EMU_RECBS_BUFSIZE_NONE0x00000000);
emuxki_write(sc, 0, EMU_MICBA0x45, 0);
emuxki_write(sc, 0, EMU_FXBS0x4b, EMU_RECBS_BUFSIZE_NONE0x00000000);
emuxki_write(sc, 0, EMU_FXBA0x47, 0);
emuxki_write(sc, 0, EMU_ADCBS0x4a, EMU_RECBS_BUFSIZE_NONE0x00000000);
emuxki_write(sc, 0, EMU_ADCBA0x46, 0);

      if (sc->sc_flags & EMUXKI_AUDIGY0x0002) {
              emuxki_write(sc, 0, EMU_SPBYPASS0x5e, EMU_SPBYPASS_24_BITS0x00000f00);
              emuxki_write(sc, 0, EMU_AC97SLOT0x5f, EMU_AC97SLOT_CENTER0x00000010 | EMU_AC97SLOT_LFE0x00000020);
      }

/* Initialize all channels to stopped and no effects */
for (i = 0; i < EMU_NUMCHAN64; i++) {
emuxki_write(sc, i, EMU_CHAN_DCYSUSV0x12, 0);
emuxki_write(sc, i, EMU_CHAN_IP0x18, 0);
emuxki_write(sc, i, EMU_CHAN_VTFT0x03, 0xffff);
emuxki_write(sc, i, EMU_CHAN_CVCF0x02, 0xffff);
emuxki_write(sc, i, EMU_CHAN_PTRX0x01, 0);
emuxki_write(sc, i, EMU_CHAN_CPF0x00, 0);
emuxki_write(sc, i, EMU_CHAN_CCR0x09, 0);
emuxki_write(sc, i, EMU_CHAN_PSST0x06, 0);
emuxki_write(sc, i, EMU_CHAN_DSL0x07, 0x10);	/* Why 16 ? */
emuxki_write(sc, i, EMU_CHAN_CCCA0x08, 0);
emuxki_write(sc, i, EMU_CHAN_Z10x05, 0);
emuxki_write(sc, i, EMU_CHAN_Z20x04, 0);
emuxki_write(sc, i, EMU_CHAN_FXRT0x0b, 0x32100000);
emuxki_write(sc, i, EMU_CHAN_ATKHLDM0x15, 0);
emuxki_write(sc, i, EMU_CHAN_DCYSUSM0x16, 0);
emuxki_write(sc, i, EMU_CHAN_IFATN0x19, 0xffff);
emuxki_write(sc, i, EMU_CHAN_PEFE0x1a, 0);
emuxki_write(sc, i, EMU_CHAN_FMMOD0x1b, 0);
emuxki_write(sc, i, EMU_CHAN_TREMFRQ0x1c, 24);
emuxki_write(sc, i, EMU_CHAN_FM2FRQ20x1d, 24);
emuxki_write(sc, i, EMU_CHAN_TEMPENV0x1e, 0);

/* these are last so OFF prevents writing */
emuxki_write(sc, i, EMU_CHAN_LFOVAL20x17, 0);
emuxki_write(sc, i, EMU_CHAN_LFOVAL10x13, 0);
emuxki_write(sc, i, EMU_CHAN_ATKHLDV0x11, 0);
emuxki_write(sc, i, EMU_CHAN_ENVVOL0x10, 0);
emuxki_write(sc, i, EMU_CHAN_ENVVAL0x14, 0);
}

/* set digital outputs format */
spcs = (EMU_SPCS_CLKACCY_1000PPM0x00000000 | EMU_SPCS_SAMPLERATE_480x02000000 |
     EMU_SPCS_CHANNELNUM_LEFT0x00100000 | EMU_SPCS_SOURCENUM_UNSPEC0x00000000 |
EMU_SPCS_GENERATIONSTATUS0x00008000 | 0x00001200 /* Cat code. */ |
0x00000000 /* IEC-958 Mode */ | EMU_SPCS_EMPHASIS_NONE0x00000000 |
EMU_SPCS_COPYRIGHT0x00000004);
emuxki_write(sc, 0, EMU_SPCS00x54, spcs);
emuxki_write(sc, 0, EMU_SPCS10x55, spcs);
emuxki_write(sc, 0, EMU_SPCS20x56, spcs);

if (sc->sc_flags & EMUXKI_CA01080x0020) {
u_int32_t tmp;

/* Setup SRCMulti_I2S SamplingRate */
tmp = emuxki_read(sc, 0, EMU_A_SPDIF_SAMPLERATE0x76) & 0xfffff1ff;
emuxki_write(sc, 0, EMU_A_SPDIF_SAMPLERATE0x76, tmp | 0x400);

/* Setup SRCSel (Enable SPDIF, I2S SRCMulti) */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_PTR, EMU_A2_SRCSEL)((sc->sc_iot)->write_4((sc->sc_ioh), (0x20), (0x600000
)));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_DATA,((sc->sc_iot)->write_4((sc->sc_ioh), (0x24), (0x00000004
 | 0x00000010)))
EMU_A2_SRCSEL_ENABLE_SPDIF | EMU_A2_SRCSEL_ENABLE_SRCMULTI)((sc->sc_iot)->write_4((sc->sc_ioh), (0x24), (0x00000004
 | 0x00000010)));

/* Setup SRCMulti Input Audio Enable */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_PTR, 0x7b0000)((sc->sc_iot)->write_4((sc->sc_ioh), (0x20), (0x7b0000
)));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_DATA, 0xff000000)((sc->sc_iot)->write_4((sc->sc_ioh), (0x24), (0xff000000
)));

/* Setup SPDIF Out Audio Enable
 * The Audigy 2 Value has a separate SPDIF out,
 * so no need for a mixer switch */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_PTR, 0x7a0000)((sc->sc_iot)->write_4((sc->sc_ioh), (0x20), (0x7a0000
)));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_DATA, 0xff000000)((sc->sc_iot)->write_4((sc->sc_ioh), (0x24), (0xff000000
)));
tmp = bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_A_IOCFG)((sc->sc_iot)->read_4((sc->sc_ioh), (0x18))) & ~0x8; /* Clear bit 3 */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A_IOCFG, tmp)((sc->sc_iot)->write_4((sc->sc_ioh), (0x18), (tmp)));
} else if(sc->sc_flags & EMUXKI_AUDIGY20x0004) {
              emuxki_write(sc, 0, EMU_A2_SPDIF_SAMPLERATE(((3) << 24) | ((9) << 16) | (0x76)), EMU_A2_SPDIF_UNKNOWN0x2);

              bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_PTR, EMU_A2_SRCSEL)((sc->sc_iot)->write_4((sc->sc_ioh), (0x20), (0x600000
)));
              bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_DATA,((sc->sc_iot)->write_4((sc->sc_ioh), (0x24), (0x00000004
 | 0x00000010))) 
                      EMU_A2_SRCSEL_ENABLE_SPDIF | EMU_A2_SRCSEL_ENABLE_SRCMULTI)((sc->sc_iot)->write_4((sc->sc_ioh), (0x24), (0x00000004
 | 0x00000010)));

              bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_PTR, EMU_A2_SRCMULTI)((sc->sc_iot)->write_4((sc->sc_ioh), (0x20), (0x6e0000
)));
              bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_A2_DATA, EMU_A2_SRCMULTI_ENABLE_INPUT)((sc->sc_iot)->write_4((sc->sc_ioh), (0x24), (0xff00ff00
)));
      }


/* Let's play with sound processor */
emuxki_initfx(sc);

if (!resuming) {
/* Here is our Page Table */
if ((sc->ptb = emuxki_dmamem_alloc(sc->sc_dmat,
    EMU_MAXPTE((0x00ffffff + 1) / 4096) * sizeof(u_int32_t),
    EMU_DMA_ALIGN4096, EMU_DMAMEM_NSEG1,
    M_DEVBUF2, M_WAITOK0x0001)) == NULL((void *)0))
	return (ENOMEM12);

/* This is necessary unless you like Metallic noise... */
if ((sc->silentpage = emuxki_dmamem_alloc(sc->sc_dmat, EMU_PTESIZE4096,
    EMU_DMA_ALIGN4096, EMU_DMAMEM_NSEG1, M_DEVBUF2, M_WAITOK0x0001))==NULL((void *)0)){
	emuxki_dmamem_free(sc->ptb, M_DEVBUF2);
	return (ENOMEM12);
}

/* Zero out the silent page */
/* This might not be always true, it might be 128 for 8bit channels */
memset(KERNADDR(sc->silentpage), 0, DMASIZE(sc->silentpage))__builtin_memset((((void *)((sc->silentpage)->kaddr))),
 (0), (((sc->silentpage)->size)));
}

/*
* Set all the PTB Entries to the silent page We shift the physical
* address by one and OR it with the page number. I don't know what
* the ORed index is for, might be a very useful unused feature...
*/
silentpage = DMAADDR(sc->silentpage)((sc->silentpage)->segs[0].ds_addr) << 1;
ptb = KERNADDR(sc->ptb)((void *)((sc->ptb)->kaddr));
for (i = 0; i < EMU_MAXPTE((0x00ffffff + 1) / 4096); i++)
ptb[i] = htole32(silentpage | i)((__uint32_t)(silentpage | i));

/* Write PTB address and set TCB to none */
emuxki_write(sc, 0, EMU_PTB0x40, DMAADDR(sc->ptb)((sc->ptb)->segs[0].ds_addr));
emuxki_write(sc, 0, EMU_TCBS0x44, 0);	/* This means 16K TCB */
emuxki_write(sc, 0, EMU_TCB0x41, 0);	/* No TCB use for now */

/*
* Set channels MAPs to the silent page.
* I don't know what MAPs are for.
*/
silentpage |= EMU_CHAN_MAP_PTI_MASK0x00001fff;
for (i = 0; i < EMU_NUMCHAN64; i++) {
emuxki_write(sc, i, EMU_CHAN_MAPA0x0c, silentpage);
emuxki_write(sc, i, EMU_CHAN_MAPB0x0d, silentpage);
sc->channel[i] = NULL((void *)0);
}

if (!resuming) {
/* Init voices list */
LIST_INIT(&(sc->voices))do { ((&(sc->voices))->lh_first) = ((void *)0); } while
 (0);
}

/* Timer is stopped */
sc->timerstate &= ~EMU_TIMER_STATE_ENABLED1;
return (0);
927}

929void
930emuxki_shutdown(struct emuxki_softc *sc)
931{
u_int32_t       i;

/* Disable any Channels interrupts */
emuxki_write(sc, 0, EMU_CLIEL0x58, 0);
emuxki_write(sc, 0, EMU_CLIEH0x59, 0);
emuxki_write(sc, 0, EMU_SOLEL0x5c, 0);
emuxki_write(sc, 0, EMU_SOLEH0x5d, 0);

/*
* Should do some voice(stream) stopping stuff here, that's what will
* stop and deallocate all channels.
*/

/* Stop all channels */
/* XXX This shouldn't be necessary, I'll remove once everything works */
for (i = 0; i < EMU_NUMCHAN64; i++)
emuxki_write(sc, i, EMU_CHAN_DCYSUSV0x12, 0);
for (i = 0; i < EMU_NUMCHAN64; i++) {
emuxki_write(sc, i, EMU_CHAN_VTFT0x03, 0);
emuxki_write(sc, i, EMU_CHAN_CVCF0x02, 0);
emuxki_write(sc, i, EMU_CHAN_PTRX0x01, 0);
emuxki_write(sc, i, EMU_CHAN_CPF0x00, 0);
}

/*
* Deallocate Emu10k1 caches and recording buffers. Again it will be
* removed because it will be done in voice shutdown.
*/
emuxki_write(sc, 0, EMU_MICBS0x49, EMU_RECBS_BUFSIZE_NONE0x00000000);
emuxki_write(sc, 0, EMU_MICBA0x45, 0);
emuxki_write(sc, 0, EMU_FXBS0x4b, EMU_RECBS_BUFSIZE_NONE0x00000000);
emuxki_write(sc, 0, EMU_FXBA0x47, 0);
if (sc->sc_flags & EMUXKI_AUDIGY0x0002) {
emuxki_write(sc, 0, EMU_A_FXWC10x74, 0);
emuxki_write(sc, 0, EMU_A_FXWC20x75, 0);
} else
emuxki_write(sc, 0, EMU_FXWC0x43, 0);
emuxki_write(sc, 0, EMU_ADCBS0x4a, EMU_RECBS_BUFSIZE_NONE0x00000000);
emuxki_write(sc, 0, EMU_ADCBA0x46, 0);

/*
* XXX I don't know yet how I will handle tank cache buffer,
* I don't even clearly  know what it is for.
*/
emuxki_write(sc, 0, EMU_TCB0x41, 0);	/* 16K again */
emuxki_write(sc, 0, EMU_TCBS0x44, 0);

emuxki_write(sc, 0, EMU_DBG0x52, 0x8000);	/* necessary ? */

emuxki_dmamem_free(sc->silentpage, M_DEVBUF2);
emuxki_dmamem_free(sc->ptb, M_DEVBUF2);
983}

985/* Emu10k1 Memory management */

987struct emuxki_mem *
988emuxki_mem_new(struct emuxki_softc *sc, int ptbidx,
size_t size, int type, int flags)
990{
struct emuxki_mem *mem;

if ((mem = malloc(sizeof(*mem), type, flags)) == NULL((void *)0))
return (NULL((void *)0));

mem->ptbidx = ptbidx;
if ((mem->dmamem = emuxki_dmamem_alloc(sc->sc_dmat, size,
   EMU_DMA_ALIGN4096, EMU_DMAMEM_NSEG1, type, flags)) == NULL((void *)0)) {
free(mem, type, 0);
return (NULL((void *)0));
}
return (mem);
1003}

1005void
1006emuxki_mem_delete(struct emuxki_mem *mem, int type)
1007{
emuxki_dmamem_free(mem->dmamem, type);
free(mem, type, 0);
1010}

1012void *
1013emuxki_pmem_alloc(struct emuxki_softc *sc, size_t size, int type, int flags)
1014{
int             i, j;
size_t          numblocks;
struct emuxki_mem *mem;
u_int32_t      *ptb, silentpage;

ptb = KERNADDR(sc->ptb)((void *)((sc->ptb)->kaddr));
silentpage = DMAADDR(sc->silentpage)((sc->silentpage)->segs[0].ds_addr) << 1;
numblocks = size / EMU_PTESIZE4096;
if (size % EMU_PTESIZE4096)
numblocks++;

for (i = 0; i < EMU_MAXPTE((0x00ffffff + 1) / 4096); i++)
if ((letoh32(ptb[i])((__uint32_t)(ptb[i])) & EMU_CHAN_MAP_PTE_MASK0xffffe000) == silentpage) {
	/* We look for a free PTE */
	for (j = 0; j < numblocks; j++)
		if ((letoh32(ptb[i + j])((__uint32_t)(ptb[i + j]))
		    & EMU_CHAN_MAP_PTE_MASK0xffffe000)
		    != silentpage)
			break;
	if (j == numblocks) {
		if ((mem = emuxki_mem_new(sc, i,
				size, type, flags)) == NULL((void *)0)) {
			return (NULL((void *)0));
		}
		for (j = 0; j < numblocks; j++)
			ptb[i + j] =
			    htole32((((DMAADDR(mem->dmamem) +((__uint32_t)((((((mem->dmamem)->segs[0].ds_addr) + j *
 4096)) << 1) | (i + j)))
			    j * EMU_PTESIZE)) << 1) | (i + j))((__uint32_t)((((((mem->dmamem)->segs[0].ds_addr) + j *
 4096)) << 1) | (i + j)));
		mtx_enter(&audio_lock);
		LIST_INSERT_HEAD(&(sc->mem), mem, next)do { if (((mem)->next.le_next = (&(sc->mem))->lh_first
) != ((void *)0)) (&(sc->mem))->lh_first->next.le_prev
 = &(mem)->next.le_next; (&(sc->mem))->lh_first
 = (mem); (mem)->next.le_prev = &(&(sc->mem))->
lh_first; } while (0);
		mtx_leave(&audio_lock);
		return (KERNADDR(mem->dmamem)((void *)((mem->dmamem)->kaddr)));
	} else
		i += j;
}
return (NULL((void *)0));
1051}

1053void *
1054emuxki_rmem_alloc(struct emuxki_softc *sc, size_t size, int type, int flags)
1055{
struct emuxki_mem *mem;

mem = emuxki_mem_new(sc, EMU_RMEM0xFFFF, size, type, flags);
if (mem == NULL((void *)0))
return (NULL((void *)0));

mtx_enter(&audio_lock);
LIST_INSERT_HEAD(&(sc->mem), mem, next)do { if (((mem)->next.le_next = (&(sc->mem))->lh_first
) != ((void *)0)) (&(sc->mem))->lh_first->next.le_prev
 = &(mem)->next.le_next; (&(sc->mem))->lh_first
 = (mem); (mem)->next.le_prev = &(&(sc->mem))->
lh_first; } while (0);
mtx_leave(&audio_lock);

return (KERNADDR(mem->dmamem)((void *)((mem->dmamem)->kaddr)));
1067}

1069/*
* emuxki_channel_* : Channel management functions
* emuxki_chanparms_* : Channel parameters modification functions
*/

1074/*
* is splaudio necessary here, can the same voice be manipulated by two
* different threads at a time ?
*/
1078void
1079emuxki_chanparms_set_defaults(struct emuxki_channel *chan)
1080{
chan->fxsend.a.level = chan->fxsend.b.level =
chan->fxsend.c.level = chan->fxsend.d.level =
/* for audigy */
chan->fxsend.e.level = chan->fxsend.f.level =
chan->fxsend.g.level = chan->fxsend.h.level =
chan->voice->sc->sc_flags & EMUXKI_AUDIGY0x0002 ?
	0xc0 : 0xff;	/* not max */

chan->fxsend.a.dest = 0x0;
chan->fxsend.b.dest = 0x1;
chan->fxsend.c.dest = 0x2;
chan->fxsend.d.dest = 0x3;
/* for audigy */
chan->fxsend.e.dest = 0x4;
chan->fxsend.f.dest = 0x5;
chan->fxsend.g.dest = 0x6;
chan->fxsend.h.dest = 0x7;

chan->pitch.initial = 0x0000;	/* shouldn't it be 0xE000 ? */
chan->pitch.current = 0x0000;	/* should it be 0x0400 */
chan->pitch.target = 0x0000;	/* the unity pitch shift ? */
chan->pitch.envelope_amount = 0x00;	/* none */

chan->initial_attenuation = 0x00;	/* no attenuation */
chan->volume.current = 0x0000;	/* no volume */
chan->volume.target = 0xffff;
chan->volume.envelope.current_state = 0x8000;	/* 0 msec delay */
chan->volume.envelope.hold_time = 0x7f;	/* 0 msec */
chan->volume.envelope.attack_time = 0x7F;	/* 5.5msec */
chan->volume.envelope.sustain_level = 0x7F;	/* full  */
chan->volume.envelope.decay_time = 0x7F;	/* 22msec  */

chan->filter.initial_cutoff_frequency = 0xff;	/* no filter */
chan->filter.current_cutoff_frequency = 0xffff;	/* no filtering */
chan->filter.target_cutoff_frequency = 0xffff;	/* no filtering */
chan->filter.lowpass_resonance_height = 0x0;
chan->filter.interpolation_ROM = 0x1;	/* full band */
chan->filter.envelope_amount = 0x7f;	/* none */
chan->filter.LFO_modulation_depth = 0x00;	/* none */

chan->loop.start = 0x000000;
chan->loop.end = 0x000010;	/* Why ? */

chan->modulation.envelope.current_state = 0x8000;
chan->modulation.envelope.hold_time = 0x00;	/* 127 better ? */
chan->modulation.envelope.attack_time = 0x00;	/* infinite */
chan->modulation.envelope.sustain_level = 0x00;	/* off */
chan->modulation.envelope.decay_time = 0x7f;	/* 22 msec */
chan->modulation.LFO_state = 0x8000;

chan->vibrato_LFO.state = 0x8000;
chan->vibrato_LFO.modulation_depth = 0x00;	/* none */
chan->vibrato_LFO.vibrato_depth = 0x00;
chan->vibrato_LFO.frequency = 0x00;	/* Why set to 24 when
				 * initialized ? */

chan->tremolo_depth = 0x00;
1138}

1140/* only call it at splaudio */
1141struct emuxki_channel *
1142emuxki_channel_new(struct emuxki_voice *voice, u_int8_t num)
1143{
struct emuxki_channel *chan;

chan = malloc(sizeof(struct emuxki_channel), M_DEVBUF2,
   M_WAITOK0x0001 | M_CANFAIL0x0004);
if (chan == NULL((void *)0))
return (NULL((void *)0));

chan->voice = voice;
chan->num = num;
emuxki_chanparms_set_defaults(chan);
chan->voice->sc->channel[num] = chan;
return (chan);
1156}

1158/* only call it at splaudio */
1159void
1160emuxki_channel_delete(struct emuxki_channel *chan)
1161{
chan->voice->sc->channel[chan->num] = NULL((void *)0);
free(chan, M_DEVBUF2, 0);
1164}

1166void
1167emuxki_channel_set_fxsend(struct emuxki_channel *chan,
	   struct emuxki_chanparms_fxsend *fxsend)
1169{
/* Could do a memcpy ...*/
chan->fxsend.a.level = fxsend->a.level;
chan->fxsend.b.level = fxsend->b.level;
chan->fxsend.c.level = fxsend->c.level;
chan->fxsend.d.level = fxsend->d.level;
chan->fxsend.a.dest = fxsend->a.dest;
chan->fxsend.b.dest = fxsend->b.dest;
chan->fxsend.c.dest = fxsend->c.dest;
chan->fxsend.d.dest = fxsend->d.dest;

/* for audigy */
chan->fxsend.e.level = fxsend->e.level;
chan->fxsend.f.level = fxsend->f.level;
chan->fxsend.g.level = fxsend->g.level;
chan->fxsend.h.level = fxsend->h.level;
chan->fxsend.e.dest = fxsend->e.dest;
chan->fxsend.f.dest = fxsend->f.dest;
chan->fxsend.g.dest = fxsend->g.dest;
chan->fxsend.h.dest = fxsend->h.dest;
1189}

1191void
1192emuxki_channel_set_srate(struct emuxki_channel *chan, u_int32_t srate)
1193{
chan->pitch.target = (srate << 8) / 375;
chan->pitch.target = (chan->pitch.target >> 1) +
(chan->pitch.target & 1);
chan->pitch.target &= 0xffff;
chan->pitch.current = chan->pitch.target;
chan->pitch.initial =
(emuxki_rate_to_pitch(srate) >> 8) & EMU_CHAN_IP_MASK0x0000ffff;
1201}

1203/* voice params must be set before calling this */
1204void
1205emuxki_channel_set_bufparms(struct emuxki_channel *chan,
	     u_int32_t start, u_int32_t end)
1207{
chan->loop.start = start & EMU_CHAN_PSST_LOOPSTARTADDR_MASK0x00ffffff;
chan->loop.end = end & EMU_CHAN_DSL_LOOPENDADDR_MASK0x00ffffff;
1210}

1212void
1213emuxki_channel_commit_fx(struct emuxki_channel *chan)
1214{
struct emuxki_softc *sc = chan->voice->sc;
      u_int8_t	chano = chan->num;
      
      if (sc->sc_flags & EMUXKI_AUDIGY0x0002) {
              emuxki_write(sc, chano, EMU_A_CHAN_FXRT10x7e,
                            (chan->fxsend.d.dest << 24) |
                            (chan->fxsend.c.dest << 16) |
                            (chan->fxsend.b.dest << 8) |
                            (chan->fxsend.a.dest));
              emuxki_write(sc, chano, EMU_A_CHAN_FXRT20x7c,
                            (chan->fxsend.h.dest << 24) |
                            (chan->fxsend.g.dest << 16) |
                            (chan->fxsend.f.dest << 8) |
                            (chan->fxsend.e.dest));
              emuxki_write(sc, chano, EMU_A_CHAN_SENDAMOUNTS0x7d,
                            (chan->fxsend.e.level << 24) |
                            (chan->fxsend.f.level << 16) |
                            (chan->fxsend.g.level << 8) |
                            (chan->fxsend.h.level));
      } else {
              emuxki_write(sc, chano, EMU_CHAN_FXRT0x0b,
                            (chan->fxsend.d.dest << 28) |
                            (chan->fxsend.c.dest << 24) |
                            (chan->fxsend.b.dest << 20) |
                            (chan->fxsend.a.dest << 16));
      }
      
      emuxki_write(sc, chano, 0x10000000 | EMU_CHAN_PTRX0x01,
                    (chan->fxsend.a.level << 8) | chan->fxsend.b.level);
      emuxki_write(sc, chano, EMU_CHAN_DSL0x07,
                    (chan->fxsend.d.level << 24) | chan->loop.end);
      emuxki_write(sc, chano, EMU_CHAN_PSST0x06,
                    (chan->fxsend.c.level << 24) | chan->loop.start);
1248}

1250void
1251emuxki_channel_commit_parms(struct emuxki_channel *chan)
1252{
struct emuxki_voice *voice = chan->voice;
struct emuxki_softc *sc = voice->sc;
u_int32_t start, mapval;
u_int8_t chano = chan->num;

start = chan->loop.start +
(voice->stereo ? 28 : 30) * (voice->b16 + 1);
mapval = DMAADDR(sc->silentpage)((sc->silentpage)->segs[0].ds_addr) << 1 | EMU_CHAN_MAP_PTI_MASK0x00001fff;

mtx_enter(&audio_lock);
emuxki_write(sc, chano, EMU_CHAN_CPF_STEREO(((1) << 24) | ((15) << 16) | (0x00)), voice->stereo);

emuxki_channel_commit_fx(chan);

emuxki_write(sc, chano, EMU_CHAN_CCCA0x08,
(chan->filter.lowpass_resonance_height << 28) |
(chan->filter.interpolation_ROM << 25) |
(voice->b16 ? 0 : EMU_CHAN_CCCA_8BITSELECT0x01000000) | start);
emuxki_write(sc, chano, EMU_CHAN_Z10x05, 0);
emuxki_write(sc, chano, EMU_CHAN_Z20x04, 0);
emuxki_write(sc, chano, EMU_CHAN_MAPA0x0c, mapval);
emuxki_write(sc, chano, EMU_CHAN_MAPB0x0d, mapval);
emuxki_write(sc, chano, EMU_CHAN_CVCF_CURRFILTER(((16) << 24) | ((0) << 16) | (0x02)),
chan->filter.current_cutoff_frequency);
emuxki_write(sc, chano, EMU_CHAN_VTFT_FILTERTARGET(((16) << 24) | ((0) << 16) | (0x03)),
chan->filter.target_cutoff_frequency);
emuxki_write(sc, chano, EMU_CHAN_ATKHLDM0x15,
(chan->modulation.envelope.hold_time << 8) |
chan->modulation.envelope.attack_time);
emuxki_write(sc, chano, EMU_CHAN_DCYSUSM0x16,
(chan->modulation.envelope.sustain_level << 8) |
chan->modulation.envelope.decay_time);
emuxki_write(sc, chano, EMU_CHAN_LFOVAL10x13,
chan->modulation.LFO_state);
emuxki_write(sc, chano, EMU_CHAN_LFOVAL20x17,
chan->vibrato_LFO.state);
emuxki_write(sc, chano, EMU_CHAN_FMMOD0x1b,
(chan->vibrato_LFO.modulation_depth << 8) |
chan->filter.LFO_modulation_depth);
emuxki_write(sc, chano, EMU_CHAN_TREMFRQ0x1c,
(chan->tremolo_depth << 8));
emuxki_write(sc, chano, EMU_CHAN_FM2FRQ20x1d,
(chan->vibrato_LFO.vibrato_depth << 8) |
chan->vibrato_LFO.frequency);
emuxki_write(sc, chano, EMU_CHAN_ENVVAL0x14,
chan->modulation.envelope.current_state);
emuxki_write(sc, chano, EMU_CHAN_ATKHLDV0x11,
(chan->volume.envelope.hold_time << 8) |
chan->volume.envelope.attack_time);
emuxki_write(sc, chano, EMU_CHAN_ENVVOL0x10,
chan->volume.envelope.current_state);
emuxki_write(sc, chano, EMU_CHAN_PEFE0x1a,
(chan->pitch.envelope_amount << 8) |
chan->filter.envelope_amount);
mtx_leave(&audio_lock);
1308}

1310void
1311emuxki_channel_start(struct emuxki_channel *chan)
1312{
struct emuxki_voice *voice = chan->voice;
struct emuxki_softc *sc = voice->sc;
u_int8_t        cache_sample, cache_invalid_size, chano = chan->num;
u_int32_t       sample;

cache_sample = voice->stereo ? 4 : 2;
sample = voice->b16 ? 0x00000000 : 0x80808080;
cache_invalid_size = (voice->stereo ? 28 : 30) * (voice->b16 + 1);

while (cache_sample--) {
emuxki_write(sc, chano, EMU_CHAN_CD00x20 + cache_sample,
	sample);
}
emuxki_write(sc, chano, EMU_CHAN_CCR_CACHEINVALIDSIZE(((7) << 24) | ((25) << 16) | (0x09)), 0);
emuxki_write(sc, chano, EMU_CHAN_CCR_READADDRESS(((6) << 24) | ((16) << 16) | (0x09)), 64);
emuxki_write(sc, chano, EMU_CHAN_CCR_CACHEINVALIDSIZE(((7) << 24) | ((25) << 16) | (0x09)),
cache_invalid_size);
emuxki_write(sc, chano, EMU_CHAN_IFATN0x19,
(chan->filter.target_cutoff_frequency << 8) |
chan->initial_attenuation);
emuxki_write(sc, chano, EMU_CHAN_VTFT_VOLUMETARGET(((16) << 24) | ((16) << 16) | (0x03)),
chan->volume.target);
emuxki_write(sc, chano, EMU_CHAN_CVCF_CURRVOL(((16) << 24) | ((16) << 16) | (0x02)),
chan->volume.current);
emuxki_write(sc, 0,
EMU_MKSUBREG(1, chano, EMU_SOLEL + (chano >> 5))(((1) << 24) | ((chano) << 16) | (0x5c + (chano >>
 5))),
0);	/* Clear stop on loop */
emuxki_write(sc, 0,
EMU_MKSUBREG(1, chano, EMU_CLIEL + (chano >> 5))(((1) << 24) | ((chano) << 16) | (0x58 + (chano >>
 5))),
0);	/* Clear loop interrupt */
emuxki_write(sc, chano, EMU_CHAN_DCYSUSV0x12,
(chan->volume.envelope.sustain_level << 8) |
chan->volume.envelope.decay_time);
emuxki_write(sc, chano, EMU_CHAN_PTRX_PITCHTARGET(((16) << 24) | ((16) << 16) | (0x01)),
chan->pitch.target);
emuxki_write(sc, chano, EMU_CHAN_CPF_PITCH(((16) << 24) | ((16) << 16) | (0x00)),
chan->pitch.current);
emuxki_write(sc, chano, EMU_CHAN_IP0x18, chan->pitch.initial);
1351}

1353void
1354emuxki_channel_stop(struct emuxki_channel *chan)
1355{
u_int8_t chano = chan->num;
struct emuxki_softc *sc = chan->voice->sc;

emuxki_write(sc, chano, EMU_CHAN_PTRX_PITCHTARGET(((16) << 24) | ((16) << 16) | (0x01)), 0);
emuxki_write(sc, chano, EMU_CHAN_CPF_PITCH(((16) << 24) | ((16) << 16) | (0x00)), 0);
emuxki_write(sc, chano, EMU_CHAN_IFATN_ATTENUATION(((8) << 24) | ((0) << 16) | (0x19)), 0xff);
emuxki_write(sc, chano, EMU_CHAN_VTFT_VOLUMETARGET(((16) << 24) | ((16) << 16) | (0x03)), 0);
emuxki_write(sc, chano, EMU_CHAN_CVCF_CURRVOL(((16) << 24) | ((16) << 16) | (0x02)), 0);
emuxki_write(sc, chano, EMU_CHAN_IP0x18, 0);
1365}

1367/*
* Voices management
* emuxki_voice_dataloc : use(play or rec) independent dataloc union helpers
* emuxki_voice_channel_* : play part of dataloc union helpers
* emuxki_voice_recsrc_* : rec part of dataloc union helpers
*/

1374/* Allocate channels for voice in case of play voice */
1375int
1376emuxki_voice_channel_create(struct emuxki_voice *voice)
1377{
struct emuxki_channel **channel = voice->sc->channel;
u_int8_t i, stereo = voice->stereo;

for (i = 0; i < EMU_NUMCHAN64; i += stereo + 1) {
if ((stereo && (channel[i + 1] != NULL((void *)0))) ||
    (channel[i] != NULL((void *)0)))	/* Looking for free channels */
	continue;
if (stereo) {
	voice->dataloc.chan[1] =
		emuxki_channel_new(voice, i + 1);
	if (voice->dataloc.chan[1] == NULL((void *)0)) {
		return (ENOMEM12);
	}
}
voice->dataloc.chan[0] = emuxki_channel_new(voice, i);
if (voice->dataloc.chan[0] == NULL((void *)0)) {
	if (stereo) {
		emuxki_channel_delete(voice->dataloc.chan[1]);
		voice->dataloc.chan[1] = NULL((void *)0);
	}
	return (ENOMEM12);
}
return (0);
}
return (EAGAIN35);
1403}

1405/* When calling this function we assume no one can access the voice */
1406void
1407emuxki_voice_channel_destroy(struct emuxki_voice *voice)
1408{
emuxki_channel_delete(voice->dataloc.chan[0]);
voice->dataloc.chan[0] = NULL((void *)0);
if (voice->stereo)
emuxki_channel_delete(voice->dataloc.chan[1]);
voice->dataloc.chan[1] = NULL((void *)0);
1414}

1416/*
* Will come back when used in voice_dataloc_create
*/
1419int
1420emuxki_recsrc_reserve(struct emuxki_voice *voice, emuxki_recsrc_t source)
1421{
if (source >= EMU_NUMRECSRCS3) {
1423#ifdef EMUXKI_DEBUG
printf("Tried to reserve invalid source: %d\n", source);
1425#endif
return (EINVAL22);
}
if (voice->sc->recsrc[source] == voice)
return (0);			/* XXX */
if (voice->sc->recsrc[source] != NULL((void *)0))
return (EBUSY16);
voice->sc->recsrc[source] = voice;
return (0);
1434}

1436/* When calling this function we assume the voice is stopped */
1437void
1438emuxki_voice_recsrc_release(struct emuxki_softc *sc, emuxki_recsrc_t source)
1439{
sc->recsrc[source] = NULL((void *)0);
1441}

1443int
1444emuxki_voice_dataloc_create(struct emuxki_voice *voice)
1445{
int             error;

if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
if ((error = emuxki_voice_channel_create(voice)))
	return (error);
} else {
if ((error =
    emuxki_recsrc_reserve(voice, voice->dataloc.source)))
	return (error);
}
return (0);
1457}

1459void
1460emuxki_voice_dataloc_destroy(struct emuxki_voice *voice)
1461{
if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
if (voice->dataloc.chan[0] != NULL((void *)0))
	emuxki_voice_channel_destroy(voice);
} else {
if (voice->dataloc.source != EMU_RECSRC_NOTSET) {
	emuxki_voice_recsrc_release(voice->sc,
				     voice->dataloc.source);
	voice->dataloc.source = EMU_RECSRC_NOTSET;
}
}
1472}

1474struct emuxki_voice *
1475emuxki_voice_new(struct emuxki_softc *sc, u_int8_t use)
1476{
struct emuxki_voice *voice;

mtx_enter(&audio_lock);
voice = sc->lvoice;
sc->lvoice = NULL((void *)0);
mtx_leave(&audio_lock);

if (!voice) {
if (!(voice = malloc(sizeof(*voice), M_DEVBUF2, M_WAITOK0x0001)))
	return (NULL((void *)0));
} else if (voice->use != use) 
emuxki_voice_dataloc_destroy(voice);
else
goto skip_initialize;

voice->sc = sc;
voice->state = 0;
voice->stereo = EMU_VOICE_STEREO_NOTSET0xFF;
voice->b16 = 0;
voice->sample_rate = 0;
if (use & EMU_VOICE_USE_PLAY(1 << 0))
voice->dataloc.chan[0] = voice->dataloc.chan[1] = NULL((void *)0);
else
voice->dataloc.source = EMU_RECSRC_NOTSET;
voice->buffer = NULL((void *)0);
voice->blksize = 0;
voice->trigblk = 0;
voice->blkmod = 0;
voice->inth = NULL((void *)0);
voice->inthparam = NULL((void *)0);
voice->use = use;

1509skip_initialize:
mtx_enter(&audio_lock);
LIST_INSERT_HEAD((&sc->voices), voice, next)do { if (((voice)->next.le_next = ((&sc->voices))->
lh_first) != ((void *)0)) ((&sc->voices))->lh_first
->next.le_prev = &(voice)->next.le_next; ((&sc->
voices))->lh_first = (voice); (voice)->next.le_prev = &
((&sc->voices))->lh_first; } while (0);
mtx_leave(&audio_lock);

return (voice);
1515}

1517void
1518emuxki_voice_delete(struct emuxki_voice *voice)
1519{
struct emuxki_softc *sc = voice->sc;
struct emuxki_voice *lvoice;

if (voice->state & EMU_VOICE_STATE_STARTED(1 << 0))
emuxki_voice_halt(voice);

mtx_enter(&audio_lock);
LIST_REMOVE(voice, next)do { if ((voice)->next.le_next != ((void *)0)) (voice)->
next.le_next->next.le_prev = (voice)->next.le_prev; *(voice
)->next.le_prev = (voice)->next.le_next; ((voice)->next
.le_prev) = ((void *)-1); ((voice)->next.le_next) = ((void
 *)-1); } while (0);
lvoice = sc->lvoice;
sc->lvoice = voice;
mtx_leave(&audio_lock);

if (lvoice) {
emuxki_voice_dataloc_destroy(lvoice);
free(lvoice, M_DEVBUF2, 0);
}
1536}

1538int
1539emuxki_voice_set_stereo(struct emuxki_voice *voice, u_int8_t stereo)
1540{
int	error;
emuxki_recsrc_t source = 0; /* XXX: gcc */
struct emuxki_chanparms_fxsend fxsend;

if (! (voice->use & EMU_VOICE_USE_PLAY(1 << 0)))
source = voice->dataloc.source;
emuxki_voice_dataloc_destroy(voice);
if (! (voice->use & EMU_VOICE_USE_PLAY(1 << 0)))
voice->dataloc.source = source;
voice->stereo = stereo;
if ((error = emuxki_voice_dataloc_create(voice)))
 return (error);
if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
fxsend.a.dest = 0x0;
fxsend.b.dest = 0x1;
fxsend.c.dest = 0x2;
fxsend.d.dest = 0x3;
/* for audigy */
fxsend.e.dest = 0x4;
fxsend.f.dest = 0x5;
fxsend.g.dest = 0x6;
fxsend.h.dest = 0x7;
if (voice->stereo) {
	fxsend.a.level = fxsend.c.level = 0xc0;
	fxsend.b.level = fxsend.d.level = 0x00;
	fxsend.e.level = fxsend.g.level = 0xc0;
	fxsend.f.level = fxsend.h.level = 0x00;
	emuxki_channel_set_fxsend(voice->dataloc.chan[0],
				   &fxsend);
	fxsend.a.level = fxsend.c.level = 0x00;
	fxsend.b.level = fxsend.d.level = 0xc0;
	fxsend.e.level = fxsend.g.level = 0x00;
	fxsend.f.level = fxsend.h.level = 0xc0;
	emuxki_channel_set_fxsend(voice->dataloc.chan[1],
				   &fxsend);
} /* No else : default is good for mono */	
}
return (0);
1579}

1581int
1582emuxki_voice_set_srate(struct emuxki_voice *voice, u_int32_t srate)
1583{
if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
if (srate < 4000)
	srate = 4000;
if (srate > 48000)
	srate = 48000;
voice->sample_rate = srate;
emuxki_channel_set_srate(voice->dataloc.chan[0], srate);
if (voice->stereo)
	emuxki_channel_set_srate(voice->dataloc.chan[1],
				  srate);
} else {
if (srate < 8000)
	srate = 8000;
if (srate > 48000)
	srate = 48000;
voice->sample_rate = srate;
if (emuxki_voice_adc_rate(voice) < 0) {
	voice->sample_rate = 0;
	return (EINVAL22);
}
}
return (0);
1606}

1608int
1609emuxki_voice_set_audioparms(struct emuxki_voice *voice, u_int8_t stereo,
	     u_int8_t b16, u_int32_t srate)
1611{
int             error = 0;

/*
* Audio driver tried to set recording AND playing params even if
* device opened in play or record only mode ==>
* modified emuxki_set_params.
* Stays here for now just in case ...
*/
if (voice == NULL((void *)0)) {
1621#ifdef EMUXKI_DEBUG
printf("warning: tried to set unallocated voice params !!\n");
1623#endif
return (0);
}

if (voice->stereo == stereo && voice->b16 == b16 &&
   voice->sample_rate == srate)
return (0);

1631#ifdef EMUXKI_DEBUG
printf("Setting %s voice params : %s, %u bits, %u hz\n",
      (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) ? "play" : "record",
      stereo ? "stereo" : "mono", (b16 + 1) * 8, srate);
1635#endif

voice->b16 = b16;

/* sample rate must be set after any channel number changes */ 
if ((voice->stereo != stereo) || (voice->sample_rate != srate)) {
if (voice->stereo != stereo) {
	if ((error = emuxki_voice_set_stereo(voice, stereo)))
		return (error);
}
error = emuxki_voice_set_srate(voice, srate);
}
return error;
1648}

1650/* voice audio parms (see just before) must be set prior to this */
1651int
1652emuxki_voice_set_bufparms(struct emuxki_voice *voice, void *ptr,
	   u_int32_t bufsize, u_int16_t blksize)
1654{
struct emuxki_mem *mem;
struct emuxki_channel **chan;
u_int32_t start, end;
u_int8_t sample_size;
int idx;
int error = EFAULT14;

LIST_FOREACH(mem, &voice->sc->mem, next)for((mem) = ((&voice->sc->mem)->lh_first); (mem)
!= ((void *)0); (mem) = ((mem)->next.le_next)) {
if (KERNADDR(mem->dmamem)((void *)((mem->dmamem)->kaddr)) != ptr)
	continue;

voice->buffer = mem;
sample_size = (voice->b16 + 1) * (voice->stereo + 1);
voice->trigblk = 0;	/* This shouldn't be needed */
voice->blkmod = bufsize / blksize;
if (bufsize % blksize) 	  /* This should not happen */
	voice->blkmod++;
error = 0;

if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
	voice->blksize = blksize / sample_size;
	chan = voice->dataloc.chan;
	start = (mem->ptbidx << 12) / sample_size;
	end = start + bufsize / sample_size;
	emuxki_channel_set_bufparms(chan[0],
				     start, end);
	if (voice->stereo)
		emuxki_channel_set_bufparms(chan[1],
		     start, end);
	voice->timerate = (u_int32_t) 48000 *
	                voice->blksize / voice->sample_rate;
	if (voice->timerate < 5)
		error = EINVAL22;
} else {
	voice->blksize = blksize;
	for(idx = sizeof(emuxki_recbuf_sz) /
	    sizeof(emuxki_recbuf_sz[0]); --idx >= 0;)
		if (emuxki_recbuf_sz[idx] == bufsize)
			break;
	if (idx < 0) {
1695#ifdef EMUXKI_DEBUG
		printf("Invalid bufsize: %d\n", bufsize);
1697#endif
		return (EINVAL22);
	}
	mtx_enter(&audio_lock);
	emuxki_write(voice->sc, 0,
	    emuxki_recsrc_szreg[voice->dataloc.source], idx);
	emuxki_write(voice->sc, 0,
	    emuxki_recsrc_bufaddrreg[voice->dataloc.source],
	    DMAADDR(mem->dmamem)((mem->dmamem)->segs[0].ds_addr));
	mtx_leave(&audio_lock);
	/* Use timer to emulate DMA completion interrupt */
	voice->timerate = (u_int32_t) 48000 * blksize /
	    (voice->sample_rate * sample_size);
	if (voice->timerate < 5) {
1711#ifdef EMUXKI_DEBUG
		printf("Invalid timerate: %d, blksize %d\n",
		    voice->timerate, blksize);
1714#endif
		error = EINVAL22;
	}
}

break;
}

return (error);
1723}

1725void
1726emuxki_voice_commit_parms(struct emuxki_voice *voice)
1727{
if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
emuxki_channel_commit_parms(voice->dataloc.chan[0]);
if (voice->stereo)
	emuxki_channel_commit_parms(voice->dataloc.chan[1]);
}
1733}

1735u_int32_t
1736emuxki_voice_curaddr(struct emuxki_voice *voice)
1737{
int idxreg = 0;

/* XXX different semantics in these cases */
if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
/* returns number of samples (an l/r pair counts 1) */
return (emuxki_read(voice->sc,
		     voice->dataloc.chan[0]->num,
		     EMU_CHAN_CCCA_CURRADDR(((24) << 24) | ((0) << 16) | (0x08))) -
	voice->dataloc.chan[0]->loop.start);
} else {
/* returns number of bytes */
switch (voice->dataloc.source) {
	case EMU_RECSRC_MIC:
		idxreg = (voice->sc->sc_flags & EMUXKI_AUDIGY0x0002) ?
			EMU_A_MICIDX0x64 : EMU_MICIDX0x63;
		break;
	case EMU_RECSRC_ADC:
		idxreg = (voice->sc->sc_flags & EMUXKI_AUDIGY0x0002) ?
			EMU_A_ADCIDX0x63 : EMU_ADCIDX0x64;
		break;
	case EMU_RECSRC_FX:
		idxreg = EMU_FXIDX0x65;
		break;
	default:
1762#ifdef EMUXKI_DEBUG
		printf("emu: bad recording source!\n");
1764#endif
		break;
}
return (emuxki_read(voice->sc, 0, EMU_RECIDX(idxreg)(0x10000000|(idxreg)))
		& EMU_RECIDX_MASK0x0000ffff);
}
return (0);
1771}

1773void
1774emuxki_resched_timer(struct emuxki_softc *sc)
1775{
struct emuxki_voice *voice;
u_int16_t       timerate = 1024;
u_int8_t	active = 0;

LIST_FOREACH(voice, &sc->voices, next)for((voice) = ((&sc->voices)->lh_first); (voice)!= (
(void *)0); (voice) = ((voice)->next.le_next)) {
if ((voice->state & EMU_VOICE_STATE_STARTED(1 << 0)) == 0)
	continue;
active = 1;
if (voice->timerate < timerate)
	timerate = voice->timerate;
}

if (timerate & ~EMU_TIMER_RATE_MASK0x000003ff)
timerate = 0;
bus_space_write_2(sc->sc_iot, sc->sc_ioh, EMU_TIMER, timerate)((sc->sc_iot)->write_2((sc->sc_ioh), (0x1a), (timerate
)));
if (!active && (sc->timerstate & EMU_TIMER_STATE_ENABLED1)) {
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE,((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) & ~0x00000004
)))
	bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_INTE) &((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) & ~0x00000004
)))
	~EMU_INTE_INTERTIMERENB)((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) & ~0x00000004
)));
sc->timerstate &= ~EMU_TIMER_STATE_ENABLED1;
} else if (active && !(sc->timerstate & EMU_TIMER_STATE_ENABLED1)) {
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_INTE,((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) | 0x00000004)))
	bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_INTE) |((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) | 0x00000004)))
	EMU_INTE_INTERTIMERENB)((sc->sc_iot)->write_4((sc->sc_ioh), (0x0c), (((sc->
sc_iot)->read_4((sc->sc_ioh), (0x0c))) | 0x00000004)));
sc->timerstate |= EMU_TIMER_STATE_ENABLED1;
}
1802}

1804int
1805emuxki_voice_adc_rate(struct emuxki_voice *voice)
1806{
switch(voice->sample_rate) {
case 48000:
	return EMU_ADCCR_SAMPLERATE_480x00000000;
	break;
case 44100:
	return EMU_ADCCR_SAMPLERATE_440x00000001;
	break;
case 32000:
	return EMU_ADCCR_SAMPLERATE_320x00000002;
	break;
case 24000:
	return EMU_ADCCR_SAMPLERATE_240x00000003;
	break;
case 22050:
	return EMU_ADCCR_SAMPLERATE_220x00000004;
	break;
case 16000:
	return EMU_ADCCR_SAMPLERATE_160x00000005;
	break;
case 12000:
	if (voice->sc->sc_flags & EMUXKI_AUDIGY0x0002)
		return EMU_A_ADCCR_SAMPLERATE_120x00000006;
	else {
1830#ifdef EMUXKI_DEBUG
		printf("recording sample_rate not supported : %u\n", voice->sample_rate);
1832#endif
		return (-1);
	}
	break;
case 11000:
	if (voice->sc->sc_flags & EMUXKI_AUDIGY0x0002)
		return EMU_A_ADCCR_SAMPLERATE_110x00000007;
	else
		return EMU_ADCCR_SAMPLERATE_110x00000006;
	break;
case 8000:
	if (voice->sc->sc_flags & EMUXKI_AUDIGY0x0002)
		return EMU_A_ADCCR_SAMPLERATE_80x00000008;
	else
		return EMU_ADCCR_SAMPLERATE_80x00000007;
	break;
default:
1849#ifdef EMUXKI_DEBUG
		printf("recording sample_rate not supported : %u\n", voice->sample_rate);
1851#endif
		return (-1);
}
return (-1);  /* shouldn't get here */
1855}

1857void
1858emuxki_voice_start(struct emuxki_voice *voice,
    void (*inth) (void *), void *inthparam)
1860{
u_int32_t val;

mtx_enter(&audio_lock);
voice->inth = inth;
voice->inthparam = inthparam;
if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
voice->trigblk = 1;
emuxki_channel_start(voice->dataloc.chan[0]);
if (voice->stereo)
	emuxki_channel_start(voice->dataloc.chan[1]);
} else {
voice->trigblk = 1;
switch (voice->dataloc.source) {
case EMU_RECSRC_ADC:
	/* XXX need to program DSP to output L+R
	 * XXX in monaural case? */
	if (voice->sc->sc_flags & EMUXKI_AUDIGY0x0002) {
		val = EMU_A_ADCCR_LCHANENABLE0x00000010;
		if (voice->stereo)
			val |= EMU_A_ADCCR_RCHANENABLE0x00000020;
	} else {
		val = EMU_ADCCR_LCHANENABLE0x00000008;
		if (voice->stereo)
			val |= EMU_ADCCR_RCHANENABLE0x00000010;
	}
	val |= emuxki_voice_adc_rate(voice);
	emuxki_write(voice->sc, 0, EMU_ADCCR0x42, 0);
	emuxki_write(voice->sc, 0, EMU_ADCCR0x42, val);
	break;
case EMU_RECSRC_MIC:
case EMU_RECSRC_FX:
	printf("unimplemented\n");
	break;
case EMU_RECSRC_NOTSET:
default:
	break;
}
1898#if 0
/* DMA completion interrupt is useless; use timer */
val = emu_rd(sc, INTE, 4);
val |= emuxki_recsrc_intrmasks[voice->dataloc.source];
emu_wr(sc, INTE, val, 4);
1903#endif
}
voice->state |= EMU_VOICE_STATE_STARTED(1 << 0);
emuxki_resched_timer(voice->sc);
mtx_leave(&audio_lock);
1908}

1910void
1911emuxki_voice_halt(struct emuxki_voice *voice)
1912{
mtx_enter(&audio_lock);
if (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
emuxki_channel_stop(voice->dataloc.chan[0]);
if (voice->stereo)
	emuxki_channel_stop(voice->dataloc.chan[1]);
} else {
switch (voice->dataloc.source) {
6
←
Control jumps to 'case EMU_RECSRC_NOTSET:'  at line 1927→
case EMU_RECSRC_ADC:
	emuxki_write(voice->sc, 0, EMU_ADCCR0x42, 0);
	break;
case EMU_RECSRC_FX:
case EMU_RECSRC_MIC:
	printf("unimplemented\n");
	break;
case EMU_RECSRC_NOTSET:
	printf("Bad dataloc.source\n");
}
/* This should reset buffer pointer */
emuxki_write(voice->sc, 0,
7
←
3rd function call argument is an uninitialized value
    emuxki_recsrc_szreg[voice->dataloc.source],
    EMU_RECBS_BUFSIZE_NONE0x00000000);
1934#if 0
val = emu_rd(sc, INTE, 4);
val &= ~emuxki_recsrc_intrmasks[voice->dataloc.source];
emu_wr(sc, INTE, val, 4);
1938#endif
}
voice->state &= ~EMU_VOICE_STATE_STARTED(1 << 0);
emuxki_resched_timer(voice->sc);
mtx_leave(&audio_lock);
1943}

1945/*
* The interrupt handler
*/
1948int
1949emuxki_intr(void *arg)
1950{
struct emuxki_softc *sc = arg;
u_int32_t       ipr, curblk, us = 0;
struct emuxki_voice *voice;

mtx_enter(&audio_lock);
while ((ipr = bus_space_read_4(sc->sc_iot, sc->sc_ioh, EMU_IPR)((sc->sc_iot)->read_4((sc->sc_ioh), (0x08))))) {
if (ipr & EMU_IPR_INTERVALTIMER0x00000200) {
	LIST_FOREACH(voice, &sc->voices, next)for((voice) = ((&sc->voices)->lh_first); (voice)!= (
(void *)0); (voice) = ((voice)->next.le_next)) {
		if ((voice->state &
		      EMU_VOICE_STATE_STARTED(1 << 0)) == 0)
			continue;

		curblk = emuxki_voice_curaddr(voice) /
		       voice->blksize;
1965#if 0
		if (curblk == voice->trigblk) {
			voice->inth(voice->inthparam);
			voice->trigblk++;
			voice->trigblk %= voice->blkmod;
		}
1971#else
		while ((curblk >= voice->trigblk &&
		    curblk < (voice->trigblk + voice->blkmod / 2)) ||
		    ((int)voice->trigblk - (int)curblk) >
		    (voice->blkmod / 2 + 1)) {
			voice->inth(voice->inthparam);
			voice->trigblk++;
			voice->trigblk %= voice->blkmod;
		}
1980#endif
	}
	us = 1;
}

/* Got interrupt */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, EMU_IPR, ipr)((sc->sc_iot)->write_4((sc->sc_ioh), (0x08), (ipr)));
}
mtx_leave(&audio_lock);
return (us);
1990}


1993/*
* Audio Architecture callbacks
*/

1997int
1998emuxki_open(void *addr, int flags)
1999{
struct emuxki_softc *sc = addr;

2002#ifdef EMUXKI_DEBUG
printf("%s: emuxki_open called\n", sc->sc_dev.dv_xname);
2004#endif

/*
* Multiple voice support would be added as soon as I find a way to
* trick the audio arch into supporting multiple voices.
* Or I might integrate a modified audio arch supporting
* multiple voices.
*/

/*
* I did this because i have problems identifying the selected
* recording source(s) which is necessary when setting recording
* params. This will be addressed very soon.
*/
if (flags & FREAD0x0001) {
sc->rvoice = emuxki_voice_new(sc, 0 /* EMU_VOICE_USE_RECORD */);
if (sc->rvoice == NULL((void *)0))
	return (EBUSY16);

/* XXX Hardcode RECSRC_ADC for now */
sc->rvoice->dataloc.source = EMU_RECSRC_ADC;
}

if (flags & FWRITE0x0002) {
sc->pvoice = emuxki_voice_new(sc, EMU_VOICE_USE_PLAY(1 << 0));
if (sc->pvoice == NULL((void *)0)) {
	if (flags & FREAD0x0001)
		emuxki_voice_delete(sc->rvoice);
	return (EBUSY16);
}
}

return (0);
2037}

2039void
2040emuxki_close(void *addr)
2041{
struct emuxki_softc *sc = addr;

2044#ifdef EMUXKI_DEBUG
printf("%s: emu10K1_close called\n", sc->sc_dev.dv_xname);
2046#endif

/* No multiple voice support for now */
if (sc->rvoice != NULL((void *)0))
emuxki_voice_delete(sc->rvoice);
sc->rvoice = NULL((void *)0);
if (sc->pvoice != NULL((void *)0))
emuxki_voice_delete(sc->pvoice);
sc->pvoice = NULL((void *)0);
2055}

2057int
2058emuxki_set_vparms(struct emuxki_voice *voice, struct audio_params *p)
2059{
u_int8_t	b16, mode;

mode = (voice->use & EMU_VOICE_USE_PLAY(1 << 0)) ?
AUMODE_PLAY0x01 : AUMODE_RECORD0x02;
if (p->channels > 2)
p->channels = 2;
if (p->precision > 16)
p->precision = 16;
/* Will change when streams come in use */

/*
* Always use slinear_le for recording, as how to set otherwise
* isn't known.
*/
if (mode == AUMODE_PLAY0x01)
b16 = (p->precision == 16);
else {
b16 = 1;
p->precision = 16;
}

switch (p->encoding) {
case AUDIO_ENCODING_SLINEAR_LE6:
if (p->precision != 16)
	return EINVAL22;
break;

case AUDIO_ENCODING_ULINEAR_LE8:
case AUDIO_ENCODING_ULINEAR_BE9:
if (p->precision != 8)
	return EINVAL22;
break;

default:
return (EINVAL22);
}
p->bps = AUDIO_BPS(p->precision)(p->precision) <= 8 ? 1 : ((p->precision) <= 16 ?
: 4);
p->msb = 1;

return (emuxki_voice_set_audioparms(voice, p->channels == 2,
		     b16, p->sample_rate));
2101}

2103int
2104emuxki_set_params(void *addr, int setmode, int usemode,
   struct audio_params *play, struct audio_params *rec)
2106{
struct emuxki_softc *sc = addr;
int	     mode, error;
struct audio_params *p;

for (mode = AUMODE_RECORD0x02; mode != -1;
    mode = mode == AUMODE_RECORD0x02 ? AUMODE_PLAY0x01 : -1) {
if ((usemode & setmode & mode) == 0)
	continue;

p = (mode == AUMODE_PLAY0x01) ? play : rec;

/* No multiple voice support for now */
if ((error = emuxki_set_vparms((mode == AUMODE_PLAY0x01) ?
				sc->pvoice : sc->rvoice, p)))
	return (error);
}

return (0);
2125}

2127int
2128emuxki_halt_output(void *addr)
2129{
struct emuxki_softc *sc = addr;

/* No multiple voice support for now */
if (sc->pvoice == NULL((void *)0))
return (ENXIO6);

emuxki_voice_halt(sc->pvoice);
return (0);
2138}

2140int
2141emuxki_halt_input(void *addr)
2142{
struct emuxki_softc *sc = addr;

2145#ifdef EMUXKI_DEBUG
printf("%s: emuxki_halt_input called\n", sc->sc_dev.dv_xname);
2147#endif

/* No multiple voice support for now */
if (sc->rvoice == NULL((void *)0))
1
Assuming field 'rvoice' is not equal to NULL→
2
←
Taking false branch→
return (ENXIO6);
emuxki_voice_halt(sc->rvoice);
3
←
Calling 'emuxki_voice_halt'→
return (0);
2154}

2156int
2157emuxki_set_port(void *addr, mixer_ctrl_t *mctl)
2158{
struct emuxki_softc *sc = addr;

return sc->codecif->vtbl->mixer_set_port(sc->codecif, mctl);
2162}

2164int
2165emuxki_get_port(void *addr, mixer_ctrl_t *mctl)
2166{
struct emuxki_softc *sc = addr;

return sc->codecif->vtbl->mixer_get_port(sc->codecif, mctl);
2170}

2172int
2173emuxki_query_devinfo(void *addr, mixer_devinfo_t *minfo)
2174{
struct emuxki_softc *sc = addr;

return sc->codecif->vtbl->query_devinfo(sc->codecif, minfo);
2178}

2180void *
2181emuxki_allocm(void *addr, int direction, size_t size, int type, int flags)
2182{
struct emuxki_softc *sc = addr;

if (direction == AUMODE_PLAY0x01)
return emuxki_pmem_alloc(sc, size, type, flags);
else
return emuxki_rmem_alloc(sc, size, type, flags);
2189}

2191void
2192emuxki_freem(void *addr, void *ptr, int type)
2193{
struct emuxki_softc *sc = addr;
int	     i;
struct emuxki_mem *mem;
size_t	  numblocks;
u_int32_t      *ptb, silentpage;

ptb = KERNADDR(sc->ptb)((void *)((sc->ptb)->kaddr));
silentpage = DMAADDR(sc->silentpage)((sc->silentpage)->segs[0].ds_addr) << 1;
LIST_FOREACH(mem, &sc->mem, next)for((mem) = ((&sc->mem)->lh_first); (mem)!= ((void *
)0); (mem) = ((mem)->next.le_next)) {
if (KERNADDR(mem->dmamem)((void *)((mem->dmamem)->kaddr)) != ptr)
	continue;

mtx_enter(&audio_lock);
if (mem->ptbidx != EMU_RMEM0xFFFF) {
	numblocks = DMASIZE(mem->dmamem)((mem->dmamem)->size) / EMU_PTESIZE4096;
	if (DMASIZE(mem->dmamem)((mem->dmamem)->size) % EMU_PTESIZE4096)
		numblocks++;
	for (i = 0; i < numblocks; i++)
		ptb[mem->ptbidx + i] =
		    htole32(silentpage | (mem->ptbidx + i))((__uint32_t)(silentpage | (mem->ptbidx + i)));
}
LIST_REMOVE(mem, next)do { if ((mem)->next.le_next != ((void *)0)) (mem)->next
.le_next->next.le_prev = (mem)->next.le_prev; *(mem)->
next.le_prev = (mem)->next.le_next; ((mem)->next.le_prev
) = ((void *)-1); ((mem)->next.le_next) = ((void *)-1); } while
 (0);
mtx_leave(&audio_lock);

emuxki_mem_delete(mem, type);
break;
}
2221}

2223/* blocksize should be a divisor of allowable buffersize */
2224/* XXX probably this could be done better */
2225int
2226emuxki_round_blocksize(void *addr, int blksize)
2227{
int bufsize = 65536;

while (bufsize > blksize)
bufsize /= 2;

return bufsize;
2234}

2236size_t
2237emuxki_round_buffersize(void *addr, int direction, size_t bsize)
2238{

if (direction == AUMODE_PLAY0x01) {
if (bsize < EMU_PTESIZE4096)
	bsize = EMU_PTESIZE4096;
else if (bsize > (EMU_PTESIZE4096 * EMU_MAXPTE((0x00ffffff + 1) / 4096)))
	bsize = EMU_PTESIZE4096 * EMU_MAXPTE((0x00ffffff + 1) / 4096);
/* Would be better if set to max available */
else if (bsize % EMU_PTESIZE4096)
	bsize = bsize -
		(bsize % EMU_PTESIZE4096) +
		EMU_PTESIZE4096;
} else {
int idx;

/* find nearest lower recbuf size */
for(idx = sizeof(emuxki_recbuf_sz) /
    sizeof(emuxki_recbuf_sz[0]); --idx >= 0; ) {
	if (bsize >= emuxki_recbuf_sz[idx]) {
		bsize = emuxki_recbuf_sz[idx];
		break;
	}
}

if (bsize == 0)
	bsize = 384;
}

return (bsize);
2267}

2269int
2270emuxki_get_props(void *addr)
2271{
return (AUDIO_PROP_MMAP0x02 | AUDIO_PROP_INDEPENDENT0x04 |
AUDIO_PROP_FULLDUPLEX0x01);
2274}

2276int
2277emuxki_trigger_output(void *addr, void *start, void *end, int blksize,
       void (*inth) (void *), void *inthparam,
       struct audio_params *params)
2280{
struct emuxki_softc *sc = addr;
/* No multiple voice support for now */
struct emuxki_voice *voice = sc->pvoice;
int	     error;

if (voice == NULL((void *)0))
return (ENXIO6);
if ((error = emuxki_set_vparms(voice, params)))
return (error);
if ((error = emuxki_voice_set_bufparms(voice, start,
		(caddr_t)end - (caddr_t)start, blksize)))
return (error);
emuxki_voice_commit_parms(voice);
emuxki_voice_start(voice, inth, inthparam);
return (0);
2296}

2298int
2299emuxki_trigger_input(void *addr, void *start, void *end, int blksize,
      void (*inth) (void *), void *inthparam,
      struct audio_params *params)
2302{
struct emuxki_softc *sc = addr;
/* No multiple voice support for now */
struct emuxki_voice *voice = sc->rvoice;
int	error;

if (voice == NULL((void *)0))
return (ENXIO6);
if ((error = emuxki_set_vparms(voice, params)))
return (error);
if ((error = emuxki_voice_set_bufparms(voice, start,
				(caddr_t)end - (caddr_t)start,
				blksize)))
return (error);
emuxki_voice_start(voice, inth, inthparam);
return (0);
2318}


2321/*
* AC97 callbacks
*/

2325int
2326emuxki_ac97_attach(void *arg, struct ac97_codec_if *codecif)
2327{
struct emuxki_softc *sc = arg;

sc->codecif = codecif;
return (0);
2332}

2334int
2335emuxki_ac97_read(void *arg, u_int8_t reg, u_int16_t *val)
2336{
struct emuxki_softc *sc = arg;

mtx_enter(&audio_lock);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, EMU_AC97ADDR, reg)((sc->sc_iot)->write_1((sc->sc_ioh), (0x1e), (reg)));
*val = bus_space_read_2(sc->sc_iot, sc->sc_ioh, EMU_AC97DATA)((sc->sc_iot)->read_2((sc->sc_ioh), (0x1c)));
mtx_leave(&audio_lock);

return (0);
2345}

2347int
2348emuxki_ac97_write(void *arg, u_int8_t reg, u_int16_t val)
2349{
struct emuxki_softc *sc = arg;

mtx_enter(&audio_lock);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, EMU_AC97ADDR, reg)((sc->sc_iot)->write_1((sc->sc_ioh), (0x1e), (reg)));
bus_space_write_2(sc->sc_iot, sc->sc_ioh, EMU_AC97DATA, val)((sc->sc_iot)->write_2((sc->sc_ioh), (0x1c), (val)));
mtx_leave(&audio_lock);

return (0);
2358}

2360void
2361emuxki_ac97_reset(void *arg)
2362{
2363}