xref: /freebsd/sys/dev/sound/pci/emu10kx.c (revision 39beb93c3f8bdbf72a61fda42300b5ebed7390c8)
1 /*-
2  * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
3  * Copyright (c) 2003-2007 Yuriy Tsibizov <yuriy.tsibizov@gfk.ru>
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  *
27  * $FreeBSD$
28  */
29 
30 #include <sys/param.h>
31 #include <sys/types.h>
32 #include <sys/bus.h>
33 #include <machine/bus.h>
34 #include <sys/rman.h>
35 #include <sys/systm.h>
36 #include <sys/sbuf.h>
37 #include <sys/queue.h>
38 #include <sys/lock.h>
39 #include <sys/mutex.h>
40 #include <sys/sysctl.h>
41 #include <sys/kdb.h>
42 
43 #include <dev/pci/pcireg.h>
44 #include <dev/pci/pcivar.h>
45 
46 #include <machine/clock.h>	/* for DELAY */
47 
48 #include <dev/sound/chip.h>
49 #include <dev/sound/pcm/sound.h>
50 #include <dev/sound/pcm/ac97.h>
51 
52 #include <dev/sound/pci/emu10kx.h>
53 
54 /* hw flags */
55 #define	HAS_51		0x0001
56 #define	HAS_71		0x0002
57 #define	HAS_AC97	0x0004
58 
59 #define	IS_EMU10K1	0x0008
60 #define	IS_EMU10K2	0x0010
61 #define	IS_CA0102	0x0020
62 #define	IS_CA0108	0x0040
63 #define	IS_UNKNOWN	0x0080
64 
65 #define	BROKEN_DIGITAL	0x0100
66 #define	DIGITAL_ONLY	0x0200
67 
68 #define	IS_CARDBUS	0x0400
69 
70 #define	MODE_ANALOG	1
71 #define	MODE_DIGITAL	2
72 #define	SPDIF_MODE_PCM	1
73 #define	SPDIF_MODE_AC3	2
74 
75 #define	MACS	0x0
76 #define	MACS1	0x1
77 #define	MACW	0x2
78 #define	MACW1	0x3
79 #define	MACINTS	0x4
80 #define	MACINTW	0x5
81 #define	ACC3	0x6
82 #define	MACMV	0x7
83 #define	ANDXOR	0x8
84 #define	TSTNEG	0x9
85 #define	LIMIT	0xA
86 #define	LIMIT1	0xB
87 #define	LOG	0xC
88 #define	EXP	0xD
89 #define	INTERP	0xE
90 #define	SKIP	0xF
91 
92 #define	GPR(i)	(sc->gpr_base+(i))
93 #define	INP(i)	(sc->input_base+(i))
94 #define	OUTP(i)	(sc->output_base+(i))
95 #define	FX(i)	(i)
96 #define	FX2(i)	(sc->efxc_base+(i))
97 #define	DSP_CONST(i) (sc->dsp_zero+(i))
98 
99 #define	COND_NORMALIZED	DSP_CONST(0x1)
100 #define	COND_BORROW	DSP_CONST(0x2)
101 #define	COND_MINUS	DSP_CONST(0x3)
102 #define	COND_LESS_ZERO	DSP_CONST(0x4)
103 #define	COND_EQ_ZERO	DSP_CONST(0x5)
104 #define	COND_SATURATION	DSP_CONST(0x6)
105 #define	COND_NEQ_ZERO	DSP_CONST(0x8)
106 
107 #define	DSP_ACCUM	DSP_CONST(0x16)
108 #define	DSP_CCR		DSP_CONST(0x17)
109 
110 /* Live! Inputs */
111 #define	IN_AC97_L 	0x00
112 #define	IN_AC97_R 	0x01
113 #define	IN_AC97		IN_AC97_L
114 #define	IN_SPDIF_CD_L	0x02
115 #define	IN_SPDIF_CD_R	0x03
116 #define	IN_SPDIF_CD	IN_SPDIF_CD_L
117 #define	IN_ZOOM_L 	0x04
118 #define	IN_ZOOM_R 	0x05
119 #define	IN_ZOOM		IN_ZOOM_L
120 #define	IN_TOSLINK_L	0x06
121 #define	IN_TOSLINK_R	0x07
122 #define	IN_TOSLINK	IN_TOSLINK_L
123 #define	IN_LINE1_L	0x08
124 #define	IN_LINE1_R	0x09
125 #define	IN_LINE1	IN_LINE1_L
126 #define	IN_COAX_SPDIF_L	0x0a
127 #define	IN_COAX_SPDIF_R	0x0b
128 #define	IN_COAX_SPDIF	IN_COAX_SPDIF_L
129 #define	IN_LINE2_L	0x0c
130 #define	IN_LINE2_R	0x0d
131 #define	IN_LINE2	IN_LINE2_L
132 #define	IN_0E		0x0e
133 #define	IN_0F		0x0f
134 
135 /* Outputs */
136 #define	OUT_AC97_L	0x00
137 #define	OUT_AC97_R	0x01
138 #define	OUT_AC97	OUT_AC97_L
139 #define	OUT_A_FRONT	OUT_AC97
140 #define	OUT_TOSLINK_L 	0x02
141 #define	OUT_TOSLINK_R 	0x03
142 #define	OUT_TOSLINK	OUT_TOSLINK_L
143 #define	OUT_D_CENTER	0x04
144 #define	OUT_D_SUB	0x05
145 #define	OUT_HEADPHONE_L	0x06
146 #define	OUT_HEADPHONE_R	0x07
147 #define	OUT_HEADPHONE	OUT_HEADPHONE_L
148 #define	OUT_REAR_L	0x08
149 #define	OUT_REAR_R	0x09
150 #define	OUT_REAR	OUT_REAR_L
151 #define	OUT_ADC_REC_L 	0x0a
152 #define	OUT_ADC_REC_R	0x0b
153 #define	OUT_ADC_REC	OUT_ADC_REC_L
154 #define	OUT_MIC_CAP	0x0c
155 
156 /* Live! 5.1 Digital, non-standart 5.1 (center & sub) outputs */
157 #define	OUT_A_CENTER	0x11
158 #define	OUT_A_SUB	0x12
159 
160 /* Audigy Inputs */
161 #define	A_IN_AC97_L	0x00
162 #define	A_IN_AC97_R	0x01
163 #define	A_IN_AC97	A_IN_AC97_L
164 #define	A_IN_SPDIF_CD_L	0x02
165 #define	A_IN_SPDIF_CD_R	0x03
166 #define	A_IN_SPDIF_CD	A_IN_SPDIF_CD_L
167 #define	A_IN_O_SPDIF_L	0x04
168 #define	A_IN_O_SPDIF_R	0x05
169 #define	A_IN_O_SPDIF	A_IN_O_SPDIF_L
170 #define	A_IN_LINE2_L	0x08
171 #define	A_IN_LINE2_R	0x09
172 #define	A_IN_LINE2	A_IN_LINE2_L
173 #define	A_IN_R_SPDIF_L	0x0a
174 #define	A_IN_R_SPDIF_R	0x0b
175 #define	A_IN_R_SPDIF	A_IN_R_SPDIF_L
176 #define	A_IN_AUX2_L	0x0c
177 #define	A_IN_AUX2_R	0x0d
178 #define	A_IN_AUX2	A_IN_AUX2_L
179 
180 /* Audigiy Outputs */
181 #define	A_OUT_D_FRONT_L	0x00
182 #define	A_OUT_D_FRONT_R	0x01
183 #define	A_OUT_D_FRONT	A_OUT_D_FRONT_L
184 #define	A_OUT_D_CENTER	0x02
185 #define	A_OUT_D_SUB	0x03
186 #define	A_OUT_D_SIDE_L	0x04
187 #define	A_OUT_D_SIDE_R	0x05
188 #define	A_OUT_D_SIDE	A_OUT_D_SIDE_L
189 #define	A_OUT_D_REAR_L	0x06
190 #define	A_OUT_D_REAR_R	0x07
191 #define	A_OUT_D_REAR	A_OUT_D_REAR_L
192 
193 /* on Audigy Platinum only */
194 #define	A_OUT_HPHONE_L	0x04
195 #define	A_OUT_HPHONE_R	0x05
196 #define	A_OUT_HPHONE	A_OUT_HPHONE_L
197 
198 #define	A_OUT_A_FRONT_L	0x08
199 #define	A_OUT_A_FRONT_R	0x09
200 #define	A_OUT_A_FRONT	A_OUT_A_FRONT_L
201 #define	A_OUT_A_CENTER	0x0a
202 #define	A_OUT_A_SUB	0x0b
203 #define	A_OUT_A_SIDE_L	0x0c
204 #define	A_OUT_A_SIDE_R	0x0d
205 #define	A_OUT_A_SIDE	A_OUT_A_SIDE_L
206 #define	A_OUT_A_REAR_L	0x0e
207 #define	A_OUT_A_REAR_R	0x0f
208 #define	A_OUT_A_REAR	A_OUT_A_REAR_L
209 #define	A_OUT_AC97_L	0x10
210 #define	A_OUT_AC97_R	0x11
211 #define	A_OUT_AC97	A_OUT_AC97_L
212 #define	A_OUT_ADC_REC_L	0x16
213 #define	A_OUT_ADC_REC_R	0x17
214 #define	A_OUT_ADC_REC	A_OUT_ADC_REC_L
215 
216 #include "emu10k1-alsa%diked.h"
217 #include "p16v-alsa%diked.h"
218 #include "p17v-alsa%diked.h"
219 
220 #define	C_FRONT_L	0
221 #define	C_FRONT_R	1
222 #define	C_REC_L		2
223 #define	C_REC_R		3
224 #define	C_REAR_L	4
225 #define	C_REAR_R	5
226 #define	C_CENTER	6
227 #define	C_SUB		7
228 #define	C_SIDE_L	8
229 #define	C_SIDE_R	9
230 #define	NUM_CACHES	10
231 
232 #define	CDSPDIFMUTE	0
233 #define	ANALOGMUTE	1
234 #define	NUM_MUTE	2
235 
236 #define	EMU_MAX_GPR	512
237 #define	EMU_MAX_IRQ_CONSUMERS 32
238 
239 struct emu_voice {
240 	int	vnum;
241 	unsigned int	b16:1, stereo:1, busy:1, running:1, ismaster:1;
242 	int	speed;
243 	int	start;
244 	int	end;
245 	int	vol;
246 	uint32_t buf;
247 	void	*vbuf;
248 	struct emu_voice *slave;
249 	uint32_t sa;
250 	uint32_t ea;
251 	uint32_t routing[8];
252 	uint32_t amounts[8];
253 };
254 
255 struct emu_memblk {
256 	SLIST_ENTRY(emu_memblk)	link;
257 	void		*buf;
258 	char		owner[16];
259 	bus_addr_t	buf_addr;
260 	uint32_t	pte_start, pte_size;
261 };
262 
263 struct emu_mem {
264 	uint8_t		bmap[EMU_MAXPAGES / 8];
265 	uint32_t	*ptb_pages;
266 	void		*silent_page;
267 	bus_addr_t	silent_page_addr;
268 	bus_addr_t	ptb_pages_addr;
269 	bus_dma_tag_t	dmat;
270 	struct emu_sc_info *card;
271 	SLIST_HEAD(, emu_memblk) blocks;
272 };
273 
274 /* rm */
275 struct emu_rm {
276 	struct emu_sc_info *card;
277 	struct mtx	gpr_lock;
278 	signed int	allocmap[EMU_MAX_GPR];
279 	int		num_gprs;
280 	int		last_free_gpr;
281 	int 		num_used;
282 };
283 
284 struct emu_intr_handler {
285 	void*		softc;
286 	uint32_t	intr_mask;
287 	uint32_t	inte_mask;
288 	uint32_t(*irq_func) (void *softc, uint32_t irq);
289 };
290 
291 struct emu_sc_info {
292 	struct mtx	lock;
293 	struct mtx	rw;		/* Hardware exclusive access lock */
294 
295 	/* Hardware and subdevices */
296 	device_t	dev;
297 	device_t	pcm[RT_COUNT];
298 	device_t	midi[2];
299 	uint32_t	type;
300 	uint32_t	rev;
301 
302 	bus_space_tag_t	st;
303 	bus_space_handle_t sh;
304 
305 	struct cdev	*cdev;		/* /dev/emu10k character device */
306 	struct mtx	emu10kx_lock;
307 	int		emu10kx_isopen;
308 	struct sbuf	emu10kx_sbuf;
309 	int		emu10kx_bufptr;
310 
311 
312 	/* Resources */
313 	struct resource	*reg;
314 	struct resource	*irq;
315 	void 		*ih;
316 
317 	/* IRQ handlers */
318 	struct emu_intr_handler ihandler[EMU_MAX_IRQ_CONSUMERS];
319 
320 	/* Card HW configuration */
321 	unsigned int	mode;	/* analog / digital */
322 	unsigned int	mchannel_fx;
323 	unsigned int	dsp_zero;
324 	unsigned int	code_base;
325 	unsigned int	code_size;
326 	unsigned int	gpr_base;
327 	unsigned int	num_gprs;
328 	unsigned int	input_base;
329 	unsigned int	output_base;
330 	unsigned int	efxc_base;
331 	unsigned int	opcode_shift;
332 	unsigned int	high_operand_shift;
333 	unsigned int	address_mask;
334 	uint32_t 	is_emu10k1:1, is_emu10k2, is_ca0102, is_ca0108:1,
335 			has_ac97:1, has_51:1, has_71:1,
336 			enable_ir:1,
337 			broken_digital:1, is_cardbus:1;
338 
339 	signed int	mch_disabled, mch_rec, dbg_level;
340 	signed int 	num_inputs;
341 	unsigned int 	num_outputs;
342 	unsigned int 	num_fxbuses;
343 	unsigned int 	routing_code_start;
344 	unsigned int	routing_code_end;
345 
346 	/* HW resources */
347 	struct emu_voice voice[NUM_G];			/* Hardware voices */
348 	uint32_t	irq_mask[EMU_MAX_IRQ_CONSUMERS]; /* IRQ manager data */
349 	int 		timer[EMU_MAX_IRQ_CONSUMERS];	/* timer */
350 	int		timerinterval;
351 	struct		emu_rm *rm;
352 	struct		emu_mem mem;			/* memory */
353 
354 	/* Mixer */
355 	int		mixer_gpr[NUM_MIXERS];
356 	int		mixer_volcache[NUM_MIXERS];
357 	int		cache_gpr[NUM_CACHES];
358 	int		dummy_gpr;
359 	int		mute_gpr[NUM_MUTE];
360 	struct sysctl_ctx_list	*ctx;
361 	struct sysctl_oid	*root;
362 };
363 
364 static void	emu_setmap(void *arg, bus_dma_segment_t * segs, int nseg, int error);
365 static void*	emu_malloc(struct emu_mem *mem, uint32_t sz, bus_addr_t * addr);
366 static void	emu_free(struct emu_mem *mem, void *dmabuf);
367 static void*	emu_memalloc(struct emu_mem *mem, uint32_t sz, bus_addr_t * addr, const char * owner);
368 static int	emu_memfree(struct emu_mem *mem, void *membuf);
369 static int	emu_memstart(struct emu_mem *mem, void *membuf);
370 
371 /* /dev */
372 static int	emu10kx_dev_init(struct emu_sc_info *sc);
373 static int	emu10kx_dev_uninit(struct emu_sc_info *sc);
374 static int	emu10kx_prepare(struct emu_sc_info *sc, struct sbuf *s);
375 
376 static void	emumix_set_mode(struct emu_sc_info *sc, int mode);
377 static void	emumix_set_spdif_mode(struct emu_sc_info *sc, int mode);
378 static void	emumix_set_fxvol(struct emu_sc_info *sc, unsigned gpr, int32_t vol);
379 static void	emumix_set_gpr(struct emu_sc_info *sc, unsigned gpr, int32_t val);
380 static int	sysctl_emu_mixer_control(SYSCTL_HANDLER_ARGS);
381 
382 static int	emu_rm_init(struct emu_sc_info *sc);
383 static int	emu_rm_uninit(struct emu_sc_info *sc);
384 static int	emu_rm_gpr_alloc(struct emu_rm *rm, int count);
385 
386 static unsigned int emu_getcard(device_t dev);
387 static uint32_t	emu_rd_nolock(struct emu_sc_info *sc, unsigned int regno, unsigned int size);
388 static void	emu_wr_nolock(struct emu_sc_info *sc, unsigned int regno, uint32_t data, unsigned int size);
389 static void	emu_wr_cbptr(struct emu_sc_info *sc, uint32_t data);
390 
391 static void	emu_vstop(struct emu_sc_info *sc, char channel, int enable);
392 
393 static void	emu_intr(void *p);
394 static void	emu_wrefx(struct emu_sc_info *sc, unsigned int pc, unsigned int data);
395 static void	emu_addefxop(struct emu_sc_info *sc, unsigned int op, unsigned int z, unsigned int w, unsigned int x, unsigned int y, uint32_t * pc);
396 static void	emu_initefx(struct emu_sc_info *sc);
397 
398 static int	emu_cardbus_init(struct emu_sc_info *sc);
399 static int	emu_init(struct emu_sc_info *sc);
400 static int	emu_uninit(struct emu_sc_info *sc);
401 
402 static int	emu_read_ivar(device_t bus __unused, device_t dev, int ivar_index, uintptr_t * result);
403 static int	emu_write_ivar(device_t bus __unused, device_t dev __unused,
404     int ivar_index, uintptr_t value __unused);
405 
406 static int	emu_pci_probe(device_t dev);
407 static int	emu_pci_attach(device_t dev);
408 static int	emu_pci_detach(device_t dev);
409 static int	emu_modevent(module_t mod __unused, int cmd, void *data __unused);
410 
411 #ifdef	SND_EMU10KX_DEBUG
412 
413 #define EMU_MTX_DEBUG() do { 						\
414 		if (mtx_owned(&sc->rw)) {				\
415 		printf("RW owned in %s line %d for %s\n", __func__,	\
416 			__LINE__ , device_get_nameunit(sc->dev));	\
417 		printf("rw lock owned: %d\n", mtx_owned(&sc->rw));	\
418 		printf("rw lock: value %x thread %x\n",			\
419 			((&sc->rw)->mtx_lock & ~MTX_FLAGMASK), 		\
420 			(uintptr_t)curthread);				\
421 		printf("rw lock: recursed %d\n", mtx_recursed(&sc->rw));\
422 		db_show_mtx(&sc->rw);					\
423 		}							\
424 	} while (0)
425 #else
426 #define EMU_MTX_DEBUG() do { 						\
427 	} while (0)
428 #endif
429 
430 #define EMU_RWLOCK() do {		\
431 	EMU_MTX_DEBUG();		\
432 	mtx_lock(&(sc->rw));		\
433 	} while (0)
434 
435 #define EMU_RWUNLOCK() do {		\
436 	mtx_unlock(&(sc->rw));		\
437 	EMU_MTX_DEBUG();		\
438 	} while (0)
439 
440 /* Supported cards */
441 struct emu_hwinfo {
442 	uint16_t	vendor;
443 	uint16_t	device;
444 	uint16_t	subvendor;
445 	uint16_t	subdevice;
446 	char		SBcode[8];
447 	char		desc[32];
448 	int		flags;
449 };
450 
451 static struct emu_hwinfo emu_cards[] = {
452 	{0xffff, 0xffff, 0xffff, 0xffff, "BADCRD", "Not a compatible card", 0},
453 	/* 0x0020..0x002f 4.0 EMU10K1 cards */
454 	{0x1102, 0x0002, 0x1102, 0x0020, "CT4850", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
455 	{0x1102, 0x0002, 0x1102, 0x0021, "CT4620", "SBLive!", HAS_AC97 | IS_EMU10K1},
456 	{0x1102, 0x0002, 0x1102, 0x002f, "CT????", "SBLive! mainboard implementation", HAS_AC97 | IS_EMU10K1},
457 
458 	/* (range unknown) 5.1 EMU10K1 cards */
459 	{0x1102, 0x0002, 0x1102, 0x100a, "CT????", "SBLive! 5.1", HAS_AC97 | HAS_51 | IS_EMU10K1},
460 
461 	/* 0x80??..0x805? 4.0 EMU10K1 cards */
462 	{0x1102, 0x0002, 0x1102, 0x8022, "CT4780", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
463 	{0x1102, 0x0002, 0x1102, 0x8023, "CT4790", "SB PCI512", HAS_AC97 | IS_EMU10K1},
464 	{0x1102, 0x0002, 0x1102, 0x8024, "CT4760", "SBLive!", HAS_AC97 | IS_EMU10K1},
465 	{0x1102, 0x0002, 0x1102, 0x8025, "CT????", "SBLive! Mainboard Implementation", HAS_AC97 | IS_EMU10K1},
466 	{0x1102, 0x0002, 0x1102, 0x8026, "CT4830", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
467 	{0x1102, 0x0002, 0x1102, 0x8027, "CT4832", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
468 	{0x1102, 0x0002, 0x1102, 0x8028, "CT4760", "SBLive! OEM version", HAS_AC97 | IS_EMU10K1},
469 	{0x1102, 0x0002, 0x1102, 0x8031, "CT4831", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
470 	{0x1102, 0x0002, 0x1102, 0x8040, "CT4760", "SBLive!", HAS_AC97 | IS_EMU10K1},
471 	{0x1102, 0x0002, 0x1102, 0x8051, "CT4850", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
472 
473 	/* 0x8061..0x???? 5.1 EMU10K1  cards */
474 	{0x1102, 0x0002, 0x1102, 0x8061, "SB????", "SBLive! Player 5.1", HAS_AC97 | HAS_51 | IS_EMU10K1},
475 	{0x1102, 0x0002, 0x1102, 0x8062, "CT4830", "SBLive! 1024", HAS_AC97 | HAS_51 | IS_EMU10K1},
476 	{0x1102, 0x0002, 0x1102, 0x8064, "SB????", "SBLive! 5.1", HAS_AC97 | HAS_51 | IS_EMU10K1},
477 	{0x1102, 0x0002, 0x1102, 0x8065, "SB0220", "SBLive! 5.1 Digital", HAS_AC97 | HAS_51 | IS_EMU10K1},
478 	{0x1102, 0x0002, 0x1102, 0x8066, "CT4780", "SBLive! 5.1 Digital", HAS_AC97 | HAS_51 | IS_EMU10K1},
479 	{0x1102, 0x0002, 0x1102, 0x8067, "SB????", "SBLive!", HAS_AC97 | HAS_51 | IS_EMU10K1},
480 
481 	/* Generic SB Live! */
482 	{0x1102, 0x0002, 0x1102, 0x0000, "SB????", "SBLive! (Unknown model)", HAS_AC97 | IS_EMU10K1},
483 
484 	/* 0x0041..0x0043 EMU10K2 (some kind of Audigy) cards */
485 
486 	/* 0x0051..0x0051 5.1 CA0100-IAF cards */
487 	{0x1102, 0x0004, 0x1102, 0x0051, "SB0090", "Audigy", HAS_AC97 | HAS_51 | IS_EMU10K2},
488 	/* ES is CA0100-IDF chip that don't work in digital mode */
489 	{0x1102, 0x0004, 0x1102, 0x0052, "SB0160", "Audigy ES", HAS_AC97 | HAS_71 | IS_EMU10K2 | BROKEN_DIGITAL},
490 	/* 0x0053..0x005C 5.1 CA0101-NAF cards */
491 	{0x1102, 0x0004, 0x1102, 0x0053, "SB0090", "Audigy Player/OEM", HAS_AC97 | HAS_51 | IS_EMU10K2},
492 	{0x1102, 0x0004, 0x1102, 0x0058, "SB0090", "Audigy Player/OEM", HAS_AC97 | HAS_51 | IS_EMU10K2},
493 
494 	/* 0x1002..0x1009 5.1 CA0102-IAT cards */
495 	{0x1102, 0x0004, 0x1102, 0x1002, "SB????", "Audigy 2 Platinum", HAS_51 | IS_CA0102},
496 	{0x1102, 0x0004, 0x1102, 0x1005, "SB????", "Audigy 2 Platinum EX", HAS_51 | IS_CA0102},
497 	{0x1102, 0x0004, 0x1102, 0x1007, "SB0240", "Audigy 2", HAS_AC97 | HAS_51 | IS_CA0102},
498 
499 	/* 0x2001..0x2003 7.1 CA0102-ICT cards */
500 	{0x1102, 0x0004, 0x1102, 0x2001, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
501 	{0x1102, 0x0004, 0x1102, 0x2002, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
502 	/* XXX No reports about 0x2003 & 0x2004 cards */
503 	{0x1102, 0x0004, 0x1102, 0x2003, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
504 	{0x1102, 0x0004, 0x1102, 0x2004, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
505 	{0x1102, 0x0004, 0x1102, 0x2005, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
506 
507 	/* (range unknown) 7.1 CA0102-xxx Audigy 4 cards */
508 	{0x1102, 0x0004, 0x1102, 0x2007, "SB0380", "Audigy 4 Pro", HAS_AC97 | HAS_71 | IS_CA0102},
509 
510 	/* Generic Audigy or Audigy 2 */
511 	{0x1102, 0x0004, 0x1102, 0x0000, "SB????", "Audigy (Unknown model)", HAS_AC97 | HAS_51 | IS_EMU10K2},
512 
513 	/* We don't support CA0103-DAT (Audigy LS) cards */
514 	/* There is NO CA0104-xxx cards */
515 	/* There is NO CA0105-xxx cards */
516 	/* We don't support CA0106-DAT (SB Live! 24 bit) cards */
517 	/* There is NO CA0107-xxx cards */
518 
519 	/* 0x1000..0x1001 7.1 CA0108-IAT cards */
520 	{0x1102, 0x0008, 0x1102, 0x1000, "SB????", "Audigy 2 LS", HAS_AC97 | HAS_51 | IS_CA0108 | DIGITAL_ONLY},
521 	{0x1102, 0x0008, 0x1102, 0x1001, "SB0400", "Audigy 2 Value", HAS_AC97 | HAS_71 | IS_CA0108 | DIGITAL_ONLY},
522 	{0x1102, 0x0008, 0x1102, 0x1021, "SB0610", "Audigy 4", HAS_AC97 | HAS_71 | IS_CA0108 | DIGITAL_ONLY},
523 
524 	{0x1102, 0x0008, 0x1102, 0x2001, "SB0530", "Audigy 2 ZS CardBus", HAS_AC97 | HAS_71 | IS_CA0108 | IS_CARDBUS},
525 
526 	{0x1102, 0x0008, 0x0000, 0x0000, "SB????", "Audigy 2 Value (Unknown model)", HAS_AC97 | HAS_51 | IS_CA0108},
527 };
528 /* Unsupported cards */
529 
530 static struct emu_hwinfo emu_bad_cards[] = {
531 	/* APS cards should be possible to support */
532 	{0x1102, 0x0002, 0x1102, 0x4001, "EMUAPS", "E-mu APS", 0},
533 	{0x1102, 0x0002, 0x1102, 0x4002, "EMUAPS", "E-mu APS", 0},
534 	{0x1102, 0x0004, 0x1102, 0x4001, "EMU???", "E-mu 1212m [4001]", 0},
535 	/* Similar-named ("Live!" or "Audigy") cards on different chipsets */
536 	{0x1102, 0x8064, 0x0000, 0x0000, "SB0100", "SBLive! 5.1 OEM", 0},
537 	{0x1102, 0x0006, 0x0000, 0x0000, "SB0200", "DELL OEM SBLive! Value", 0},
538 	{0x1102, 0x0007, 0x0000, 0x0000, "SB0310", "Audigy LS", 0},
539 };
540 
541 /*
542  * Get best known information about device.
543  */
544 static unsigned int
545 emu_getcard(device_t dev)
546 {
547 	uint16_t device;
548 	uint16_t subdevice;
549 	int n_cards;
550 	unsigned int thiscard;
551 	int i;
552 
553 	device = pci_read_config(dev, PCIR_DEVICE, /* bytes */ 2);
554 	subdevice = pci_read_config(dev, PCIR_SUBDEV_0, /* bytes */ 2);
555 
556 	n_cards = sizeof(emu_cards) / sizeof(struct emu_hwinfo);
557 	thiscard = 0;
558 	for (i = 1; i < n_cards; i++) {
559 		if (device == emu_cards[i].device) {
560 			if (subdevice == emu_cards[i].subdevice) {
561 				thiscard = i;
562 				break;
563 			}
564 			if (0x0000 == emu_cards[i].subdevice) {
565 				thiscard = i;
566 				/*
567 				 * don't break, we can get more specific card
568 				 * later in the list.
569 				 */
570 			}
571 		}
572 	}
573 
574 	n_cards = sizeof(emu_bad_cards) / sizeof(struct emu_hwinfo);
575 	for (i = 0; i < n_cards; i++) {
576 		if (device == emu_bad_cards[i].device) {
577 			if (subdevice == emu_bad_cards[i].subdevice) {
578 				thiscard = 0;
579 				break;
580 			}
581 			if (0x0000 == emu_bad_cards[i].subdevice) {
582 				thiscard = 0;
583 				break;	/* we avoid all this cards */
584 			}
585 		}
586 	}
587 	return (thiscard);
588 }
589 
590 
591 /*
592  * Base hardware interface are 32 (Audigy) or 64 (Audigy2) registers.
593  * Some of them are used directly, some of them provide pointer / data pairs.
594  */
595 static uint32_t
596 emu_rd_nolock(struct emu_sc_info *sc, unsigned int regno, unsigned int size)
597 {
598 
599 	KASSERT(sc != NULL, ("emu_rd: NULL sc"));
600 	switch (size) {
601 	case 1:
602 		return (bus_space_read_1(sc->st, sc->sh, regno));
603 	case 2:
604 		return (bus_space_read_2(sc->st, sc->sh, regno));
605 	case 4:
606 		return (bus_space_read_4(sc->st, sc->sh, regno));
607 	}
608 	return (0xffffffff);
609 }
610 
611 static void
612 emu_wr_nolock(struct emu_sc_info *sc, unsigned int regno, uint32_t data, unsigned int size)
613 {
614 
615 	KASSERT(sc != NULL, ("emu_rd: NULL sc"));
616 	switch (size) {
617 	case 1:
618 		bus_space_write_1(sc->st, sc->sh, regno, data);
619 		break;
620 	case 2:
621 		bus_space_write_2(sc->st, sc->sh, regno, data);
622 		break;
623 	case 4:
624 		bus_space_write_4(sc->st, sc->sh, regno, data);
625 		break;
626 	}
627 }
628 /*
629  * PTR / DATA interface. Access to EMU10Kx is made
630  * via (channel, register) pair. Some registers are channel-specific,
631  * some not.
632  */
633 uint32_t
634 emu_rdptr(struct emu_sc_info *sc, unsigned int chn, unsigned int reg)
635 {
636 	uint32_t ptr, val, mask, size, offset;
637 
638 	ptr = ((reg << 16) & sc->address_mask) | (chn & PTR_CHANNELNUM_MASK);
639 
640 	EMU_RWLOCK();
641 	emu_wr_nolock(sc, PTR, ptr, 4);
642 	val = emu_rd_nolock(sc, DATA, 4);
643 	EMU_RWUNLOCK();
644 
645 	/*
646 	 * XXX Some register numbers has data size and offset encoded in
647 	 * it to get only part of 32bit register. This use is not described
648 	 * in register name, be careful!
649 	 */
650 	if (reg & 0xff000000) {
651 		size = (reg >> 24) & 0x3f;
652 		offset = (reg >> 16) & 0x1f;
653 		mask = ((1 << size) - 1) << offset;
654 		val &= mask;
655 		val >>= offset;
656 	}
657 	return (val);
658 }
659 
660 void
661 emu_wrptr(struct emu_sc_info *sc, unsigned int chn, unsigned int reg, uint32_t data)
662 {
663 	uint32_t ptr, mask, size, offset;
664 
665 	ptr = ((reg << 16) & sc->address_mask) | (chn & PTR_CHANNELNUM_MASK);
666 
667 	EMU_RWLOCK();
668 	emu_wr_nolock(sc, PTR, ptr, 4);
669 	/*
670 	 * XXX Another kind of magic encoding in register number. This can
671 	 * give you side effect - it will read previous data from register
672 	 * and change only required bits.
673 	 */
674 	if (reg & 0xff000000) {
675 		size = (reg >> 24) & 0x3f;
676 		offset = (reg >> 16) & 0x1f;
677 		mask = ((1 << size) - 1) << offset;
678 		data <<= offset;
679 		data &= mask;
680 		data |= emu_rd_nolock(sc, DATA, 4) & ~mask;
681 	}
682 	emu_wr_nolock(sc, DATA, data, 4);
683 	EMU_RWUNLOCK();
684 }
685 /*
686  * PTR2 / DATA2 interface. Access to P16v is made
687  * via (channel, register) pair. Some registers are channel-specific,
688  * some not. This interface is supported by CA0102 and CA0108 chips only.
689  */
690 uint32_t
691 emu_rd_p16vptr(struct emu_sc_info *sc, uint16_t chn, uint16_t reg)
692 {
693 	uint32_t val;
694 
695 	/* XXX separate lock? */
696 	EMU_RWLOCK();
697 	emu_wr_nolock(sc, PTR2, (reg << 16) | chn, 4);
698 	val = emu_rd_nolock(sc, DATA2, 4);
699 
700 	EMU_RWUNLOCK();
701 
702 	return (val);
703 }
704 
705 void
706 emu_wr_p16vptr(struct emu_sc_info *sc, uint16_t chn, uint16_t reg, uint32_t data)
707 {
708 
709 	EMU_RWLOCK();
710 	emu_wr_nolock(sc, PTR2, (reg << 16) | chn, 4);
711 	emu_wr_nolock(sc, DATA2, data, 4);
712 	EMU_RWUNLOCK();
713 }
714 /*
715  * XXX CardBus interface. Not tested on any real hardware.
716  */
717 static void
718 emu_wr_cbptr(struct emu_sc_info *sc, uint32_t data)
719 {
720 	uint32_t val;
721 
722 	/*
723 	 * 0x38 is IPE3 (CD S/PDIF interrupt pending register) on CA0102. Seems
724 	 * to be some reg/value accessible kind of config register on CardBus
725 	 * CA0108, with value(?) in top 16 bit, address(?) in low 16
726 	 */
727 
728 	val = emu_rd_nolock(sc, 0x38, 4);
729 	emu_wr_nolock(sc, 0x38, data, 4);
730 	val = emu_rd_nolock(sc, 0x38, 4);
731 
732 }
733 
734 /*
735  * Direct hardware register access
736  * Assume that it is never used to access PTR-based registers and can run unlocked.
737  */
738 void
739 emu_wr(struct emu_sc_info *sc, unsigned int regno, uint32_t data, unsigned int size)
740 {
741 	KASSERT(regno != PTR, ("emu_wr: attempt to write to PTR"));
742 	KASSERT(regno != PTR2, ("emu_wr: attempt to write to PTR2"));
743 
744 	emu_wr_nolock(sc, regno, data, size);
745 }
746 
747 uint32_t
748 emu_rd(struct emu_sc_info *sc, unsigned int regno, unsigned int size)
749 {
750 	uint32_t rd;
751 
752 	KASSERT(regno != DATA, ("emu_rd: attempt to read DATA"));
753 	KASSERT(regno != DATA2, ("emu_rd: attempt to read DATA2"));
754 
755 	rd = emu_rd_nolock(sc, regno, size);
756 	return (rd);
757 }
758 
759 /*
760  * Enabling IR MIDI messages is another kind of black magic. It just
761  * has to be made this way. It really do it.
762  */
763 void
764 emu_enable_ir(struct emu_sc_info *sc)
765 {
766 	uint32_t iocfg;
767 
768 	if (sc->is_emu10k2 || sc->is_ca0102) {
769 		iocfg = emu_rd_nolock(sc, A_IOCFG, 2);
770 		emu_wr_nolock(sc, A_IOCFG, iocfg | A_IOCFG_GPOUT2, 2);
771 		DELAY(500);
772 		emu_wr_nolock(sc, A_IOCFG, iocfg | A_IOCFG_GPOUT1 | A_IOCFG_GPOUT2, 2);
773 		DELAY(500);
774 		emu_wr_nolock(sc, A_IOCFG, iocfg | A_IOCFG_GPOUT1, 2);
775 		DELAY(100);
776 		emu_wr_nolock(sc, A_IOCFG, iocfg, 2);
777 		device_printf(sc->dev, "Audigy IR MIDI events enabled.\n");
778 		sc->enable_ir = 1;
779 	}
780 	if (sc->is_emu10k1) {
781 		iocfg = emu_rd_nolock(sc, HCFG, 4);
782 		emu_wr_nolock(sc, HCFG, iocfg | HCFG_GPOUT2, 4);
783 		DELAY(500);
784 		emu_wr_nolock(sc, HCFG, iocfg | HCFG_GPOUT1 | HCFG_GPOUT2, 4);
785 		DELAY(100);
786 		emu_wr_nolock(sc, HCFG, iocfg, 4);
787 		device_printf(sc->dev, "SB Live! IR MIDI events enabled.\n");
788 		sc->enable_ir = 1;
789 	}
790 }
791 
792 
793 /*
794  * emu_timer_ - HW timer managment
795  */
796 int
797 emu_timer_create(struct emu_sc_info *sc)
798 {
799 	int i, timer;
800 
801 	timer = -1;
802 
803 	mtx_lock(&sc->lock);
804 	for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
805 		if (sc->timer[i] == 0) {
806 			sc->timer[i] = -1;	/* disable it */
807 			timer = i;
808 			mtx_unlock(&sc->lock);
809 			return (timer);
810 		}
811 	mtx_unlock(&sc->lock);
812 
813 	return (-1);
814 }
815 
816 int
817 emu_timer_set(struct emu_sc_info *sc, int timer, int delay)
818 {
819 	int i;
820 
821 	if (timer < 0)
822 		return (-1);
823 
824 	RANGE(delay, 16, 1024);
825 	RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
826 
827 	mtx_lock(&sc->lock);
828 	sc->timer[timer] = delay;
829 	for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
830 		if (sc->timerinterval > sc->timer[i])
831 			sc->timerinterval = sc->timer[i];
832 
833 	/* XXX */
834 	emu_wr(sc, TIMER, sc->timerinterval & 0x03ff, 2);
835 	mtx_unlock(&sc->lock);
836 
837 	return (timer);
838 }
839 
840 int
841 emu_timer_enable(struct emu_sc_info *sc, int timer, int go)
842 {
843 	uint32_t x;
844 	int ena_int;
845 	int i;
846 
847 	if (timer < 0)
848 		return (-1);
849 
850 	RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
851 
852 	mtx_lock(&sc->lock);
853 
854 	if ((go == 1) && (sc->timer[timer] < 0))
855 		sc->timer[timer] = -sc->timer[timer];
856 	if ((go == 0) && (sc->timer[timer] > 0))
857 		sc->timer[timer] = -sc->timer[timer];
858 
859 	ena_int = 0;
860 	for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++) {
861 		if (sc->timerinterval > sc->timer[i])
862 			sc->timerinterval = sc->timer[i];
863 		if (sc->timer[i] > 0)
864 			ena_int = 1;
865 	}
866 
867 	emu_wr(sc, TIMER, sc->timerinterval & 0x03ff, 2);
868 
869 	if (ena_int == 1) {
870 		x = emu_rd(sc, INTE, 4);
871 		x |= INTE_INTERVALTIMERENB;
872 		emu_wr(sc, INTE, x, 4);
873 	} else {
874 		x = emu_rd(sc, INTE, 4);
875 		x &= ~INTE_INTERVALTIMERENB;
876 		emu_wr(sc, INTE, x, 4);
877 	}
878 	mtx_unlock(&sc->lock);
879 	return (0);
880 }
881 
882 int
883 emu_timer_clear(struct emu_sc_info *sc, int timer)
884 {
885 	if (timer < 0)
886 		return (-1);
887 
888 	RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
889 
890 	emu_timer_enable(sc, timer, 0);
891 
892 	mtx_lock(&sc->lock);
893 	if (sc->timer[timer] != 0)
894 		sc->timer[timer] = 0;
895 	mtx_unlock(&sc->lock);
896 
897 	return (timer);
898 }
899 
900 /*
901  * emu_intr_ - HW interrupt handler managment
902  */
903 int
904 emu_intr_register(struct emu_sc_info *sc, uint32_t inte_mask, uint32_t intr_mask, uint32_t(*func) (void *softc, uint32_t irq), void *isc)
905 {
906 	int i;
907 	uint32_t x;
908 
909 	mtx_lock(&sc->lock);
910 	for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
911 		if (sc->ihandler[i].inte_mask == 0) {
912 			sc->ihandler[i].inte_mask = inte_mask;
913 			sc->ihandler[i].intr_mask = intr_mask;
914 			sc->ihandler[i].softc = isc;
915 			sc->ihandler[i].irq_func = func;
916 			x = emu_rd(sc, INTE, 4);
917 			x |= inte_mask;
918 			emu_wr(sc, INTE, x, 4);
919 			mtx_unlock(&sc->lock);
920 			if (sc->dbg_level > 1)
921 				device_printf(sc->dev, "ihandle %d registered\n", i);
922 
923 			return (i);
924 		}
925 	mtx_unlock(&sc->lock);
926 	if (sc->dbg_level > 1)
927 		device_printf(sc->dev, "ihandle not registered\n");
928 
929 	return (-1);
930 }
931 
932 int
933 emu_intr_unregister(struct emu_sc_info *sc, int hnumber)
934 {
935 	uint32_t x;
936 	int i;
937 
938 	mtx_lock(&sc->lock);
939 
940 	if (sc->ihandler[hnumber].inte_mask == 0) {
941 		mtx_unlock(&sc->lock);
942 		return (-1);
943 	}
944 
945 	x = emu_rd(sc, INTE, 4);
946 	x &= ~sc->ihandler[hnumber].inte_mask;
947 
948 	sc->ihandler[hnumber].inte_mask = 0;
949 	sc->ihandler[hnumber].intr_mask = 0;
950 	sc->ihandler[hnumber].softc = NULL;
951 	sc->ihandler[hnumber].irq_func = NULL;
952 
953 	/* other interrupt handlers may use this INTE value */
954 	for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
955 		if (sc->ihandler[i].inte_mask != 0)
956 			x |= sc->ihandler[i].inte_mask;
957 
958 	emu_wr(sc, INTE, x, 4);
959 
960 	mtx_unlock(&sc->lock);
961 	return (hnumber);
962 }
963 
964 static void
965 emu_intr(void *p)
966 {
967 	struct emu_sc_info *sc = (struct emu_sc_info *)p;
968 	uint32_t stat, ack;
969 	int i;
970 
971 	for (;;) {
972 		stat = emu_rd(sc, IPR, 4);
973 		ack = 0;
974 		if (stat == 0)
975 			break;
976 		emu_wr(sc, IPR, stat, 4);
977 		for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++) {
978 			if ((((sc->ihandler[i].intr_mask) & stat) != 0) &&
979 			    (((void *)sc->ihandler[i].irq_func) != NULL)) {
980 				ack |= sc->ihandler[i].irq_func(sc->ihandler[i].softc,
981 				    (sc->ihandler[i].intr_mask) & stat);
982 			}
983 		}
984 	if (sc->dbg_level > 1)
985 		if (stat & (~ack))
986 			device_printf(sc->dev, "Unhandled interrupt: %08x\n", stat & (~ack));
987 
988 	}
989 
990 	if ((sc->is_ca0102) || (sc->is_ca0108))
991 		for (;;) {
992 			stat = emu_rd(sc, IPR2, 4);
993 			ack = 0;
994 			if (stat == 0)
995 				break;
996 			emu_wr(sc, IPR2, stat, 4);
997 			if (sc->dbg_level > 1)
998 				device_printf(sc->dev, "IPR2: %08x\n", stat);
999 
1000 			break;	/* to avoid infinite loop. shoud be removed
1001 				 * after completion of P16V interface. */
1002 		}
1003 
1004 	if (sc->is_ca0102)
1005 		for (;;) {
1006 			stat = emu_rd(sc, IPR3, 4);
1007 			ack = 0;
1008 			if (stat == 0)
1009 				break;
1010 			emu_wr(sc, IPR3, stat, 4);
1011 			if (sc->dbg_level > 1)
1012 				device_printf(sc->dev, "IPR3: %08x\n", stat);
1013 
1014 			break;	/* to avoid infinite loop. should be removed
1015 				 * after completion of S/PDIF interface */
1016 		}
1017 }
1018 
1019 
1020 /*
1021  * Get data from private emu10kx structure for PCM buffer allocation.
1022  * Used by PCM code only.
1023  */
1024 bus_dma_tag_t
1025 emu_gettag(struct emu_sc_info *sc)
1026 {
1027 	return (sc->mem.dmat);
1028 }
1029 
1030 static void
1031 emu_setmap(void *arg, bus_dma_segment_t * segs, int nseg, int error)
1032 {
1033 	bus_addr_t *phys = (bus_addr_t *) arg;
1034 
1035 	*phys = error ? 0 : (bus_addr_t) segs->ds_addr;
1036 
1037 	if (bootverbose) {
1038 		printf("emu10kx: setmap (%lx, %lx), nseg=%d, error=%d\n",
1039 		    (unsigned long)segs->ds_addr, (unsigned long)segs->ds_len,
1040 		    nseg, error);
1041 	}
1042 }
1043 
1044 static void *
1045 emu_malloc(struct emu_mem *mem, uint32_t sz, bus_addr_t * addr)
1046 {
1047 	void *dmabuf;
1048 	bus_dmamap_t map;
1049 	int error;
1050 
1051 	*addr = 0;
1052 	if ((error = bus_dmamem_alloc(mem->dmat, &dmabuf, BUS_DMA_NOWAIT, &map))) {
1053 		if (mem->card->dbg_level > 2)
1054 			device_printf(mem->card->dev, "emu_malloc: failed to alloc DMA map: %d\n", error);
1055 		return (NULL);
1056 		}
1057 	if ((error = bus_dmamap_load(mem->dmat, map, dmabuf, sz, emu_setmap, addr, 0)) || !*addr) {
1058 		if (mem->card->dbg_level > 2)
1059 			device_printf(mem->card->dev, "emu_malloc: failed to load DMA memory: %d\n", error);
1060 		return (NULL);
1061 		}
1062 	return (dmabuf);
1063 }
1064 
1065 static void
1066 emu_free(struct emu_mem *mem, void *dmabuf)
1067 {
1068 	bus_dmamem_free(mem->dmat, dmabuf, NULL);
1069 }
1070 
1071 static void *
1072 emu_memalloc(struct emu_mem *mem, uint32_t sz, bus_addr_t * addr, const char *owner)
1073 {
1074 	uint32_t blksz, start, idx, ofs, tmp, found;
1075 	struct emu_memblk *blk;
1076 	void *membuf;
1077 
1078 	blksz = sz / EMUPAGESIZE;
1079 	if (sz > (blksz * EMUPAGESIZE))
1080 		blksz++;
1081 	if (blksz > EMU_MAX_BUFSZ / EMUPAGESIZE) {
1082 		if (mem->card->dbg_level > 2)
1083 			device_printf(mem->card->dev, "emu_memalloc: memory request tool large\n");
1084 		return (NULL);
1085 		}
1086 	/* find a free block in the bitmap */
1087 	found = 0;
1088 	start = 1;
1089 	while (!found && start + blksz < EMU_MAXPAGES) {
1090 		found = 1;
1091 		for (idx = start; idx < start + blksz; idx++)
1092 			if (mem->bmap[idx >> 3] & (1 << (idx & 7)))
1093 				found = 0;
1094 		if (!found)
1095 			start++;
1096 	}
1097 	if (!found) {
1098 		if (mem->card->dbg_level > 2)
1099 			device_printf(mem->card->dev, "emu_memalloc: no free space in bitmap\n");
1100 		return (NULL);
1101 		}
1102 	blk = malloc(sizeof(*blk), M_DEVBUF, M_NOWAIT);
1103 	if (blk == NULL) {
1104 		if (mem->card->dbg_level > 2)
1105 			device_printf(mem->card->dev, "emu_memalloc: buffer allocation failed\n");
1106 		return (NULL);
1107 		}
1108 	bzero(blk, sizeof(*blk));
1109 	membuf = emu_malloc(mem, sz, &blk->buf_addr);
1110 	*addr = blk->buf_addr;
1111 	if (membuf == NULL) {
1112 		if (mem->card->dbg_level > 2)
1113 			device_printf(mem->card->dev, "emu_memalloc: can't setup HW memory\n");
1114 		free(blk, M_DEVBUF);
1115 		return (NULL);
1116 	}
1117 	blk->buf = membuf;
1118 	blk->pte_start = start;
1119 	blk->pte_size = blksz;
1120 	strncpy(blk->owner, owner, 15);
1121 	blk->owner[15] = '\0';
1122 	ofs = 0;
1123 	for (idx = start; idx < start + blksz; idx++) {
1124 		mem->bmap[idx >> 3] |= 1 << (idx & 7);
1125 		tmp = (uint32_t) (u_long) ((uint8_t *) blk->buf_addr + ofs);
1126 		mem->ptb_pages[idx] = (tmp << 1) | idx;
1127 		ofs += EMUPAGESIZE;
1128 	}
1129 	SLIST_INSERT_HEAD(&mem->blocks, blk, link);
1130 	return (membuf);
1131 }
1132 
1133 static int
1134 emu_memfree(struct emu_mem *mem, void *membuf)
1135 {
1136 	uint32_t idx, tmp;
1137 	struct emu_memblk *blk, *i;
1138 
1139 	blk = NULL;
1140 	SLIST_FOREACH(i, &mem->blocks, link) {
1141 		if (i->buf == membuf)
1142 			blk = i;
1143 	}
1144 	if (blk == NULL)
1145 		return (EINVAL);
1146 	SLIST_REMOVE(&mem->blocks, blk, emu_memblk, link);
1147 	emu_free(mem, membuf);
1148 	tmp = (uint32_t) (mem->silent_page_addr) << 1;
1149 	for (idx = blk->pte_start; idx < blk->pte_start + blk->pte_size; idx++) {
1150 		mem->bmap[idx >> 3] &= ~(1 << (idx & 7));
1151 		mem->ptb_pages[idx] = tmp | idx;
1152 	}
1153 	free(blk, M_DEVBUF);
1154 	return (0);
1155 }
1156 
1157 static int
1158 emu_memstart(struct emu_mem *mem, void *membuf)
1159 {
1160 	struct emu_memblk *blk, *i;
1161 
1162 	blk = NULL;
1163 	SLIST_FOREACH(i, &mem->blocks, link) {
1164 		if (i->buf == membuf)
1165 			blk = i;
1166 	}
1167 	if (blk == NULL)
1168 		return (-1);
1169 	return (blk->pte_start);
1170 }
1171 
1172 
1173 static uint32_t
1174 emu_rate_to_pitch(uint32_t rate)
1175 {
1176 	static uint32_t logMagTable[128] = {
1177 		0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3, 0x13aa2,
1178 		0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a, 0x2655d, 0x28ed5,
1179 		0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb, 0x381b6, 0x3a93d, 0x3d081,
1180 		0x3f782, 0x41e42, 0x444c1, 0x46b01, 0x49101, 0x4b6c4, 0x4dc49, 0x50191,
1181 		0x5269e, 0x54b6f, 0x57006, 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7,
1182 		0x646ee, 0x66a00, 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829,
1183 		0x759d4, 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
1184 		0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20, 0x93d26,
1185 		0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec, 0xa11d8, 0xa2f9d,
1186 		0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241, 0xadf26, 0xafbe7, 0xb1885,
1187 		0xb3500, 0xb5157, 0xb6d8c, 0xb899f, 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899,
1188 		0xc1404, 0xc2f50, 0xc4a7b, 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c,
1189 		0xceaec, 0xd053f, 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3,
1190 		0xdba4a, 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
1191 		0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a, 0xf2c83,
1192 		0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57, 0xfd1a7, 0xfe8df
1193 	};
1194 	static char logSlopeTable[128] = {
1195 		0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
1196 		0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
1197 		0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
1198 		0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
1199 		0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
1200 		0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
1201 		0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
1202 		0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
1203 		0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
1204 		0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
1205 		0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
1206 		0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
1207 		0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
1208 		0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
1209 		0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
1210 		0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
1211 	};
1212 	int i;
1213 
1214 	if (rate == 0)
1215 		return (0);
1216 	rate *= 11185;		/* Scale 48000 to 0x20002380 */
1217 	for (i = 31; i > 0; i--) {
1218 		if (rate & 0x80000000) {	/* Detect leading "1" */
1219 			return (((uint32_t) (i - 15) << 20) +
1220 			    logMagTable[0x7f & (rate >> 24)] +
1221 			    (0x7f & (rate >> 17)) *
1222 			    logSlopeTable[0x7f & (rate >> 24)]);
1223 		}
1224 		rate <<= 1;
1225 	}
1226 	/* NOTREACHED */
1227 	return (0);
1228 }
1229 
1230 static uint32_t
1231 emu_rate_to_linearpitch(uint32_t rate)
1232 {
1233 	rate = (rate << 8) / 375;
1234 	return ((rate >> 1) + (rate & 1));
1235 }
1236 
1237 struct emu_voice *
1238 emu_valloc(struct emu_sc_info *sc)
1239 {
1240 	struct emu_voice *v;
1241 	int i;
1242 
1243 	v = NULL;
1244 	mtx_lock(&sc->lock);
1245 	for (i = 0; i < NUM_G && sc->voice[i].busy; i++);
1246 	if (i < NUM_G) {
1247 		v = &sc->voice[i];
1248 		v->busy = 1;
1249 	}
1250 	mtx_unlock(&sc->lock);
1251 	return (v);
1252 }
1253 
1254 void
1255 emu_vfree(struct emu_sc_info *sc, struct emu_voice *v)
1256 {
1257 	int i, r;
1258 
1259 	mtx_lock(&sc->lock);
1260 	for (i = 0; i < NUM_G; i++) {
1261 		if (v == &sc->voice[i] && sc->voice[i].busy) {
1262 			v->busy = 0;
1263 			/*
1264 			 * XXX What we should do with mono channels?
1265 			 * See -pcm.c emupchan_init for other side of
1266 			 * this problem
1267 			 */
1268 			if (v->slave != NULL)
1269 				r = emu_memfree(&sc->mem, v->vbuf);
1270 		}
1271 	}
1272 	mtx_unlock(&sc->lock);
1273 }
1274 
1275 int
1276 emu_vinit(struct emu_sc_info *sc, struct emu_voice *m, struct emu_voice *s,
1277     uint32_t sz, struct snd_dbuf *b)
1278 {
1279 	void *vbuf;
1280 	bus_addr_t tmp_addr;
1281 
1282 	vbuf = emu_memalloc(&sc->mem, sz, &tmp_addr, "vinit");
1283 	if (vbuf == NULL) {
1284 		if(sc->dbg_level > 2)
1285 			device_printf(sc->dev, "emu_memalloc returns NULL in enu_vinit\n");
1286 		return (ENOMEM);
1287 		}
1288 	if (b != NULL)
1289 		sndbuf_setup(b, vbuf, sz);
1290 	m->start = emu_memstart(&sc->mem, vbuf) * EMUPAGESIZE;
1291 	if (m->start < 0) {
1292 		if(sc->dbg_level > 2)
1293 			device_printf(sc->dev, "emu_memstart returns (-1) in enu_vinit\n");
1294 		emu_memfree(&sc->mem, vbuf);
1295 		return (ENOMEM);
1296 	}
1297 	m->end = m->start + sz;
1298 	m->speed = 0;
1299 	m->b16 = 0;
1300 	m->stereo = 0;
1301 	m->running = 0;
1302 	m->ismaster = 1;
1303 	m->vol = 0xff;
1304 	m->buf = tmp_addr;
1305 	m->vbuf = vbuf;
1306 	m->slave = s;
1307 	if (s != NULL) {
1308 		s->start = m->start;
1309 		s->end = m->end;
1310 		s->speed = 0;
1311 		s->b16 = 0;
1312 		s->stereo = 0;
1313 		s->running = 0;
1314 		s->ismaster = 0;
1315 		s->vol = m->vol;
1316 		s->buf = m->buf;
1317 		s->vbuf = NULL;
1318 		s->slave = NULL;
1319 	}
1320 	return (0);
1321 }
1322 
1323 void
1324 emu_vsetup(struct emu_voice *v, int fmt, int spd)
1325 {
1326 	if (fmt) {
1327 		v->b16 = (fmt & AFMT_16BIT) ? 1 : 0;
1328 		v->stereo = (fmt & AFMT_STEREO) ? 1 : 0;
1329 		if (v->slave != NULL) {
1330 			v->slave->b16 = v->b16;
1331 			v->slave->stereo = v->stereo;
1332 		}
1333 	}
1334 	if (spd) {
1335 		v->speed = spd;
1336 		if (v->slave != NULL)
1337 			v->slave->speed = v->speed;
1338 	}
1339 }
1340 
1341 void
1342 emu_vroute(struct emu_sc_info *sc, struct emu_route *rt,  struct emu_voice *v)
1343 {
1344 	int i;
1345 
1346 	for (i = 0; i < 8; i++) {
1347 		v->routing[i] = rt->routing_left[i];
1348 		v->amounts[i] = rt->amounts_left[i];
1349 	}
1350 	if ((v->stereo) && (v->ismaster == 0))
1351 		for (i = 0; i < 8; i++) {
1352 			v->routing[i] = rt->routing_right[i];
1353 			v->amounts[i] = rt->amounts_right[i];
1354 		}
1355 
1356 	if ((v->stereo) && (v->slave != NULL))
1357 		emu_vroute(sc, rt, v->slave);
1358 }
1359 
1360 void
1361 emu_vwrite(struct emu_sc_info *sc, struct emu_voice *v)
1362 {
1363 	int s;
1364 	uint32_t start, val, silent_page;
1365 
1366 	s = (v->stereo ? 1 : 0) + (v->b16 ? 1 : 0);
1367 
1368 	v->sa = v->start >> s;
1369 	v->ea = v->end >> s;
1370 
1371 
1372 	if (v->stereo) {
1373 		emu_wrptr(sc, v->vnum, CPF, CPF_STEREO_MASK);
1374 	} else {
1375 		emu_wrptr(sc, v->vnum, CPF, 0);
1376 	}
1377 	val = v->stereo ? 28 : 30;
1378 	val *= v->b16 ? 1 : 2;
1379 	start = v->sa + val;
1380 
1381 	if (sc->is_emu10k1) {
1382 		emu_wrptr(sc, v->vnum, FXRT, ((v->routing[3] << 12) |
1383 		    (v->routing[2] << 8) |
1384 		    (v->routing[1] << 4) |
1385 		    (v->routing[0] << 0)) << 16);
1386 	} else {
1387 		emu_wrptr(sc, v->vnum, A_FXRT1, (v->routing[3] << 24) |
1388 		    (v->routing[2] << 16) |
1389 		    (v->routing[1] << 8) |
1390 		    (v->routing[0] << 0));
1391 		emu_wrptr(sc, v->vnum, A_FXRT2, (v->routing[7] << 24) |
1392 		    (v->routing[6] << 16) |
1393 		    (v->routing[5] << 8) |
1394 		    (v->routing[4] << 0));
1395 		emu_wrptr(sc, v->vnum, A_SENDAMOUNTS, (v->amounts[7] << 24) |
1396 		    (v->amounts[6] << 26) |
1397 		    (v->amounts[5] << 8) |
1398 		    (v->amounts[4] << 0));
1399 	}
1400 	emu_wrptr(sc, v->vnum, PTRX, (v->amounts[0] << 8) | (v->amounts[1] << 0));
1401 	emu_wrptr(sc, v->vnum, DSL, v->ea | (v->amounts[3] << 24));
1402 	emu_wrptr(sc, v->vnum, PSST, v->sa | (v->amounts[2] << 24));
1403 
1404 	emu_wrptr(sc, v->vnum, CCCA, start | (v->b16 ? 0 : CCCA_8BITSELECT));
1405 	emu_wrptr(sc, v->vnum, Z1, 0);
1406 	emu_wrptr(sc, v->vnum, Z2, 0);
1407 
1408 	silent_page = ((uint32_t) (sc->mem.silent_page_addr) << 1) | MAP_PTI_MASK;
1409 	emu_wrptr(sc, v->vnum, MAPA, silent_page);
1410 	emu_wrptr(sc, v->vnum, MAPB, silent_page);
1411 
1412 	emu_wrptr(sc, v->vnum, CVCF, CVCF_CURRENTFILTER_MASK);
1413 	emu_wrptr(sc, v->vnum, VTFT, VTFT_FILTERTARGET_MASK);
1414 	emu_wrptr(sc, v->vnum, ATKHLDM, 0);
1415 	emu_wrptr(sc, v->vnum, DCYSUSM, DCYSUSM_DECAYTIME_MASK);
1416 	emu_wrptr(sc, v->vnum, LFOVAL1, 0x8000);
1417 	emu_wrptr(sc, v->vnum, LFOVAL2, 0x8000);
1418 	emu_wrptr(sc, v->vnum, FMMOD, 0);
1419 	emu_wrptr(sc, v->vnum, TREMFRQ, 0);
1420 	emu_wrptr(sc, v->vnum, FM2FRQ2, 0);
1421 	emu_wrptr(sc, v->vnum, ENVVAL, 0x8000);
1422 
1423 	emu_wrptr(sc, v->vnum, ATKHLDV, ATKHLDV_HOLDTIME_MASK | ATKHLDV_ATTACKTIME_MASK);
1424 	emu_wrptr(sc, v->vnum, ENVVOL, 0x8000);
1425 
1426 	emu_wrptr(sc, v->vnum, PEFE_FILTERAMOUNT, 0x7f);
1427 	emu_wrptr(sc, v->vnum, PEFE_PITCHAMOUNT, 0);
1428 	if ((v->stereo) && (v->slave != NULL))
1429 		emu_vwrite(sc, v->slave);
1430 }
1431 
1432 static void
1433 emu_vstop(struct emu_sc_info *sc, char channel, int enable)
1434 {
1435 	int reg;
1436 
1437 	reg = (channel & 0x20) ? SOLEH : SOLEL;
1438 	channel &= 0x1f;
1439 	reg |= 1 << 24;
1440 	reg |= channel << 16;
1441 	emu_wrptr(sc, 0, reg, enable);
1442 }
1443 
1444 void
1445 emu_vtrigger(struct emu_sc_info *sc, struct emu_voice *v, int go)
1446 {
1447 	uint32_t pitch_target, initial_pitch;
1448 	uint32_t cra, cs, ccis;
1449 	uint32_t sample, i;
1450 
1451 	if (go) {
1452 		cra = 64;
1453 		cs = v->stereo ? 4 : 2;
1454 		ccis = v->stereo ? 28 : 30;
1455 		ccis *= v->b16 ? 1 : 2;
1456 		sample = v->b16 ? 0x00000000 : 0x80808080;
1457 		for (i = 0; i < cs; i++)
1458 			emu_wrptr(sc, v->vnum, CD0 + i, sample);
1459 		emu_wrptr(sc, v->vnum, CCR_CACHEINVALIDSIZE, 0);
1460 		emu_wrptr(sc, v->vnum, CCR_READADDRESS, cra);
1461 		emu_wrptr(sc, v->vnum, CCR_CACHEINVALIDSIZE, ccis);
1462 
1463 		emu_wrptr(sc, v->vnum, IFATN, 0xff00);
1464 		emu_wrptr(sc, v->vnum, VTFT, 0xffffffff);
1465 		emu_wrptr(sc, v->vnum, CVCF, 0xffffffff);
1466 		emu_wrptr(sc, v->vnum, DCYSUSV, 0x00007f7f);
1467 		emu_vstop(sc, v->vnum, 0);
1468 
1469 		pitch_target = emu_rate_to_linearpitch(v->speed);
1470 		initial_pitch = emu_rate_to_pitch(v->speed) >> 8;
1471 		emu_wrptr(sc, v->vnum, PTRX_PITCHTARGET, pitch_target);
1472 		emu_wrptr(sc, v->vnum, CPF_CURRENTPITCH, pitch_target);
1473 		emu_wrptr(sc, v->vnum, IP, initial_pitch);
1474 	} else {
1475 		emu_wrptr(sc, v->vnum, PTRX_PITCHTARGET, 0);
1476 		emu_wrptr(sc, v->vnum, CPF_CURRENTPITCH, 0);
1477 		emu_wrptr(sc, v->vnum, IFATN, 0xffff);
1478 		emu_wrptr(sc, v->vnum, VTFT, 0x0000ffff);
1479 		emu_wrptr(sc, v->vnum, CVCF, 0x0000ffff);
1480 		emu_wrptr(sc, v->vnum, IP, 0);
1481 		emu_vstop(sc, v->vnum, 1);
1482 	}
1483 	if ((v->stereo) && (v->slave != NULL))
1484 		emu_vtrigger(sc, v->slave, go);
1485 }
1486 
1487 int
1488 emu_vpos(struct emu_sc_info *sc, struct emu_voice *v)
1489 {
1490 	int s, ptr;
1491 
1492 	s = (v->b16 ? 1 : 0) + (v->stereo ? 1 : 0);
1493 	ptr = (emu_rdptr(sc, v->vnum, CCCA_CURRADDR) - (v->start >> s)) << s;
1494 	return (ptr & ~0x0000001f);
1495 }
1496 
1497 
1498 /* fx */
1499 static void
1500 emu_wrefx(struct emu_sc_info *sc, unsigned int pc, unsigned int data)
1501 {
1502 	emu_wrptr(sc, 0, sc->code_base + pc, data);
1503 }
1504 
1505 
1506 static void
1507 emu_addefxop(struct emu_sc_info *sc, unsigned int op, unsigned int z, unsigned int w, unsigned int x, unsigned int y, uint32_t * pc)
1508 {
1509 	if ((*pc) + 1 > sc->code_size) {
1510 		device_printf(sc->dev, "DSP CODE OVERRUN: attept to write past code_size (pc=%d)\n", (*pc));
1511 		return;
1512 	}
1513 	emu_wrefx(sc, (*pc) * 2, (x << sc->high_operand_shift) | y);
1514 	emu_wrefx(sc, (*pc) * 2 + 1, (op << sc->opcode_shift) | (z << sc->high_operand_shift) | w);
1515 	(*pc)++;
1516 }
1517 
1518 static int
1519 sysctl_emu_mixer_control(SYSCTL_HANDLER_ARGS)
1520 {
1521 	struct emu_sc_info *sc;
1522 	int	mixer_id;
1523 	int	new_vol;
1524 	int	err;
1525 
1526 	sc = arg1;
1527 	mixer_id = arg2;
1528 
1529 	new_vol = emumix_get_volume(sc, mixer_id);
1530 	err = sysctl_handle_int(oidp, &new_vol, 0, req);
1531 
1532 	if (err || req->newptr == NULL)
1533 		return (err);
1534 	if (new_vol < 0 || new_vol > 100)
1535 		return (EINVAL);
1536 	emumix_set_volume(sc, mixer_id, new_vol);
1537 
1538 	return (0);
1539 }
1540 
1541 static int
1542 emu_addefxmixer(struct emu_sc_info *sc, const char *mix_name, const int mix_id, uint32_t defvolume)
1543 {
1544 	int volgpr;
1545 	char	sysctl_name[32];
1546 
1547 	volgpr = emu_rm_gpr_alloc(sc->rm, 1);
1548 	emumix_set_fxvol(sc, volgpr, defvolume);
1549 	/*
1550 	 * Mixer controls with NULL mix_name are handled
1551 	 * by AC97 emulation code or PCM mixer.
1552 	 */
1553 	if (mix_name != NULL) {
1554 		/*
1555 		 * Temporary sysctls should start with underscore,
1556 		 * see freebsd-current mailing list, emu10kx driver
1557 		 * discussion around 2006-05-24.
1558 		 */
1559 		snprintf(sysctl_name, 32, "_%s", mix_name);
1560 		SYSCTL_ADD_PROC(sc->ctx,
1561 			SYSCTL_CHILDREN(sc->root),
1562 			OID_AUTO, sysctl_name,
1563 			CTLTYPE_INT | CTLFLAG_RW, sc, mix_id,
1564 			sysctl_emu_mixer_control, "I", "");
1565 	}
1566 
1567 	return (volgpr);
1568 }
1569 
1570 static int
1571 sysctl_emu_digitalswitch_control(SYSCTL_HANDLER_ARGS)
1572 {
1573 	struct emu_sc_info *sc;
1574 	int	new_val;
1575 	int	err;
1576 
1577 	sc = arg1;
1578 
1579 	new_val = (sc->mode == MODE_DIGITAL) ? 1 : 0;
1580 	err = sysctl_handle_int(oidp, &new_val, 0, req);
1581 
1582 	if (err || req->newptr == NULL)
1583 		return (err);
1584 	if (new_val < 0 || new_val > 1)
1585 		return (EINVAL);
1586 
1587 	switch (new_val) {
1588 		case 0:
1589 			emumix_set_mode(sc, MODE_ANALOG);
1590 			break;
1591 		case 1:
1592 			emumix_set_mode(sc, MODE_DIGITAL);
1593 			break;
1594 	}
1595 	return (0);
1596 }
1597 
1598 static void
1599 emu_digitalswitch(struct emu_sc_info *sc)
1600 {
1601 	/* XXX temporary? */
1602 	SYSCTL_ADD_PROC(sc->ctx,
1603 		SYSCTL_CHILDREN(sc->root),
1604 		OID_AUTO, "_digital",
1605 		CTLTYPE_INT | CTLFLAG_RW, sc, 0,
1606 		sysctl_emu_digitalswitch_control, "I", "Enable digital output");
1607 
1608 	return;
1609 }
1610 
1611 /*
1612  * Allocate cache GPRs that will hold mixed output channels
1613  * and clear it on every DSP run.
1614  */
1615 #define	EFX_CACHE(CACHE_IDX) do {				\
1616 	sc->cache_gpr[CACHE_IDX] = emu_rm_gpr_alloc(sc->rm, 1); \
1617 	emu_addefxop(sc, ACC3, 					\
1618 		GPR(sc->cache_gpr[CACHE_IDX]), 			\
1619 		DSP_CONST(0), 					\
1620 		DSP_CONST(0), 					\
1621 		DSP_CONST(0), 					\
1622 		&pc);						\
1623 } while (0)
1624 
1625 /* Allocate GPR for volume control and route sound: OUT = OUT + IN * VOL */
1626 #define	EFX_ROUTE(TITLE, INP_NR, IN_GPR_IDX, OUT_CACHE_IDX, DEF) do { 	\
1627 	sc->mixer_gpr[IN_GPR_IDX] = emu_addefxmixer(sc, TITLE, IN_GPR_IDX,  DEF); \
1628 	sc->mixer_volcache[IN_GPR_IDX] = DEF; 			\
1629 	emu_addefxop(sc, MACS, 					\
1630 		GPR(sc->cache_gpr[OUT_CACHE_IDX]), 		\
1631 		GPR(sc->cache_gpr[OUT_CACHE_IDX]),		\
1632 		INP_NR,						\
1633 		GPR(sc->mixer_gpr[IN_GPR_IDX]),			\
1634 		&pc);						\
1635 } while (0)
1636 
1637 /* allocate GPR, OUT = IN * VOL */
1638 #define	EFX_OUTPUT(TITLE, OUT_CACHE_IDX, OUT_GPR_IDX, OUTP_NR, DEF) do {	\
1639 	sc->mixer_gpr[OUT_GPR_IDX] = emu_addefxmixer(sc, TITLE, OUT_GPR_IDX, DEF); \
1640 	sc->mixer_volcache[OUT_GPR_IDX] = DEF;			\
1641 	emu_addefxop(sc, MACS,					\
1642 		OUTP(OUTP_NR),					\
1643 		DSP_CONST(0),					\
1644 		GPR(sc->cache_gpr[OUT_CACHE_IDX]),		\
1645 		GPR(sc->mixer_gpr[OUT_GPR_IDX]),		\
1646 		&pc);						\
1647 } while (0)
1648 
1649 /* like EFX_OUTPUT, but don't allocate mixer gpr */
1650 #define	EFX_OUTPUTD(OUT_CACHE_IDX, OUT_GPR_IDX, OUTP_NR) do {	\
1651 	emu_addefxop(sc, MACS,					\
1652 		OUTP(OUTP_NR),					\
1653 		DSP_CONST(0),					\
1654 		GPR(sc->cache_gpr[OUT_CACHE_IDX]),		\
1655 		GPR(sc->mixer_gpr[OUT_GPR_IDX]),		\
1656 		&pc);						\
1657 } while (0)
1658 
1659 /* skip next OPCOUNT instructions if FLAG != 0 */
1660 #define EFX_SKIP(OPCOUNT, FLAG_GPR) do {			\
1661 	emu_addefxop(sc, MACS,					\
1662 		DSP_CONST(0),					\
1663 		GPR(sc->mute_gpr[FLAG_GPR]),					\
1664 		DSP_CONST(0),					\
1665 		DSP_CONST(0),					\
1666 		&pc);						\
1667 	emu_addefxop(sc, SKIP,					\
1668 		DSP_CCR,					\
1669 		DSP_CCR,					\
1670 		COND_NEQ_ZERO,					\
1671 		OPCOUNT,					\
1672 		&pc);						\
1673 } while (0)
1674 
1675 #define EFX_COPY(TO, FROM) do {					\
1676 	emu_addefxop(sc, ACC3,					\
1677 		TO,						\
1678 		DSP_CONST(0),					\
1679 		DSP_CONST(0),					\
1680 		FROM,						\
1681 		&pc);						\
1682 } while (0)
1683 
1684 
1685 static void
1686 emu_initefx(struct emu_sc_info *sc)
1687 {
1688 	unsigned int i;
1689 	uint32_t pc;
1690 
1691 	/* stop DSP */
1692 	if (sc->is_emu10k1) {
1693 		emu_wrptr(sc, 0, DBG, EMU10K1_DBG_SINGLE_STEP);
1694 	} else {
1695 		emu_wrptr(sc, 0, A_DBG, A_DBG_SINGLE_STEP);
1696 	}
1697 
1698 	/* code size is in instructions */
1699 	pc = 0;
1700 	for (i = 0; i < sc->code_size; i++) {
1701 		if (sc->is_emu10k1) {
1702 			emu_addefxop(sc, ACC3, DSP_CONST(0x0), DSP_CONST(0x0), DSP_CONST(0x0), DSP_CONST(0x0), &pc);
1703 		} else {
1704 			emu_addefxop(sc, SKIP, DSP_CONST(0x0), DSP_CONST(0x0), DSP_CONST(0xf), DSP_CONST(0x0), &pc);
1705 		}
1706 	}
1707 
1708 	/* allocate GPRs for mute switches (EFX_SKIP). Mute by default */
1709 	for (i = 0; i < NUM_MUTE; i++) {
1710 		sc->mute_gpr[i] = emu_rm_gpr_alloc(sc->rm, 1);
1711 		emumix_set_gpr(sc, sc->mute_gpr[i], 1);
1712 	}
1713 	emu_digitalswitch(sc);
1714 
1715 	pc = 0;
1716 
1717 	/*
1718 	 * DSP code below is not good, because:
1719 	 * 1. It can be written smaller, if it can use DSP accumulator register
1720 	 * instead of cache_gpr[].
1721 	 * 2. It can be more careful when volume is 100%, because in DSP
1722 	 * x*0x7fffffff may not be equal to x !
1723 	 */
1724 
1725 	/* clean outputs */
1726 	for (i = 0; i < 16 ; i++) {
1727 		emu_addefxop(sc, ACC3, OUTP(i), DSP_CONST(0), DSP_CONST(0), DSP_CONST(0), &pc);
1728 	}
1729 
1730 
1731 	if (sc->is_emu10k1) {
1732 		EFX_CACHE(C_FRONT_L);
1733 		EFX_CACHE(C_FRONT_R);
1734 		EFX_CACHE(C_REC_L);
1735 		EFX_CACHE(C_REC_R);
1736 
1737 		/* fx0 to front/record, 100%/muted by default */
1738 		EFX_ROUTE("pcm_front_l", FX(0), M_FX0_FRONT_L, C_FRONT_L, 100);
1739 		EFX_ROUTE("pcm_front_r", FX(1), M_FX1_FRONT_R, C_FRONT_R, 100);
1740 		EFX_ROUTE(NULL, FX(0), M_FX0_REC_L, C_REC_L, 0);
1741 		EFX_ROUTE(NULL, FX(1), M_FX1_REC_R, C_REC_R, 0);
1742 
1743 		/* in0, from AC97 codec output */
1744 		EFX_ROUTE("ac97_front_l", INP(IN_AC97_L), M_IN0_FRONT_L, C_FRONT_L, 0);
1745 		EFX_ROUTE("ac97_front_r", INP(IN_AC97_R), M_IN0_FRONT_R, C_FRONT_R, 0);
1746 		EFX_ROUTE("ac97_rec_l", INP(IN_AC97_L), M_IN0_REC_L, C_REC_L, 0);
1747 		EFX_ROUTE("ac97_rec_r", INP(IN_AC97_R), M_IN0_REC_R, C_REC_R, 0);
1748 
1749 		/* in1, from CD S/PDIF */
1750 		/* XXX EFX_SKIP 4 assumes that each EFX_ROUTE is one DSP op */
1751 		EFX_SKIP(4, CDSPDIFMUTE);
1752 		EFX_ROUTE(NULL, INP(IN_SPDIF_CD_L), M_IN1_FRONT_L, C_FRONT_L, 0);
1753 		EFX_ROUTE(NULL, INP(IN_SPDIF_CD_R), M_IN1_FRONT_R, C_FRONT_R, 0);
1754 		EFX_ROUTE(NULL, INP(IN_SPDIF_CD_L), M_IN1_REC_L, C_REC_L, 0);
1755 		EFX_ROUTE(NULL, INP(IN_SPDIF_CD_R), M_IN1_REC_R, C_REC_R, 0);
1756 
1757 		if (sc->dbg_level > 0) {
1758 			/* in2, ZoomVide (???) */
1759 			EFX_ROUTE("zoom_front_l", INP(IN_ZOOM_L), M_IN2_FRONT_L, C_FRONT_L, 0);
1760 			EFX_ROUTE("zoom_front_r", INP(IN_ZOOM_R), M_IN2_FRONT_R, C_FRONT_R, 0);
1761 			EFX_ROUTE("zoom_rec_l", INP(IN_ZOOM_L), M_IN2_REC_L, C_REC_L, 0);
1762 			EFX_ROUTE("zoom_rec_r", INP(IN_ZOOM_R), M_IN2_REC_R, C_REC_R, 0);
1763 		}
1764 
1765 		/* in3, TOSLink  */
1766 		EFX_ROUTE(NULL, INP(IN_TOSLINK_L), M_IN3_FRONT_L, C_FRONT_L, 0);
1767 		EFX_ROUTE(NULL, INP(IN_TOSLINK_R), M_IN3_FRONT_R, C_FRONT_R, 0);
1768 		EFX_ROUTE(NULL, INP(IN_TOSLINK_L), M_IN3_REC_L, C_REC_L, 0);
1769 		EFX_ROUTE(NULL, INP(IN_TOSLINK_R), M_IN3_REC_R, C_REC_R, 0);
1770 		/* in4, LineIn  */
1771 		EFX_ROUTE(NULL, INP(IN_LINE1_L), M_IN4_FRONT_L, C_FRONT_L, 0);
1772 		EFX_ROUTE(NULL, INP(IN_LINE1_R), M_IN4_FRONT_R, C_FRONT_R, 0);
1773 		EFX_ROUTE(NULL, INP(IN_LINE1_L), M_IN4_REC_L, C_REC_L, 0);
1774 		EFX_ROUTE(NULL, INP(IN_LINE1_R), M_IN4_REC_R, C_REC_R, 0);
1775 
1776 		/* in5, on-card S/PDIF */
1777 		EFX_ROUTE(NULL, INP(IN_COAX_SPDIF_L), M_IN5_FRONT_L, C_FRONT_L, 0);
1778 		EFX_ROUTE(NULL, INP(IN_COAX_SPDIF_R), M_IN5_FRONT_R, C_FRONT_R, 0);
1779 		EFX_ROUTE(NULL, INP(IN_COAX_SPDIF_L), M_IN5_REC_L, C_REC_L, 0);
1780 		EFX_ROUTE(NULL, INP(IN_COAX_SPDIF_R), M_IN5_REC_R, C_REC_R, 0);
1781 
1782 		/* in6, Line2 on Live!Drive */
1783 		EFX_ROUTE(NULL, INP(IN_LINE2_L), M_IN6_FRONT_L, C_FRONT_L, 0);
1784 		EFX_ROUTE(NULL, INP(IN_LINE2_R), M_IN6_FRONT_R, C_FRONT_R, 0);
1785 		EFX_ROUTE(NULL, INP(IN_LINE2_L), M_IN6_REC_L, C_REC_L, 0);
1786 		EFX_ROUTE(NULL, INP(IN_LINE2_R), M_IN6_REC_R, C_REC_R, 0);
1787 
1788 		if (sc->dbg_level > 0) {
1789 			/* in7, unknown */
1790 			EFX_ROUTE("in7_front_l", INP(0xE), M_IN7_FRONT_L, C_FRONT_L, 0);
1791 			EFX_ROUTE("in7_front_r", INP(0xF), M_IN7_FRONT_R, C_FRONT_R, 0);
1792 			EFX_ROUTE("in7_rec_l", INP(0xE), M_IN7_REC_L, C_REC_L, 0);
1793 			EFX_ROUTE("in7_rec_r", INP(0xF), M_IN7_REC_R, C_REC_R, 0);
1794 		}
1795 
1796 		/* analog and digital */
1797 		EFX_OUTPUT("master_front_l", C_FRONT_L, M_MASTER_FRONT_L, OUT_AC97_L, 100);
1798 		EFX_OUTPUT("master_front_r", C_FRONT_R, M_MASTER_FRONT_R, OUT_AC97_R, 100);
1799 		/* S/PDIF */
1800 		EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, OUT_TOSLINK_L);
1801 		EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, OUT_TOSLINK_R);
1802 		/* Headphones */
1803 		EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, OUT_HEADPHONE_L);
1804 		EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, OUT_HEADPHONE_R);
1805 
1806 		/* rec output to "ADC" */
1807 		EFX_OUTPUT("master_rec_l", C_REC_L, M_MASTER_REC_L, OUT_ADC_REC_L, 100);
1808 		EFX_OUTPUT("master_rec_r", C_REC_R, M_MASTER_REC_R, OUT_ADC_REC_R, 100);
1809 
1810 		if (!(sc->mch_disabled)) {
1811 			/*
1812 			 * Additional channel volume is controlled by mixer in
1813 			 * emu_dspmixer_set() in -pcm.c
1814 			 */
1815 
1816 			/* fx2/3 (pcm1) to rear */
1817 			EFX_CACHE(C_REAR_L);
1818 			EFX_CACHE(C_REAR_R);
1819 			EFX_ROUTE(NULL, FX(2), M_FX2_REAR_L, C_REAR_L, 100);
1820 			EFX_ROUTE(NULL, FX(3), M_FX3_REAR_R, C_REAR_R, 100);
1821 
1822 			EFX_OUTPUT(NULL, C_REAR_L, M_MASTER_REAR_L, OUT_REAR_L, 100);
1823 			EFX_OUTPUT(NULL, C_REAR_R, M_MASTER_REAR_R, OUT_REAR_R, 100);
1824 			if (sc->has_51) {
1825 				/* fx4 (pcm2) to center */
1826 				EFX_CACHE(C_CENTER);
1827 				EFX_ROUTE(NULL, FX(4), M_FX4_CENTER, C_CENTER, 100);
1828 				EFX_OUTPUT(NULL, C_CENTER, M_MASTER_CENTER, OUT_D_CENTER, 100);
1829 
1830 				/* XXX in digital mode (default) this should be muted because
1831 				this output is shared with digital out */
1832 				EFX_SKIP(1, ANALOGMUTE);
1833 				EFX_OUTPUTD(C_CENTER, M_MASTER_CENTER, OUT_A_CENTER);
1834 
1835 				/* fx5 (pcm3) to sub */
1836 				EFX_CACHE(C_SUB);
1837 				EFX_ROUTE(NULL, FX(5), M_FX5_SUBWOOFER, C_SUB, 100);
1838 				EFX_OUTPUT(NULL, C_SUB, M_MASTER_SUBWOOFER, OUT_D_SUB, 100);
1839 
1840 				/* XXX in digital mode (default) this should be muted because
1841 				this output is shared with digital out */
1842 				EFX_SKIP(1, ANALOGMUTE);
1843 				EFX_OUTPUTD(C_SUB, M_MASTER_SUBWOOFER, OUT_A_SUB);
1844 
1845 			}
1846 		} else {
1847 			/* SND_EMU10KX_MULTICHANNEL_DISABLED */
1848 			EFX_OUTPUT(NULL, C_FRONT_L, M_MASTER_REAR_L, OUT_REAR_L, 57); /* 75%*75% */
1849 			EFX_OUTPUT(NULL, C_FRONT_R, M_MASTER_REAR_R, OUT_REAR_R, 57); /* 75%*75% */
1850 
1851 #if 0
1852 			/* XXX 5.1 does not work */
1853 
1854 			if (sc->has_51) {
1855 				/* (fx0+fx1)/2 to center */
1856 				EFX_CACHE(C_CENTER);
1857 				emu_addefxop(sc, MACS,
1858 					GPR(sc->cache_gpr[C_CENTER]),
1859 					GPR(sc->cache_gpr[C_CENTER]),
1860 					DSP_CONST(0xd), /* = 1/2 */
1861 					GPR(sc->cache_gpr[C_FRONT_L]),
1862 					&pc);
1863 				emu_addefxop(sc, MACS,
1864 					GPR(sc->cache_gpr[C_CENTER]),
1865 					GPR(sc->cache_gpr[C_CENTER]),
1866 					DSP_CONST(0xd), /* = 1/2 */
1867 					GPR(sc->cache_gpr[C_FRONT_R]),
1868 					&pc);
1869 				EFX_OUTPUT(NULL, C_CENTER, M_MASTER_CENTER, OUT_D_CENTER, 100);
1870 
1871 				/* XXX in digital mode (default) this should be muted because
1872 				this output is shared with digital out */
1873 				EFX_SKIP(1, ANALOGMUTE);
1874 				EFX_OUTPUTD(C_CENTER, M_MASTER_CENTER, OUT_A_CENTER);
1875 
1876 				/* (fx0+fx1)/2  to sub */
1877 				EFX_CACHE(C_SUB);
1878 				emu_addefxop(sc, MACS,
1879 					GPR(sc->cache_gpr[C_CENTER]),
1880 					GPR(sc->cache_gpr[C_CENTER]),
1881 					DSP_CONST(0xd), /* = 1/2 */
1882 					GPR(sc->cache_gpr[C_FRONT_L]),
1883 					&pc);
1884 				emu_addefxop(sc, MACS,
1885 					GPR(sc->cache_gpr[C_CENTER]),
1886 					GPR(sc->cache_gpr[C_CENTER]),
1887 					DSP_CONST(0xd), /* = 1/2 */
1888 					GPR(sc->cache_gpr[C_FRONT_R]),
1889 					&pc);
1890 				/* XXX add lowpass filter here */
1891 
1892 				EFX_OUTPUT(NULL, C_SUB, M_MASTER_SUBWOOFER, OUT_D_SUB, 100);
1893 
1894 				/* XXX in digital mode (default) this should be muted because
1895 				this output is shared with digital out */
1896 				EFX_SKIP(1, ANALOGMUTE);
1897 				EFX_OUTPUTD(C_SUB, M_MASTER_SUBWOOFER, OUT_A_SUB);
1898 			}
1899 #endif
1900 		} /* !mch_disabled */
1901 		if (sc->mch_rec) {
1902 			/*
1903 			 * MCH RECORDING , hight 16 slots. On 5.1 cards first 4 slots
1904 			 * are used as outputs and already filled with data
1905 			 */
1906 			/*
1907 			 * XXX On Live! cards stream does not begin at zero offset.
1908 			 * It can be HW, driver or sound buffering problem.
1909 			 * Use sync substream (offset 0x3E) to let userland find
1910 			 * correct data.
1911 			 */
1912 
1913 			/*
1914 			 * Substream map (in byte offsets, each substream is 2 bytes):
1915 			 *	0x00..0x1E - outputs
1916 			 *	0x20..0x3E - FX, inputs ans sync stream
1917 			 */
1918 
1919 			/* First 2 channels (offset 0x20,0x22) are empty */
1920 			for(i = (sc->has_51 ? 2 : 0); i < 2; i++)
1921 				EFX_COPY(FX2(i), DSP_CONST(0));
1922 
1923 			/* PCM Playback monitoring, offset 0x24..0x2A */
1924 			for(i = 0; i < 4; i++)
1925 				EFX_COPY(FX2(i+2), FX(i));
1926 
1927 			/* Copy of some inputs, offset 0x2C..0x3C */
1928 			for(i = 0; i < 9; i++)
1929 				EFX_COPY(FX2(i+8), INP(i));
1930 
1931 			/* sync data (0xc0de, offset 0x3E) */
1932 			sc->dummy_gpr = emu_rm_gpr_alloc(sc->rm, 1);
1933 			emumix_set_gpr(sc, sc->dummy_gpr, 0xc0de0000);
1934 
1935 			EFX_COPY(FX2(15), GPR(sc->dummy_gpr));
1936 		} /* mch_rec */
1937 	} else /* emu10k2 and later */ {
1938 		EFX_CACHE(C_FRONT_L);
1939 		EFX_CACHE(C_FRONT_R);
1940 		EFX_CACHE(C_REC_L);
1941 		EFX_CACHE(C_REC_R);
1942 
1943 		/* fx0 to front/record, 100%/muted by default */
1944 		/*
1945 		 * FRONT_[L|R] is controlled by AC97 emulation in
1946 		 * emu_ac97_[read|write]_emulation in -pcm.c
1947 		 */
1948 		EFX_ROUTE(NULL, FX(0), M_FX0_FRONT_L, C_FRONT_L, 100);
1949 		EFX_ROUTE(NULL, FX(1), M_FX1_FRONT_R, C_FRONT_R, 100);
1950 		EFX_ROUTE(NULL, FX(0), M_FX0_REC_L, C_REC_L, 0);
1951 		EFX_ROUTE(NULL, FX(1), M_FX1_REC_R, C_REC_R, 0);
1952 
1953 		/* in0, from AC97 codec output */
1954 		EFX_ROUTE(NULL, INP(A_IN_AC97_L), M_IN0_FRONT_L, C_FRONT_L, 100);
1955 		EFX_ROUTE(NULL, INP(A_IN_AC97_R), M_IN0_FRONT_R, C_FRONT_R, 100);
1956 		EFX_ROUTE(NULL, INP(A_IN_AC97_L), M_IN0_REC_L, C_REC_L, 0);
1957 		EFX_ROUTE(NULL, INP(A_IN_AC97_R), M_IN0_REC_R, C_REC_R, 0);
1958 
1959 		/* in1, from CD S/PDIF */
1960 		EFX_ROUTE(NULL, INP(A_IN_SPDIF_CD_L), M_IN1_FRONT_L, C_FRONT_L, 0);
1961 		EFX_ROUTE(NULL, INP(A_IN_SPDIF_CD_R), M_IN1_FRONT_R, C_FRONT_R, 0);
1962 		EFX_ROUTE(NULL, INP(A_IN_SPDIF_CD_L), M_IN1_REC_L, C_REC_L, 0);
1963 		EFX_ROUTE(NULL, INP(A_IN_SPDIF_CD_R), M_IN1_REC_R, C_REC_R, 0);
1964 
1965 		/* in2, optical & coax S/PDIF on AudigyDrive*/
1966 		/* XXX Should be muted when GPRSCS valid stream == 0 */
1967 		EFX_ROUTE(NULL, INP(A_IN_O_SPDIF_L), M_IN2_FRONT_L, C_FRONT_L, 0);
1968 		EFX_ROUTE(NULL, INP(A_IN_O_SPDIF_R), M_IN2_FRONT_R, C_FRONT_R, 0);
1969 		EFX_ROUTE(NULL, INP(A_IN_O_SPDIF_L), M_IN2_REC_L, C_REC_L, 0);
1970 		EFX_ROUTE(NULL, INP(A_IN_O_SPDIF_R), M_IN2_REC_R, C_REC_R, 0);
1971 
1972 		if (sc->dbg_level > 0) {
1973 			/* in3, unknown */
1974 			EFX_ROUTE("in3_front_l", INP(0x6), M_IN3_FRONT_L, C_FRONT_L, 0);
1975 			EFX_ROUTE("in3_front_r", INP(0x7), M_IN3_FRONT_R, C_FRONT_R, 0);
1976 			EFX_ROUTE("in3_rec_l", INP(0x6), M_IN3_REC_L, C_REC_L, 0);
1977 			EFX_ROUTE("in3_rec_r", INP(0x7), M_IN3_REC_R, C_REC_R, 0);
1978 		}
1979 
1980 		/* in4, LineIn 2 on AudigyDrive */
1981 		EFX_ROUTE(NULL, INP(A_IN_LINE2_L), M_IN4_FRONT_L, C_FRONT_L, 0);
1982 		EFX_ROUTE(NULL, INP(A_IN_LINE2_R), M_IN4_FRONT_R, C_FRONT_R, 0);
1983 		EFX_ROUTE(NULL, INP(A_IN_LINE2_L), M_IN4_REC_L, C_REC_L, 0);
1984 		EFX_ROUTE(NULL, INP(A_IN_LINE2_R), M_IN4_REC_R, C_REC_R, 0);
1985 
1986 		/* in5, on-card S/PDIF */
1987 		EFX_ROUTE(NULL, INP(A_IN_R_SPDIF_L), M_IN5_FRONT_L, C_FRONT_L, 0);
1988 		EFX_ROUTE(NULL, INP(A_IN_R_SPDIF_R), M_IN5_FRONT_R, C_FRONT_R, 0);
1989 		EFX_ROUTE(NULL, INP(A_IN_R_SPDIF_L), M_IN5_REC_L, C_REC_L, 0);
1990 		EFX_ROUTE(NULL, INP(A_IN_R_SPDIF_R), M_IN5_REC_R, C_REC_R, 0);
1991 
1992 		/* in6, AUX2 on AudigyDrive */
1993 		EFX_ROUTE(NULL, INP(A_IN_AUX2_L), M_IN6_FRONT_L, C_FRONT_L, 0);
1994 		EFX_ROUTE(NULL, INP(A_IN_AUX2_R), M_IN6_FRONT_R, C_FRONT_R, 0);
1995 		EFX_ROUTE(NULL, INP(A_IN_AUX2_L), M_IN6_REC_L, C_REC_L, 0);
1996 		EFX_ROUTE(NULL, INP(A_IN_AUX2_R), M_IN6_REC_R, C_REC_R, 0);
1997 
1998 		if (sc->dbg_level > 0) {
1999 			/* in7, unknown */
2000 			EFX_ROUTE("in7_front_l", INP(0xE), M_IN7_FRONT_L, C_FRONT_L, 0);
2001 			EFX_ROUTE("in7_front_r", INP(0xF), M_IN7_FRONT_R, C_FRONT_R, 0);
2002 			EFX_ROUTE("in7_rec_l", INP(0xE), M_IN7_REC_L, C_REC_L, 0);
2003 			EFX_ROUTE("in7_rec_r", INP(0xF), M_IN7_REC_R, C_REC_R, 0);
2004 		}
2005 
2006 		/* front output to headphones and  alog and digital *front */
2007 		/* volume controlled by AC97 emulation */
2008 		EFX_OUTPUT(NULL, C_FRONT_L, M_MASTER_FRONT_L, A_OUT_A_FRONT_L, 100);
2009 		EFX_OUTPUT(NULL, C_FRONT_R, M_MASTER_FRONT_R, A_OUT_A_FRONT_R, 100);
2010 		EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, A_OUT_D_FRONT_L);
2011 		EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, A_OUT_D_FRONT_R);
2012 		EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, A_OUT_HPHONE_L);
2013 		EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, A_OUT_HPHONE_R);
2014 
2015 		/* rec output to "ADC" */
2016 		/* volume controlled by AC97 emulation */
2017 		EFX_OUTPUT(NULL, C_REC_L, M_MASTER_REC_L, A_OUT_ADC_REC_L, 100);
2018 		EFX_OUTPUT(NULL, C_REC_R, M_MASTER_REC_R, A_OUT_ADC_REC_R, 100);
2019 
2020 		if (!(sc->mch_disabled)) {
2021 			/*
2022 			 * Additional channel volume is controlled by mixer in
2023 			 * emu_dspmixer_set() in -pcm.c
2024 			 */
2025 
2026 			/* fx2/3 (pcm1) to rear */
2027 			EFX_CACHE(C_REAR_L);
2028 			EFX_CACHE(C_REAR_R);
2029 			EFX_ROUTE(NULL, FX(2), M_FX2_REAR_L, C_REAR_L, 100);
2030 			EFX_ROUTE(NULL, FX(3), M_FX3_REAR_R, C_REAR_R, 100);
2031 
2032 			EFX_OUTPUT(NULL, C_REAR_L, M_MASTER_REAR_L, A_OUT_A_REAR_L, 100);
2033 			EFX_OUTPUT(NULL, C_REAR_R, M_MASTER_REAR_R, A_OUT_A_REAR_R, 100);
2034 			EFX_OUTPUTD(C_REAR_L, M_MASTER_REAR_L, A_OUT_D_REAR_L);
2035 			EFX_OUTPUTD(C_REAR_R, M_MASTER_REAR_R, A_OUT_D_REAR_R);
2036 
2037 			/* fx4 (pcm2) to center */
2038 			EFX_CACHE(C_CENTER);
2039 			EFX_ROUTE(NULL, FX(4), M_FX4_CENTER, C_CENTER, 100);
2040 			EFX_OUTPUT(NULL, C_CENTER, M_MASTER_CENTER, A_OUT_D_CENTER, 100);
2041 #if 0
2042 			/*
2043 			 * XXX in digital mode (default) this should be muted
2044 			 * because this output is shared with digital out
2045 			 */
2046 			EFX_OUTPUTD(C_CENTER, M_MASTER_CENTER, A_OUT_A_CENTER);
2047 #endif
2048 			/* fx5 (pcm3) to sub */
2049 			EFX_CACHE(C_SUB);
2050 			EFX_ROUTE(NULL, FX(5), M_FX5_SUBWOOFER, C_SUB, 100);
2051 			EFX_OUTPUT(NULL, C_SUB, M_MASTER_SUBWOOFER, A_OUT_D_SUB, 100);
2052 #if 0
2053 			/*
2054 			 * XXX in digital mode (default) this should be muted
2055 			 * because this output is shared with digital out
2056 			 */
2057 			EFX_OUTPUTD(C_SUB, M_MASTER_SUBWOOFER, A_OUT_A_SUB);
2058 #endif
2059 			if (sc->has_71) {
2060 				/* XXX this will broke headphones on AudigyDrive */
2061 				/* fx6/7 (pcm4) to side */
2062 				EFX_CACHE(C_SIDE_L);
2063 				EFX_CACHE(C_SIDE_R);
2064 				EFX_ROUTE(NULL, FX(6), M_FX6_SIDE_L, C_SIDE_L, 100);
2065 				EFX_ROUTE(NULL, FX(7), M_FX7_SIDE_R, C_SIDE_R, 100);
2066 				EFX_OUTPUT(NULL, C_SIDE_L, M_MASTER_SIDE_L, A_OUT_A_SIDE_L, 100);
2067 				EFX_OUTPUT(NULL, C_SIDE_R, M_MASTER_SIDE_R, A_OUT_A_SIDE_R, 100);
2068 				EFX_OUTPUTD(C_SIDE_L, M_MASTER_SIDE_L, A_OUT_D_SIDE_L);
2069 				EFX_OUTPUTD(C_SIDE_R, M_MASTER_SIDE_R, A_OUT_D_SIDE_R);
2070 			}
2071 		} else {	/* mch_disabled */
2072 			EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, A_OUT_A_REAR_L);
2073 			EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, A_OUT_A_REAR_R);
2074 
2075 			EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, A_OUT_D_REAR_L);
2076 			EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, A_OUT_D_REAR_R);
2077 
2078 			if (sc->has_51) {
2079 				/* (fx0+fx1)/2 to center */
2080 				EFX_CACHE(C_CENTER);
2081 				emu_addefxop(sc, MACS,
2082 					GPR(sc->cache_gpr[C_CENTER]),
2083 					GPR(sc->cache_gpr[C_CENTER]),
2084 					DSP_CONST(0xd), /* = 1/2 */
2085 					GPR(sc->cache_gpr[C_FRONT_L]),
2086 					&pc);
2087 				emu_addefxop(sc, MACS,
2088 					GPR(sc->cache_gpr[C_CENTER]),
2089 					GPR(sc->cache_gpr[C_CENTER]),
2090 					DSP_CONST(0xd), /* = 1/2 */
2091 					GPR(sc->cache_gpr[C_FRONT_R]),
2092 					&pc);
2093 				EFX_OUTPUT(NULL, C_CENTER, M_MASTER_CENTER, A_OUT_D_CENTER, 100);
2094 
2095 				/* XXX in digital mode (default) this should be muted because
2096 				this output is shared with digital out */
2097 				EFX_SKIP(1, ANALOGMUTE);
2098 				EFX_OUTPUTD(C_CENTER, M_MASTER_CENTER, A_OUT_A_CENTER);
2099 
2100 				/* (fx0+fx1)/2  to sub */
2101 				EFX_CACHE(C_SUB);
2102 				emu_addefxop(sc, MACS,
2103 					GPR(sc->cache_gpr[C_SUB]),
2104 					GPR(sc->cache_gpr[C_SUB]),
2105 					DSP_CONST(0xd), /* = 1/2 */
2106 					GPR(sc->cache_gpr[C_FRONT_L]),
2107 					&pc);
2108 				emu_addefxop(sc, MACS,
2109 					GPR(sc->cache_gpr[C_SUB]),
2110 					GPR(sc->cache_gpr[C_SUB]),
2111 					DSP_CONST(0xd), /* = 1/2 */
2112 					GPR(sc->cache_gpr[C_FRONT_R]),
2113 					&pc);
2114 				/* XXX add lowpass filter here */
2115 
2116 				EFX_OUTPUT(NULL, C_SUB, M_MASTER_SUBWOOFER, A_OUT_D_SUB, 100);
2117 
2118 				/* XXX in digital mode (default) this should be muted because
2119 				this output is shared with digital out */
2120 				EFX_SKIP(1, ANALOGMUTE);
2121 				EFX_OUTPUTD(C_SUB, M_MASTER_SUBWOOFER, A_OUT_A_SUB);
2122 			}
2123 		} /* mch_disabled */
2124 		if (sc->mch_rec) {
2125 			/* MCH RECORDING, high 32 slots */
2126 
2127 			/*
2128 			 * Stream map (in byte offsets):
2129 			 *	0x00..0x3E - outputs
2130 			 *	0x40..0x7E - FX, inputs
2131 			 *	each substream is 2 bytes.
2132 			 */
2133 			/*
2134 			 * XXX Audigy 2 Value cards (and, possibly,
2135 			 * Audigy 4) write some unknown data in place of
2136 			 * some outputs (offsets 0x20..0x3F) and one
2137 			 * input (offset 0x7E).
2138 			 */
2139 
2140 			/* PCM Playback monitoring, offsets 0x40..0x5E */
2141 			for(i = 0; i < 16; i++)
2142 				EFX_COPY(FX2(i), FX(i));
2143 
2144 			/* Copy of all inputs, offsets 0x60..0x7E */
2145 			for(i = 0; i < 16; i++)
2146 				EFX_COPY(FX2(i+16), INP(i));
2147 #if 0
2148 			/* XXX Audigy seems to work correct and does not need this */
2149 			/* sync data (0xc0de), offset 0x7E */
2150 			sc->dummy_gpr = emu_rm_gpr_alloc(sc->rm, 1);
2151 			emumix_set_gpr(sc, sc->dummy_gpr, 0xc0de0000);
2152 			EFX_COPY(FX2(31), GPR(sc->dummy_gpr));
2153 #endif
2154 		} /* mch_rec */
2155 	}
2156 
2157 	sc->routing_code_end = pc;
2158 
2159 	/* start DSP */
2160 	if (sc->is_emu10k1) {
2161 		emu_wrptr(sc, 0, DBG, 0);
2162 	} else {
2163 		emu_wrptr(sc, 0, A_DBG, 0);
2164 	}
2165 }
2166 
2167 /* /dev/em10kx */
2168 static d_open_t		emu10kx_open;
2169 static d_close_t	emu10kx_close;
2170 static d_read_t		emu10kx_read;
2171 
2172 static struct cdevsw emu10kx_cdevsw = {
2173 	.d_open = 	emu10kx_open,
2174 	.d_close =	emu10kx_close,
2175 	.d_read = 	emu10kx_read,
2176 	.d_name = 	"emu10kx",
2177 	.d_version = 	D_VERSION,
2178 };
2179 
2180 
2181 static int
2182 emu10kx_open(struct cdev *i_dev, int flags __unused, int mode __unused, struct thread *td __unused)
2183 {
2184 	int error;
2185 	struct emu_sc_info *sc;
2186 
2187 	sc = i_dev->si_drv1;
2188 	mtx_lock(&sc->emu10kx_lock);
2189 	if (sc->emu10kx_isopen) {
2190 		mtx_unlock(&sc->emu10kx_lock);
2191 		return (EBUSY);
2192 	}
2193 	sc->emu10kx_isopen = 1;
2194 	mtx_unlock(&sc->emu10kx_lock);
2195 	if (sbuf_new(&sc->emu10kx_sbuf, NULL, 4096, 0) == NULL) {
2196 		error = ENXIO;
2197 		goto out;
2198 	}
2199 	sc->emu10kx_bufptr = 0;
2200 	error = (emu10kx_prepare(sc, &sc->emu10kx_sbuf) > 0) ? 0 : ENOMEM;
2201 out:
2202 	if (error) {
2203 		mtx_lock(&sc->emu10kx_lock);
2204 		sc->emu10kx_isopen = 0;
2205 		mtx_unlock(&sc->emu10kx_lock);
2206 	}
2207 	return (error);
2208 }
2209 
2210 static int
2211 emu10kx_close(struct cdev *i_dev, int flags __unused, int mode __unused, struct thread *td __unused)
2212 {
2213 	struct emu_sc_info *sc;
2214 
2215 	sc = i_dev->si_drv1;
2216 
2217 	mtx_lock(&sc->emu10kx_lock);
2218 	if (!(sc->emu10kx_isopen)) {
2219 		mtx_unlock(&sc->emu10kx_lock);
2220 		return (EBADF);
2221 	}
2222 	sbuf_delete(&sc->emu10kx_sbuf);
2223 	sc->emu10kx_isopen = 0;
2224 	mtx_unlock(&sc->emu10kx_lock);
2225 
2226 	return (0);
2227 }
2228 
2229 static int
2230 emu10kx_read(struct cdev *i_dev, struct uio *buf, int flag __unused)
2231 {
2232 	int l, err;
2233 	struct emu_sc_info *sc;
2234 
2235 	sc = i_dev->si_drv1;
2236 	mtx_lock(&sc->emu10kx_lock);
2237 	if (!(sc->emu10kx_isopen)) {
2238 		mtx_unlock(&sc->emu10kx_lock);
2239 		return (EBADF);
2240 	}
2241 	mtx_unlock(&sc->emu10kx_lock);
2242 
2243 	l = min(buf->uio_resid, sbuf_len(&sc->emu10kx_sbuf) - sc->emu10kx_bufptr);
2244 	err = (l > 0) ? uiomove(sbuf_data(&sc->emu10kx_sbuf) + sc->emu10kx_bufptr, l, buf) : 0;
2245 	sc->emu10kx_bufptr += l;
2246 
2247 	return (err);
2248 }
2249 
2250 static int
2251 emu10kx_prepare(struct emu_sc_info *sc, struct sbuf *s)
2252 {
2253 	int i;
2254 
2255 	sbuf_printf(s, "FreeBSD EMU10Kx Audio Driver\n");
2256 	sbuf_printf(s, "\nHardware resource usage:\n");
2257 	sbuf_printf(s, "DSP General Purpose Registers: %d used, %d total\n", sc->rm->num_used, sc->rm->num_gprs);
2258 	sbuf_printf(s, "DSP Instruction Registers: %d used, %d total\n", sc->routing_code_end, sc->code_size);
2259 	sbuf_printf(s, "Card supports");
2260 	if (sc->has_ac97) {
2261 		sbuf_printf(s, " AC97 codec");
2262 	} else {
2263 		sbuf_printf(s, " NO AC97 codec");
2264 	}
2265 	if (sc->has_51) {
2266 		if (sc->has_71)
2267 			sbuf_printf(s, " and 7.1 output");
2268 		else
2269 			sbuf_printf(s, " and 5.1 output");
2270 	}
2271 	if (sc->is_emu10k1)
2272 		sbuf_printf(s, ", SBLive! DSP code");
2273 	if (sc->is_emu10k2)
2274 		sbuf_printf(s, ", Audigy DSP code");
2275 	if (sc->is_ca0102)
2276 		sbuf_printf(s, ", Audigy DSP code with Audigy2 hacks");
2277 	if (sc->is_ca0108)
2278 		sbuf_printf(s, ", Audigy DSP code with Audigy2Value hacks");
2279 	sbuf_printf(s, "\n");
2280 	if (sc->broken_digital)
2281 		sbuf_printf(s, "Digital mode unsupported\n");
2282 	sbuf_printf(s, "\nInstalled devices:\n");
2283 	for (i = 0; i < RT_COUNT; i++)
2284 		if (sc->pcm[i] != NULL)
2285 			if (device_is_attached(sc->pcm[i])) {
2286 				sbuf_printf(s, "%s on %s\n", device_get_desc(sc->pcm[i]), device_get_nameunit(sc->pcm[i]));
2287 			}
2288 	if (sc->midi[0] != NULL)
2289 		if (device_is_attached(sc->midi[0])) {
2290 			sbuf_printf(s, "EMU10Kx MIDI Interface\n");
2291 			sbuf_printf(s, "\tOn-card connector on %s\n", device_get_nameunit(sc->midi[0]));
2292 		}
2293 	if (sc->midi[1] != NULL)
2294 		if (device_is_attached(sc->midi[1])) {
2295 			sbuf_printf(s, "\tOn-Drive connector on %s\n", device_get_nameunit(sc->midi[1]));
2296 		}
2297 	if (sc->midi[0] != NULL)
2298 		if (device_is_attached(sc->midi[0])) {
2299 			sbuf_printf(s, "\tIR reciever MIDI events %s\n", sc->enable_ir ? "enabled" : "disabled");
2300 		}
2301 	sbuf_printf(s, "Card is in %s mode\n", (sc->mode == MODE_ANALOG) ? "analog" : "digital");
2302 
2303 	sbuf_finish(s);
2304 	return (sbuf_len(s));
2305 }
2306 
2307 /* INIT & UNINIT */
2308 static int
2309 emu10kx_dev_init(struct emu_sc_info *sc)
2310 {
2311 	int unit;
2312 
2313 	mtx_init(&sc->emu10kx_lock, device_get_nameunit(sc->dev), "kxdevlock", 0);
2314 	unit = device_get_unit(sc->dev);
2315 
2316 	sc->cdev = make_dev(&emu10kx_cdevsw, unit, UID_ROOT, GID_WHEEL, 0640, "emu10kx%d", unit);
2317 	if (sc->cdev != NULL) {
2318 		sc->cdev->si_drv1 = sc;
2319 		return (0);
2320 	}
2321 	return (ENXIO);
2322 }
2323 
2324 static int
2325 emu10kx_dev_uninit(struct emu_sc_info *sc)
2326 {
2327 	mtx_lock(&sc->emu10kx_lock);
2328 	if (sc->emu10kx_isopen) {
2329 		mtx_unlock(&sc->emu10kx_lock);
2330 		return (EBUSY);
2331 	}
2332 	if (sc->cdev)
2333 		destroy_dev(sc->cdev);
2334 	sc->cdev = 0;
2335 
2336 	mtx_destroy(&sc->emu10kx_lock);
2337 	return (0);
2338 }
2339 
2340 /* resource manager */
2341 int
2342 emu_rm_init(struct emu_sc_info *sc)
2343 {
2344 	int i;
2345 	int maxcount;
2346 	struct emu_rm *rm;
2347 
2348 	rm = malloc(sizeof(struct emu_rm), M_DEVBUF, M_NOWAIT | M_ZERO);
2349 	if (rm == NULL) {
2350 		return (ENOMEM);
2351 	}
2352 	sc->rm = rm;
2353 	rm->card = sc;
2354 	maxcount = sc->num_gprs;
2355 	rm->num_used = 0;
2356 	mtx_init(&(rm->gpr_lock), device_get_nameunit(sc->dev), "gpr alloc", MTX_DEF);
2357 	rm->num_gprs = (maxcount < EMU_MAX_GPR ? maxcount : EMU_MAX_GPR);
2358 	for (i = 0; i < rm->num_gprs; i++)
2359 		rm->allocmap[i] = 0;
2360 	/* pre-allocate gpr[0] */
2361 	rm->allocmap[0] = 1;
2362 	rm->last_free_gpr = 1;
2363 
2364 	return (0);
2365 }
2366 
2367 int
2368 emu_rm_uninit(struct emu_sc_info *sc)
2369 {
2370 	int i;
2371 
2372 	if (sc->dbg_level > 1) {
2373 		mtx_lock(&(sc->rm->gpr_lock));
2374 		for (i = 1; i < sc->rm->last_free_gpr; i++)
2375 			if (sc->rm->allocmap[i] > 0)
2376 				device_printf(sc->dev, "rm: gpr %d not free before uninit\n", i);
2377 		mtx_unlock(&(sc->rm->gpr_lock));
2378 	}
2379 
2380 	mtx_destroy(&(sc->rm->gpr_lock));
2381 	free(sc->rm, M_DEVBUF);
2382 	return (0);
2383 }
2384 
2385 static int
2386 emu_rm_gpr_alloc(struct emu_rm *rm, int count)
2387 {
2388 	int i, j;
2389 	int allocated_gpr;
2390 
2391 	allocated_gpr = rm->num_gprs;
2392 	/* try fast way first */
2393 	mtx_lock(&(rm->gpr_lock));
2394 	if (rm->last_free_gpr + count <= rm->num_gprs) {
2395 		allocated_gpr = rm->last_free_gpr;
2396 		rm->last_free_gpr += count;
2397 		rm->allocmap[allocated_gpr] = count;
2398 		for (i = 1; i < count; i++)
2399 			rm->allocmap[allocated_gpr + i] = -(count - i);
2400 	} else {
2401 		/* longer */
2402 		i = 0;
2403 		allocated_gpr = rm->num_gprs;
2404 		while (i < rm->last_free_gpr - count) {
2405 			if (rm->allocmap[i] > 0) {
2406 				i += rm->allocmap[i];
2407 			} else {
2408 				allocated_gpr = i;
2409 				for (j = 1; j < count; j++) {
2410 					if (rm->allocmap[i + j] != 0)
2411 						allocated_gpr = rm->num_gprs;
2412 				}
2413 				if (allocated_gpr == i)
2414 					break;
2415 			}
2416 		}
2417 		if (allocated_gpr + count < rm->last_free_gpr) {
2418 			rm->allocmap[allocated_gpr] = count;
2419 			for (i = 1; i < count; i++)
2420 				rm->allocmap[allocated_gpr + i] = -(count - i);
2421 
2422 		}
2423 	}
2424 	if (allocated_gpr == rm->num_gprs)
2425 		allocated_gpr = (-1);
2426 	if (allocated_gpr >= 0)
2427 		rm->num_used += count;
2428 	mtx_unlock(&(rm->gpr_lock));
2429 	return (allocated_gpr);
2430 }
2431 
2432 /* mixer */
2433 void
2434 emumix_set_mode(struct emu_sc_info *sc, int mode)
2435 {
2436 	uint32_t a_iocfg;
2437 	uint32_t hcfg;
2438 	uint32_t tmp;
2439 
2440 	switch (mode) {
2441 	case MODE_DIGITAL:
2442 		/* FALLTHROUGH */
2443 	case MODE_ANALOG:
2444 		break;
2445 	default:
2446 		return;
2447 	}
2448 
2449 	hcfg = HCFG_AUDIOENABLE | HCFG_AUTOMUTE;
2450 	a_iocfg = 0;
2451 
2452 	if (sc->rev >= 6)
2453 		hcfg |= HCFG_JOYENABLE;
2454 
2455 	if (sc->is_emu10k1)
2456 		hcfg |= HCFG_LOCKTANKCACHE_MASK;
2457 	else
2458 		hcfg |= HCFG_CODECFORMAT_I2S | HCFG_JOYENABLE;
2459 
2460 
2461 	if (mode == MODE_DIGITAL) {
2462 		if (sc->broken_digital) {
2463 			device_printf(sc->dev, "Digital mode is reported as broken on this card.\n");
2464 		}
2465 		a_iocfg |= A_IOCFG_ENABLE_DIGITAL;
2466 		hcfg |= HCFG_GPOUT0;
2467 	}
2468 
2469 	if (mode == MODE_ANALOG)
2470 		emumix_set_spdif_mode(sc, SPDIF_MODE_PCM);
2471 
2472 	if (sc->is_emu10k2)
2473 		a_iocfg |= 0x80; /* XXX */
2474 
2475 	if ((sc->is_ca0102) || (sc->is_ca0108))
2476 		/*
2477 		 * Setting A_IOCFG_DISABLE_ANALOG will do opposite things
2478 		 * on diffrerent cards.
2479 		 * "don't disable analog outs" on Audigy 2 (ca0102/ca0108)
2480 		 * "disable analog outs" on Audigy (emu10k2)
2481 		 */
2482 		a_iocfg |= A_IOCFG_DISABLE_ANALOG;
2483 
2484 	if (sc->is_ca0108)
2485 		a_iocfg |= 0x20; /* XXX */
2486 
2487 	/* Mute analog center & subwoofer before mode change */
2488 	if (mode == MODE_DIGITAL)
2489 		emumix_set_gpr(sc, sc->mute_gpr[ANALOGMUTE], 1);
2490 
2491 	emu_wr(sc, HCFG, hcfg, 4);
2492 
2493 	if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2494 		tmp = emu_rd(sc, A_IOCFG, 2);
2495 		tmp = a_iocfg;
2496 		emu_wr(sc, A_IOCFG, tmp, 2);
2497 	}
2498 
2499 	/* Unmute if we have changed mode to analog. */
2500 
2501 	if (mode == MODE_ANALOG)
2502 		emumix_set_gpr(sc, sc->mute_gpr[ANALOGMUTE], 0);
2503 
2504 	sc->mode = mode;
2505 }
2506 
2507 void
2508 emumix_set_spdif_mode(struct emu_sc_info *sc, int mode)
2509 {
2510 	uint32_t spcs;
2511 
2512 	switch (mode) {
2513 	case SPDIF_MODE_PCM:
2514 		break;
2515 	case SPDIF_MODE_AC3:
2516 		device_printf(sc->dev, "AC3 mode does not work and disabled\n");
2517 		return;
2518 	default:
2519 		return;
2520 	}
2521 
2522 	spcs = SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
2523 	    SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
2524 	    SPCS_GENERATIONSTATUS | 0x00001200 | 0x00000000 |
2525 	    SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT;
2526 
2527 	mode = SPDIF_MODE_PCM;
2528 
2529 	emu_wrptr(sc, 0, SPCS0, spcs);
2530 	emu_wrptr(sc, 0, SPCS1, spcs);
2531 	emu_wrptr(sc, 0, SPCS2, spcs);
2532 }
2533 
2534 #define	L2L_POINTS	10
2535 
2536 static int l2l_df[L2L_POINTS] = {
2537 	0x572C5CA,		/* 100..90 */
2538 	0x3211625,		/* 90..80 */
2539 	0x1CC1A76,		/* 80..70 */
2540 	0x108428F,		/* 70..60 */
2541 	0x097C70A,		/* 60..50 */
2542 	0x0572C5C,		/* 50..40 */
2543 	0x0321162,		/* 40..30 */
2544 	0x01CC1A7,		/* 30..20 */
2545 	0x0108428,		/* 20..10 */
2546 	0x016493D		/* 10..0 */
2547 };
2548 
2549 static int l2l_f[L2L_POINTS] = {
2550 	0x4984461A,		/* 90 */
2551 	0x2A3968A7,		/* 80 */
2552 	0x18406003,		/* 70 */
2553 	0x0DEDC66D,		/* 60 */
2554 	0x07FFFFFF,		/* 50 */
2555 	0x04984461,		/* 40 */
2556 	0x02A3968A,		/* 30 */
2557 	0x01840600,		/* 20 */
2558 	0x00DEDC66,		/* 10 */
2559 	0x00000000		/* 0 */
2560 };
2561 
2562 
2563 static int
2564 log2lin(int log_t)
2565 {
2566 	int lin_t;
2567 	int idx, lin;
2568 
2569 	if (log_t <= 0) {
2570 		lin_t = 0x00000000;
2571 		return (lin_t);
2572 	}
2573 
2574 	if (log_t >= 100) {
2575 		lin_t = 0x7fffffff;
2576 		return (lin_t);
2577 	}
2578 
2579 	idx = (L2L_POINTS - 1) - log_t / (L2L_POINTS);
2580 	lin = log_t % (L2L_POINTS);
2581 	lin_t = l2l_df[idx] * lin + l2l_f[idx];
2582 	return (lin_t);
2583 }
2584 
2585 
2586 void
2587 emumix_set_fxvol(struct emu_sc_info *sc, unsigned gpr, int32_t vol)
2588 {
2589 
2590 	vol = log2lin(vol);
2591 	emumix_set_gpr(sc, gpr, vol);
2592 }
2593 
2594 void
2595 emumix_set_gpr(struct emu_sc_info *sc, unsigned gpr, int32_t val)
2596 {
2597 	if (sc->dbg_level > 1)
2598 		if (gpr == 0) {
2599 			device_printf(sc->dev, "Zero gpr write access\n");
2600 #ifdef KDB
2601 			kdb_backtrace();
2602 #endif
2603 			return;
2604 			}
2605 
2606 	emu_wrptr(sc, 0, GPR(gpr), val);
2607 }
2608 
2609 void
2610 emumix_set_volume(struct emu_sc_info *sc, int mixer_idx, int volume)
2611 {
2612 
2613 	RANGE(volume, 0, 100);
2614 	if (mixer_idx < NUM_MIXERS) {
2615 		sc->mixer_volcache[mixer_idx] = volume;
2616 		emumix_set_fxvol(sc, sc->mixer_gpr[mixer_idx], volume);
2617 	}
2618 }
2619 
2620 int
2621 emumix_get_volume(struct emu_sc_info *sc, int mixer_idx)
2622 {
2623 	if ((mixer_idx < NUM_MIXERS) && (mixer_idx >= 0))
2624 		return (sc->mixer_volcache[mixer_idx]);
2625 	return (-1);
2626 }
2627 
2628 /* Init CardBus part */
2629 static int
2630 emu_cardbus_init(struct emu_sc_info *sc)
2631 {
2632 
2633 	/*
2634 	 * XXX May not need this if we have IPR3 handler.
2635 	 * Is it a real init calls, or IPR3 interrupt acknowledgments?
2636 	 * Looks much like "(data << 16) | register".
2637 	 */
2638 	emu_wr_cbptr(sc, (0x00d0 << 16) | 0x0000);
2639 	emu_wr_cbptr(sc, (0x00d0 << 16) | 0x0001);
2640 	emu_wr_cbptr(sc, (0x00d0 << 16) | 0x005f);
2641 	emu_wr_cbptr(sc, (0x00d0 << 16) | 0x007f);
2642 
2643 	emu_wr_cbptr(sc, (0x0090 << 16) | 0x007f);
2644 
2645 	return (0);
2646 }
2647 
2648 /* Probe and attach the card */
2649 static int
2650 emu_init(struct emu_sc_info *sc)
2651 {
2652 	uint32_t ch, tmp;
2653 	uint32_t spdif_sr;
2654 	uint32_t ac97slot;
2655 	int def_mode;
2656 	int i;
2657 
2658 	/* disable audio and lock cache */
2659 	emu_wr(sc, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE, 4);
2660 
2661 	/* reset recording buffers */
2662 	emu_wrptr(sc, 0, MICBS, ADCBS_BUFSIZE_NONE);
2663 	emu_wrptr(sc, 0, MICBA, 0);
2664 	emu_wrptr(sc, 0, FXBS, ADCBS_BUFSIZE_NONE);
2665 	emu_wrptr(sc, 0, FXBA, 0);
2666 	emu_wrptr(sc, 0, ADCBS, ADCBS_BUFSIZE_NONE);
2667 	emu_wrptr(sc, 0, ADCBA, 0);
2668 
2669 	/* disable channel interrupt */
2670 	emu_wr(sc, INTE, INTE_INTERVALTIMERENB | INTE_SAMPLERATETRACKER | INTE_PCIERRORENABLE, 4);
2671 	emu_wrptr(sc, 0, CLIEL, 0);
2672 	emu_wrptr(sc, 0, CLIEH, 0);
2673 	emu_wrptr(sc, 0, SOLEL, 0);
2674 	emu_wrptr(sc, 0, SOLEH, 0);
2675 
2676 	/* disable P16V and S/PDIF interrupts */
2677 	if ((sc->is_ca0102) || (sc->is_ca0108))
2678 		emu_wr(sc, INTE2, 0, 4);
2679 
2680 	if (sc->is_ca0102)
2681 		emu_wr(sc, INTE3, 0, 4);
2682 
2683 	/* init phys inputs and outputs */
2684 	ac97slot = 0;
2685 	if (sc->has_51)
2686 		ac97slot = AC97SLOT_CNTR | AC97SLOT_LFE;
2687 	if (sc->has_71)
2688 		ac97slot = AC97SLOT_CNTR | AC97SLOT_LFE | AC97SLOT_REAR_LEFT | AC97SLOT_REAR_RIGHT;
2689 	if (sc->is_emu10k2)
2690 		ac97slot |= 0x40;
2691 	emu_wrptr(sc, 0, AC97SLOT, ac97slot);
2692 
2693 	if (sc->is_emu10k2)	/* XXX for later cards? */
2694 		emu_wrptr(sc, 0, SPBYPASS, 0xf00);	/* What will happen if
2695 							 * we write 1 here? */
2696 
2697 	if (bus_dma_tag_create( /* parent */ bus_get_dma_tag(sc->dev),
2698 	     /* alignment */ 2, /* boundary */ 0,
2699 	     /* lowaddr */ 1 << 31,	/* can only access 0-2gb */
2700 	     /* highaddr */ BUS_SPACE_MAXADDR,
2701 	     /* filter */ NULL, /* filterarg */ NULL,
2702 	     /* maxsize */ EMU_MAX_BUFSZ, /* nsegments */ 1, /* maxsegz */ 0x3ffff,
2703 	     /* flags */ 0, /* lockfunc */ busdma_lock_mutex,
2704 	     /* lockarg */ &Giant, &(sc->mem.dmat)) != 0) {
2705 		device_printf(sc->dev, "unable to create dma tag\n");
2706 		bus_dma_tag_destroy(sc->mem.dmat);
2707 		return (ENOMEM);
2708 	}
2709 
2710 	sc->mem.card = sc;
2711 	SLIST_INIT(&sc->mem.blocks);
2712 	sc->mem.ptb_pages = emu_malloc(&sc->mem, EMU_MAXPAGES * sizeof(uint32_t), &sc->mem.ptb_pages_addr);
2713 	if (sc->mem.ptb_pages == NULL)
2714 		return (ENOMEM);
2715 
2716 	sc->mem.silent_page = emu_malloc(&sc->mem, EMUPAGESIZE, &sc->mem.silent_page_addr);
2717 	if (sc->mem.silent_page == NULL) {
2718 		emu_free(&sc->mem, sc->mem.ptb_pages);
2719 		return (ENOMEM);
2720 	}
2721 	/* Clear page with silence & setup all pointers to this page */
2722 	bzero(sc->mem.silent_page, EMUPAGESIZE);
2723 	tmp = (uint32_t) (sc->mem.silent_page_addr) << 1;
2724 	for (i = 0; i < EMU_MAXPAGES; i++)
2725 		sc->mem.ptb_pages[i] = tmp | i;
2726 
2727 	for (ch = 0; ch < NUM_G; ch++) {
2728 		emu_wrptr(sc, ch, MAPA, tmp | MAP_PTI_MASK);
2729 		emu_wrptr(sc, ch, MAPB, tmp | MAP_PTI_MASK);
2730 	}
2731 	emu_wrptr(sc, 0, PTB, (sc->mem.ptb_pages_addr));
2732 	emu_wrptr(sc, 0, TCB, 0);	/* taken from original driver */
2733 	emu_wrptr(sc, 0, TCBS, 0);	/* taken from original driver */
2734 
2735 	/* init envelope engine */
2736 	for (ch = 0; ch < NUM_G; ch++) {
2737 		emu_wrptr(sc, ch, DCYSUSV, 0);
2738 		emu_wrptr(sc, ch, IP, 0);
2739 		emu_wrptr(sc, ch, VTFT, 0xffff);
2740 		emu_wrptr(sc, ch, CVCF, 0xffff);
2741 		emu_wrptr(sc, ch, PTRX, 0);
2742 		emu_wrptr(sc, ch, CPF, 0);
2743 		emu_wrptr(sc, ch, CCR, 0);
2744 
2745 		emu_wrptr(sc, ch, PSST, 0);
2746 		emu_wrptr(sc, ch, DSL, 0x10);
2747 		emu_wrptr(sc, ch, CCCA, 0);
2748 		emu_wrptr(sc, ch, Z1, 0);
2749 		emu_wrptr(sc, ch, Z2, 0);
2750 		emu_wrptr(sc, ch, FXRT, 0xd01c0000);
2751 
2752 		emu_wrptr(sc, ch, ATKHLDM, 0);
2753 		emu_wrptr(sc, ch, DCYSUSM, 0);
2754 		emu_wrptr(sc, ch, IFATN, 0xffff);
2755 		emu_wrptr(sc, ch, PEFE, 0);
2756 		emu_wrptr(sc, ch, FMMOD, 0);
2757 		emu_wrptr(sc, ch, TREMFRQ, 24);	/* 1 Hz */
2758 		emu_wrptr(sc, ch, FM2FRQ2, 24);	/* 1 Hz */
2759 		emu_wrptr(sc, ch, TEMPENV, 0);
2760 
2761 		/*** these are last so OFF prevents writing ***/
2762 		emu_wrptr(sc, ch, LFOVAL2, 0);
2763 		emu_wrptr(sc, ch, LFOVAL1, 0);
2764 		emu_wrptr(sc, ch, ATKHLDV, 0);
2765 		emu_wrptr(sc, ch, ENVVOL, 0);
2766 		emu_wrptr(sc, ch, ENVVAL, 0);
2767 
2768 		if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2769 			emu_wrptr(sc, ch, 0x4c, 0x0);
2770 			emu_wrptr(sc, ch, 0x4d, 0x0);
2771 			emu_wrptr(sc, ch, 0x4e, 0x0);
2772 			emu_wrptr(sc, ch, 0x4f, 0x0);
2773 			emu_wrptr(sc, ch, A_FXRT1, 0x3f3f3f3f);
2774 			emu_wrptr(sc, ch, A_FXRT2, 0x3f3f3f3f);
2775 			emu_wrptr(sc, ch, A_SENDAMOUNTS, 0x0);
2776 		}
2777 	}
2778 
2779 	emumix_set_spdif_mode(sc, SPDIF_MODE_PCM);
2780 
2781 	if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108))
2782 		emu_wrptr(sc, 0, A_SPDIF_SAMPLERATE, A_SPDIF_48000);
2783 
2784 	/*
2785 	 * CAxxxx cards needs additional setup:
2786 	 * 1. Set I2S capture sample rate to 96000
2787 	 * 2. Disable P16v / P17v proceesing
2788 	 * 3. Allow EMU10K DSP inputs
2789 	 */
2790 	if ((sc->is_ca0102) || (sc->is_ca0108)) {
2791 
2792 		spdif_sr = emu_rdptr(sc, 0, A_SPDIF_SAMPLERATE);
2793 		spdif_sr &= 0xfffff1ff;
2794 		spdif_sr |= A_I2S_CAPTURE_96000;
2795 		emu_wrptr(sc, 0, A_SPDIF_SAMPLERATE, spdif_sr);
2796 
2797 		/* Disable P16v processing */
2798 		emu_wr_p16vptr(sc, 0, SRCSel, 0x14);
2799 
2800 		/* Setup P16v/P17v sound routing */
2801 		if (sc->is_ca0102)
2802 			emu_wr_p16vptr(sc, 0, SRCMULTI_ENABLE, 0xFF00FF00);
2803 		else {
2804 			emu_wr_p16vptr(sc, 0, P17V_MIXER_I2S_ENABLE, 0xFF000000);
2805 			emu_wr_p16vptr(sc, 0, P17V_MIXER_SPDIF_ENABLE, 0xFF000000);
2806 
2807 			tmp = emu_rd(sc, A_IOCFG, 2);
2808 			emu_wr(sc, A_IOCFG, tmp & ~0x8, 2);
2809 		}
2810 	}
2811 	emu_initefx(sc);
2812 
2813 	def_mode = MODE_ANALOG;
2814 	if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108))
2815 		def_mode = MODE_DIGITAL;
2816 	if (((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) && (sc->broken_digital)) {
2817 		device_printf(sc->dev, "Audigy card initialized in analog mode.\n");
2818 		def_mode = MODE_ANALOG;
2819 	}
2820 	emumix_set_mode(sc, def_mode);
2821 
2822 	if (bootverbose) {
2823 		tmp = emu_rd(sc, HCFG, 4);
2824 		device_printf(sc->dev, "Card Configuration (   0x%08x )\n", tmp);
2825 		device_printf(sc->dev, "Card Configuration ( & 0xff000000 ) : %s%s%s%s%s%s%s%s\n",
2826 		    (tmp & 0x80000000 ? "[Legacy MPIC] " : ""),
2827 		    (tmp & 0x40000000 ? "[0x40] " : ""),
2828 		    (tmp & 0x20000000 ? "[0x20] " : ""),
2829 		    (tmp & 0x10000000 ? "[0x10] " : ""),
2830 		    (tmp & 0x08000000 ? "[0x08] " : ""),
2831 		    (tmp & 0x04000000 ? "[0x04] " : ""),
2832 		    (tmp & 0x02000000 ? "[0x02] " : ""),
2833 		    (tmp & 0x01000000 ? "[0x01]" : " "));
2834 		device_printf(sc->dev, "Card Configuration ( & 0x00ff0000 ) : %s%s%s%s%s%s%s%s\n",
2835 		    (tmp & 0x00800000 ? "[0x80] " : ""),
2836 		    (tmp & 0x00400000 ? "[0x40] " : ""),
2837 		    (tmp & 0x00200000 ? "[Legacy INT] " : ""),
2838 		    (tmp & 0x00100000 ? "[0x10] " : ""),
2839 		    (tmp & 0x00080000 ? "[0x08] " : ""),
2840 		    (tmp & 0x00040000 ? "[Codec4] " : ""),
2841 		    (tmp & 0x00020000 ? "[Codec2] " : ""),
2842 		    (tmp & 0x00010000 ? "[I2S Codec]" : " "));
2843 		device_printf(sc->dev, "Card Configuration ( & 0x0000ff00 ) : %s%s%s%s%s%s%s%s\n",
2844 		    (tmp & 0x00008000 ? "[0x80] " : ""),
2845 		    (tmp & 0x00004000 ? "[GPINPUT0] " : ""),
2846 		    (tmp & 0x00002000 ? "[GPINPUT1] " : ""),
2847 		    (tmp & 0x00001000 ? "[GPOUT0] " : ""),
2848 		    (tmp & 0x00000800 ? "[GPOUT1] " : ""),
2849 		    (tmp & 0x00000400 ? "[GPOUT2] " : ""),
2850 		    (tmp & 0x00000200 ? "[Joystick] " : ""),
2851 		    (tmp & 0x00000100 ? "[0x01]" : " "));
2852 		device_printf(sc->dev, "Card Configuration ( & 0x000000ff ) : %s%s%s%s%s%s%s%s\n",
2853 		    (tmp & 0x00000080 ? "[0x80] " : ""),
2854 		    (tmp & 0x00000040 ? "[0x40] " : ""),
2855 		    (tmp & 0x00000020 ? "[0x20] " : ""),
2856 		    (tmp & 0x00000010 ? "[AUTOMUTE] " : ""),
2857 		    (tmp & 0x00000008 ? "[LOCKSOUNDCACHE] " : ""),
2858 		    (tmp & 0x00000004 ? "[LOCKTANKCACHE] " : ""),
2859 		    (tmp & 0x00000002 ? "[MUTEBUTTONENABLE] " : ""),
2860 		    (tmp & 0x00000001 ? "[AUDIOENABLE]" : " "));
2861 
2862 		if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2863 			tmp = emu_rd(sc, A_IOCFG, 2);
2864 			device_printf(sc->dev, "Audigy Card Configuration (    0x%04x )\n", tmp);
2865 			device_printf(sc->dev, "Audigy Card Configuration (  & 0xff00 )");
2866 			printf(" : %s%s%s%s%s%s%s%s\n",
2867 			    (tmp & 0x8000 ? "[Rear Speakers] " : ""),
2868 			    (tmp & 0x4000 ? "[Front Speakers] " : ""),
2869 			    (tmp & 0x2000 ? "[0x20] " : ""),
2870 			    (tmp & 0x1000 ? "[0x10] " : ""),
2871 			    (tmp & 0x0800 ? "[0x08] " : ""),
2872 			    (tmp & 0x0400 ? "[0x04] " : ""),
2873 			    (tmp & 0x0200 ? "[0x02] " : ""),
2874 			    (tmp & 0x0100 ? "[AudigyDrive Phones]" : " "));
2875 			device_printf(sc->dev, "Audigy Card Configuration (  & 0x00ff )");
2876 			printf(" : %s%s%s%s%s%s%s%s\n",
2877 			    (tmp & 0x0080 ? "[0x80] " : ""),
2878 			    (tmp & 0x0040 ? "[Mute AnalogOut] " : ""),
2879 			    (tmp & 0x0020 ? "[0x20] " : ""),
2880 			    (tmp & 0x0010 ? "[0x10] " : ""),
2881 			    (tmp & 0x0008 ? "[0x08] " : ""),
2882 			    (tmp & 0x0004 ? "[GPOUT0] " : ""),
2883 			    (tmp & 0x0002 ? "[GPOUT1] " : ""),
2884 			    (tmp & 0x0001 ? "[GPOUT2]" : " "));
2885 		}		/* is_emu10k2 or ca* */
2886 	}			/* bootverbose */
2887 	return (0);
2888 }
2889 
2890 static int
2891 emu_uninit(struct emu_sc_info *sc)
2892 {
2893 	uint32_t ch;
2894 	struct emu_memblk *blk;
2895 
2896 	emu_wr(sc, INTE, 0, 4);
2897 	for (ch = 0; ch < NUM_G; ch++)
2898 		emu_wrptr(sc, ch, DCYSUSV, 0);
2899 	for (ch = 0; ch < NUM_G; ch++) {
2900 		emu_wrptr(sc, ch, VTFT, 0);
2901 		emu_wrptr(sc, ch, CVCF, 0);
2902 		emu_wrptr(sc, ch, PTRX, 0);
2903 		emu_wrptr(sc, ch, CPF, 0);
2904 	}
2905 
2906 	/* disable audio and lock cache */
2907 	emu_wr(sc, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE, 4);
2908 
2909 	emu_wrptr(sc, 0, PTB, 0);
2910 	/* reset recording buffers */
2911 	emu_wrptr(sc, 0, MICBS, ADCBS_BUFSIZE_NONE);
2912 	emu_wrptr(sc, 0, MICBA, 0);
2913 	emu_wrptr(sc, 0, FXBS, ADCBS_BUFSIZE_NONE);
2914 	emu_wrptr(sc, 0, FXBA, 0);
2915 	emu_wrptr(sc, 0, FXWC, 0);
2916 	emu_wrptr(sc, 0, ADCBS, ADCBS_BUFSIZE_NONE);
2917 	emu_wrptr(sc, 0, ADCBA, 0);
2918 	emu_wrptr(sc, 0, TCB, 0);
2919 	emu_wrptr(sc, 0, TCBS, 0);
2920 
2921 	/* disable channel interrupt */
2922 	emu_wrptr(sc, 0, CLIEL, 0);
2923 	emu_wrptr(sc, 0, CLIEH, 0);
2924 	emu_wrptr(sc, 0, SOLEL, 0);
2925 	emu_wrptr(sc, 0, SOLEH, 0);
2926 
2927 	if (!SLIST_EMPTY(&sc->mem.blocks))
2928 		device_printf(sc->dev, "warning: memblock list not empty\n");
2929 
2930 	SLIST_FOREACH(blk, &sc->mem.blocks, link)
2931 		if (blk != NULL)
2932 		device_printf(sc->dev, "lost %d for %s\n", blk->pte_size, blk->owner);
2933 
2934 	emu_free(&sc->mem, sc->mem.ptb_pages);
2935 	emu_free(&sc->mem, sc->mem.silent_page);
2936 
2937 	return (0);
2938 }
2939 
2940 static int
2941 emu_read_ivar(device_t bus, device_t dev, int ivar_index, uintptr_t * result)
2942 {
2943 	struct sndcard_func *func = device_get_ivars(dev);
2944 	struct emu_sc_info *sc = device_get_softc(bus);
2945 
2946 	if (func==NULL)
2947 		return (ENOMEM);
2948 	if (sc == NULL)
2949 		return (ENOMEM);
2950 
2951 	switch (ivar_index) {
2952 	case EMU_VAR_FUNC:
2953 		*result = func->func;
2954 		break;
2955 	case EMU_VAR_ROUTE:
2956 		if (func->varinfo == NULL)
2957 			return (ENOMEM);
2958 		*result = ((struct emu_pcminfo *)func->varinfo)->route;
2959 		break;
2960 	case EMU_VAR_ISEMU10K1:
2961 		*result = sc->is_emu10k1;
2962 		break;
2963 	case EMU_VAR_MCH_DISABLED:
2964 		*result = sc->mch_disabled;
2965 		break;
2966 	case EMU_VAR_MCH_REC:
2967 		*result = sc->mch_rec;
2968 		break;
2969 	default:
2970 		return (ENOENT);
2971 	}
2972 
2973 	return (0);
2974 }
2975 
2976 static int
2977 emu_write_ivar(device_t bus __unused, device_t dev __unused,
2978     int ivar_index, uintptr_t value __unused)
2979 {
2980 
2981 	switch (ivar_index) {
2982 		case 0:
2983 		return (EINVAL);
2984 
2985 	default:
2986 		return (ENOENT);
2987 	}
2988 }
2989 
2990 static int
2991 emu_pci_probe(device_t dev)
2992 {
2993 	struct sbuf *s;
2994 	unsigned int thiscard = 0;
2995 	uint16_t vendor;
2996 
2997 	vendor = pci_read_config(dev, PCIR_DEVVENDOR, /* bytes */ 2);
2998 	if (vendor != 0x1102)
2999 		return (ENXIO);	/* Not Creative */
3000 
3001 	thiscard = emu_getcard(dev);
3002 	if (thiscard == 0)
3003 		return (ENXIO);
3004 
3005 	s = sbuf_new(NULL, NULL, 4096, 0);
3006 	if (s == NULL)
3007 		return (ENOMEM);
3008 	sbuf_printf(s, "Creative %s [%s]", emu_cards[thiscard].desc, emu_cards[thiscard].SBcode);
3009 	sbuf_finish(s);
3010 
3011 	device_set_desc_copy(dev, sbuf_data(s));
3012 
3013 	sbuf_delete(s);
3014 
3015 	return (BUS_PROBE_DEFAULT);
3016 }
3017 
3018 
3019 static int
3020 emu_pci_attach(device_t dev)
3021 {
3022 	struct sndcard_func *func;
3023 	struct emu_sc_info *sc;
3024 	struct emu_pcminfo *pcminfo;
3025 #if 0
3026 	struct emu_midiinfo *midiinfo;
3027 #endif
3028 	uint32_t data;
3029 	int i;
3030 	int device_flags;
3031 	char status[255];
3032 	int error = ENXIO;
3033 	int unit;
3034 
3035 	sc = device_get_softc(dev);
3036 	unit = device_get_unit(dev);
3037 
3038 	if (resource_disabled("emu10kx", unit)) {
3039 		device_printf(dev, "disabled by kernel hints\n");
3040 		return (ENXIO); /* XXX to avoid unit reuse */
3041 	}
3042 
3043 	/* Get configuration */
3044 
3045 	sc->ctx = device_get_sysctl_ctx(dev);
3046 	if (sc->ctx == NULL)
3047 		goto bad;
3048 	sc->root = device_get_sysctl_tree(dev);
3049 	if (sc->root == NULL)
3050 		goto bad;
3051 
3052 	if (resource_int_value("emu10kx", unit, "multichannel_disabled", &(sc->mch_disabled)))
3053 		RANGE(sc->mch_disabled, 0, 1);
3054 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3055 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
3056             OID_AUTO, "multichannel_disabled", CTLFLAG_RD, &(sc->mch_disabled), 0, "Multichannel playback setting");
3057 
3058 	if (resource_int_value("emu10kx", unit, "multichannel_recording", &(sc->mch_rec)))
3059 		RANGE(sc->mch_rec, 0, 1);
3060 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3061 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
3062             OID_AUTO, "multichannel_recording", CTLFLAG_RD,  &(sc->mch_rec), 0, "Multichannel recording setting");
3063 
3064 	if (resource_int_value("emu10kx", unit, "debug", &(sc->dbg_level)))
3065 		RANGE(sc->mch_rec, 0, 2);
3066 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3067 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
3068             OID_AUTO, "debug", CTLFLAG_RW, &(sc->dbg_level), 0, "Debug level");
3069 
3070 	/* Fill in the softc. */
3071 	mtx_init(&sc->lock, device_get_nameunit(dev), "bridge conf", MTX_DEF);
3072 	mtx_init(&sc->rw, device_get_nameunit(dev), "exclusive io", MTX_DEF);
3073 	sc->dev = dev;
3074 	sc->type = pci_get_devid(dev);
3075 	sc->rev = pci_get_revid(dev);
3076 	sc->enable_ir = 0;
3077 	sc->has_ac97 = 0;
3078 	sc->has_51 = 0;
3079 	sc->has_71 = 0;
3080 	sc->broken_digital = 0;
3081 	sc->is_emu10k1 = 0;
3082 	sc->is_emu10k2 = 0;
3083 	sc->is_ca0102 = 0;
3084 	sc->is_ca0108 = 0;
3085 	sc->is_cardbus = 0;
3086 
3087 	device_flags = emu_cards[emu_getcard(dev)].flags;
3088 	if (device_flags & HAS_51)
3089 		sc->has_51 = 1;
3090 	if (device_flags & HAS_71) {
3091 		sc->has_51 = 1;
3092 		sc->has_71 = 1;
3093 	}
3094 	if (device_flags & IS_EMU10K1)
3095 		sc->is_emu10k1 = 1;
3096 	if (device_flags & IS_EMU10K2)
3097 		sc->is_emu10k2 = 1;
3098 	if (device_flags & IS_CA0102)
3099 		sc->is_ca0102 = 1;
3100 	if (device_flags & IS_CA0108)
3101 		sc->is_ca0108 = 1;
3102 	if ((sc->is_emu10k2) && (sc->rev == 4)) {
3103 		sc->is_emu10k2 = 0;
3104 		sc->is_ca0102 = 1;	/* for unknown Audigy 2 cards */
3105 	}
3106 	if ((sc->is_ca0102 == 1) || (sc->is_ca0108 == 1))
3107 		if (device_flags & IS_CARDBUS)
3108 			sc->is_cardbus = 1;
3109 
3110 	if ((sc->is_emu10k1 + sc->is_emu10k2 + sc->is_ca0102 + sc->is_ca0108) != 1) {
3111 		device_printf(sc->dev, "Unable to detect HW chipset\n");
3112 		goto bad;
3113 	}
3114 	if (device_flags & BROKEN_DIGITAL)
3115 		sc->broken_digital = 1;
3116 	if (device_flags & HAS_AC97)
3117 		sc->has_ac97 = 1;
3118 
3119 	sc->opcode_shift = 0;
3120 	if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
3121 		sc->opcode_shift = 24;
3122 		sc->high_operand_shift = 12;
3123 
3124 	/*	DSP map				*/
3125 	/*	sc->fx_base = 0x0		*/
3126 		sc->input_base = 0x40;
3127 	/*	sc->p16vinput_base = 0x50;	*/
3128 		sc->output_base = 0x60;
3129 		sc->efxc_base = 0x80;
3130 	/*	sc->output32h_base = 0xa0;	*/
3131 	/*	sc->output32l_base = 0xb0;	*/
3132 		sc->dsp_zero = 0xc0;
3133 	/*	0xe0...0x100 are unknown	*/
3134 	/*	sc->tram_base = 0x200		*/
3135 	/*	sc->tram_addr_base = 0x300	*/
3136 		sc->gpr_base = A_FXGPREGBASE;
3137 		sc->num_gprs = 0x200;
3138 		sc->code_base = A_MICROCODEBASE;
3139 		sc->code_size = 0x800 / 2;	/* 0x600-0xdff,  2048 words,
3140 						 * 1024 instructions */
3141 
3142 		sc->mchannel_fx = 8;
3143 		sc->num_fxbuses = 16;
3144 		sc->num_inputs = 8;
3145 		sc->num_outputs = 16;
3146 		sc->address_mask = A_PTR_ADDRESS_MASK;
3147 	}
3148 	if (sc->is_emu10k1) {
3149 		sc->has_51 = 0;	/* We don't support 5.1 sound on SB Live! 5.1 */
3150 		sc->opcode_shift = 20;
3151 		sc->high_operand_shift = 10;
3152 		sc->code_base = MICROCODEBASE;
3153 		sc->code_size = 0x400 / 2;	/* 0x400-0x7ff,  1024 words,
3154 						 * 512 instructions */
3155 		sc->gpr_base = FXGPREGBASE;
3156 		sc->num_gprs = 0x100;
3157 		sc->input_base = 0x10;
3158 		sc->output_base = 0x20;
3159 		/*
3160 		 * XXX 5.1 Analog outputs are inside efxc address space!
3161 		 * They use ouput+0x11/+0x12 (=efxc+1/+2).
3162 		 * Don't use this efx registers for recording on SB Live! 5.1!
3163 		 */
3164 		sc->efxc_base = 0x30;
3165 		sc->dsp_zero = 0x40;
3166 		sc->mchannel_fx = 0;
3167 		sc->num_fxbuses = 8;
3168 		sc->num_inputs = 8;
3169 		sc->num_outputs = 16;
3170 		sc->address_mask = PTR_ADDRESS_MASK;
3171 	}
3172 	if (sc->opcode_shift == 0)
3173 		goto bad;
3174 
3175 	data = pci_read_config(dev, PCIR_COMMAND, 2);
3176 	data |= (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN);
3177 	pci_write_config(dev, PCIR_COMMAND, data, 2);
3178 	data = pci_read_config(dev, PCIR_COMMAND, 2);
3179 
3180 	pci_enable_busmaster(dev);
3181 
3182 	i = PCIR_BAR(0);
3183 	sc->reg = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &i, RF_ACTIVE);
3184 	if (sc->reg == NULL) {
3185 		device_printf(dev, "unable to map register space\n");
3186 		goto bad;
3187 	}
3188 	sc->st = rman_get_bustag(sc->reg);
3189 	sc->sh = rman_get_bushandle(sc->reg);
3190 
3191 	for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
3192 		sc->timer[i] = 0;	/* disable it */
3193 
3194 	i = 0;
3195 	sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &i, RF_ACTIVE | RF_SHAREABLE);
3196 	if ((sc->irq == NULL) || bus_setup_intr(dev, sc->irq, INTR_MPSAFE | INTR_TYPE_AV, NULL, emu_intr, sc, &sc->ih)) {
3197 		device_printf(dev, "unable to map interrupt\n");
3198 		goto bad;
3199 	}
3200 	if (emu_rm_init(sc) != 0) {
3201 		device_printf(dev, "unable to create resource manager\n");
3202 		goto bad;
3203 	}
3204 	if (sc->is_cardbus)
3205 		if (emu_cardbus_init(sc) != 0) {
3206 			device_printf(dev, "unable to initialize CardBus interface\n");
3207 			goto bad;
3208 		}
3209 	if (emu_init(sc) != 0) {
3210 		device_printf(dev, "unable to initialize the card\n");
3211 		goto bad;
3212 	}
3213 	if (emu10kx_dev_init(sc) != 0) {
3214 		device_printf(dev, "unable to create control device\n");
3215 		goto bad;
3216 	}
3217 	snprintf(status, 255, "rev %d at io 0x%lx irq %ld", sc->rev, rman_get_start(sc->reg), rman_get_start(sc->irq));
3218 
3219 	/* Voices */
3220 	for (i = 0; i < NUM_G; i++) {
3221 		sc->voice[i].vnum = i;
3222 		sc->voice[i].slave = NULL;
3223 		sc->voice[i].busy = 0;
3224 		sc->voice[i].ismaster = 0;
3225 		sc->voice[i].running = 0;
3226 		sc->voice[i].b16 = 0;
3227 		sc->voice[i].stereo = 0;
3228 		sc->voice[i].speed = 0;
3229 		sc->voice[i].start = 0;
3230 		sc->voice[i].end = 0;
3231 	}
3232 
3233 	/* PCM Audio */
3234 	for (i = 0; i < RT_COUNT; i++)
3235 		sc->pcm[i] = NULL;
3236 
3237 	/* FRONT */
3238 	func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3239 	if (func == NULL) {
3240 		error = ENOMEM;
3241 		goto bad;
3242 	}
3243 	pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3244 	if (pcminfo == NULL) {
3245 		error = ENOMEM;
3246 		goto bad;
3247 	}
3248 	pcminfo->card = sc;
3249 	pcminfo->route = RT_FRONT;
3250 
3251 	func->func = SCF_PCM;
3252 	func->varinfo = pcminfo;
3253 	sc->pcm[RT_FRONT] = device_add_child(dev, "pcm", -1);
3254 	device_set_ivars(sc->pcm[RT_FRONT], func);
3255 
3256 	if (!(sc->mch_disabled)) {
3257 		/* REAR */
3258 		func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3259 		if (func == NULL) {
3260 			error = ENOMEM;
3261 			goto bad;
3262 		}
3263 		pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3264 		if (pcminfo == NULL) {
3265 			error = ENOMEM;
3266 			goto bad;
3267 		}
3268 		pcminfo->card = sc;
3269 		pcminfo->route = RT_REAR;
3270 
3271 		func->func = SCF_PCM;
3272 		func->varinfo = pcminfo;
3273 		sc->pcm[RT_REAR] = device_add_child(dev, "pcm", -1);
3274 		device_set_ivars(sc->pcm[RT_REAR], func);
3275 		if (sc->has_51) {
3276 			/* CENTER */
3277 			func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3278 			if (func == NULL) {
3279 				error = ENOMEM;
3280 				goto bad;
3281 			}
3282 			pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3283 			if (pcminfo == NULL) {
3284 				error = ENOMEM;
3285 				goto bad;
3286 			}
3287 			pcminfo->card = sc;
3288 			pcminfo->route = RT_CENTER;
3289 
3290 			func->func = SCF_PCM;
3291 			func->varinfo = pcminfo;
3292 			sc->pcm[RT_CENTER] = device_add_child(dev, "pcm", -1);
3293 			device_set_ivars(sc->pcm[RT_CENTER], func);
3294 			/* SUB */
3295 			func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3296 			if (func == NULL) {
3297 				error = ENOMEM;
3298 				goto bad;
3299 			}
3300 			pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3301 			if (pcminfo == NULL) {
3302 				error = ENOMEM;
3303 				goto bad;
3304 			}
3305 			pcminfo->card = sc;
3306 			pcminfo->route = RT_SUB;
3307 
3308 			func->func = SCF_PCM;
3309 			func->varinfo = pcminfo;
3310 			sc->pcm[RT_SUB] = device_add_child(dev, "pcm", -1);
3311 			device_set_ivars(sc->pcm[RT_SUB], func);
3312 		}
3313 		if (sc->has_71) {
3314 			/* SIDE */
3315 			func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3316 			if (func == NULL) {
3317 				error = ENOMEM;
3318 				goto bad;
3319 			}
3320 			pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3321 			if (pcminfo == NULL) {
3322 				error = ENOMEM;
3323 				goto bad;
3324 			}
3325 			pcminfo->card = sc;
3326 			pcminfo->route = RT_SIDE;
3327 
3328 			func->func = SCF_PCM;
3329 			func->varinfo = pcminfo;
3330 			sc->pcm[RT_SIDE] = device_add_child(dev, "pcm", -1);
3331 			device_set_ivars(sc->pcm[RT_SIDE], func);
3332 		}
3333 	} /* mch_disabled */
3334 
3335 	if (sc->mch_rec) {
3336 		func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3337 		if (func == NULL) {
3338 			error = ENOMEM;
3339 			goto bad;
3340 		}
3341 		pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3342 		if (pcminfo == NULL) {
3343 			error = ENOMEM;
3344 			goto bad;
3345 		}
3346 		pcminfo->card = sc;
3347 		pcminfo->route = RT_MCHRECORD;
3348 
3349 		func->func = SCF_PCM;
3350 		func->varinfo = pcminfo;
3351 		sc->pcm[RT_MCHRECORD] = device_add_child(dev, "pcm", -1);
3352 		device_set_ivars(sc->pcm[RT_MCHRECORD], func);
3353 	} /*mch_rec */
3354 
3355 	for (i = 0; i < 2; i++)
3356 		sc->midi[i] = NULL;
3357 
3358 	/* MIDI has some memory mangament and (possible) locking problems */
3359 #if 0
3360 	/* Midi Interface 1: Live!, Audigy, Audigy 2 */
3361 	if ((sc->is_emu10k1) || (sc->is_emu10k2) || (sc->is_ca0102)) {
3362 		func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3363 		if (func == NULL) {
3364 			error = ENOMEM;
3365 			goto bad;
3366 		}
3367 		midiinfo = malloc(sizeof(struct emu_midiinfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3368 		if (midiinfo == NULL) {
3369 			error = ENOMEM;
3370 			goto bad;
3371 		}
3372 		midiinfo->card = sc;
3373 		if (sc->is_emu10k2 || (sc->is_ca0102)) {
3374 			midiinfo->port = A_MUDATA1;
3375 			midiinfo->portnr = 1;
3376 		}
3377 		if (sc->is_emu10k1) {
3378 			midiinfo->port = MUDATA;
3379 			midiinfo->portnr = 1;
3380 		}
3381 		func->func = SCF_MIDI;
3382 		func->varinfo = midiinfo;
3383 		sc->midi[0] = device_add_child(dev, "midi", -1);
3384 		device_set_ivars(sc->midi[0], func);
3385 	}
3386 	/* Midi Interface 2: Audigy, Audigy 2 (on AudigyDrive) */
3387 	if (sc->is_emu10k2 || (sc->is_ca0102)) {
3388 		func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3389 		if (func == NULL) {
3390 			error = ENOMEM;
3391 			goto bad;
3392 		}
3393 		midiinfo = malloc(sizeof(struct emu_midiinfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3394 		if (midiinfo == NULL) {
3395 			error = ENOMEM;
3396 			goto bad;
3397 		}
3398 		midiinfo->card = sc;
3399 
3400 		midiinfo->port = A_MUDATA2;
3401 		midiinfo->portnr = 2;
3402 
3403 		func->func = SCF_MIDI;
3404 		func->varinfo = midiinfo;
3405 		sc->midi[1] = device_add_child(dev, "midi", -1);
3406 		device_set_ivars(sc->midi[1], func);
3407 	}
3408 #endif
3409 	return (bus_generic_attach(dev));
3410 
3411 bad:
3412 	/* XXX can we just call emu_pci_detach here? */
3413 	if (sc->cdev)
3414 		emu10kx_dev_uninit(sc);
3415 	if (sc->rm != NULL)
3416 		emu_rm_uninit(sc);
3417 	if (sc->reg)
3418 		bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->reg);
3419 	if (sc->ih)
3420 		bus_teardown_intr(dev, sc->irq, sc->ih);
3421 	if (sc->irq)
3422 		bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
3423 	mtx_destroy(&sc->rw);
3424 	mtx_destroy(&sc->lock);
3425 	return (error);
3426 }
3427 
3428 static int
3429 emu_pci_detach(device_t dev)
3430 {
3431 	struct emu_sc_info *sc;
3432 	struct sndcard_func *func;
3433 	int devcount, i;
3434 	device_t *childlist;
3435 	int r = 0;
3436 
3437 	sc = device_get_softc(dev);
3438 
3439 	for (i = 0; i < RT_COUNT; i++) {
3440 		if (sc->pcm[i] != NULL) {
3441 			func = device_get_ivars(sc->pcm[i]);
3442 			if (func != NULL && func->func == SCF_PCM) {
3443 				device_set_ivars(sc->pcm[i], NULL);
3444 				free(func->varinfo, M_DEVBUF);
3445 				free(func, M_DEVBUF);
3446 			}
3447 			r = device_delete_child(dev, sc->pcm[i]);
3448 			if (r)	return (r);
3449 		}
3450 	}
3451 
3452 	if (sc->midi[0] != NULL) {
3453 		func = device_get_ivars(sc->midi[0]);
3454 		if (func != NULL && func->func == SCF_MIDI) {
3455 			device_set_ivars(sc->midi[0], NULL);
3456 			free(func->varinfo, M_DEVBUF);
3457 			free(func, M_DEVBUF);
3458 		}
3459 		r = device_delete_child(dev, sc->midi[0]);
3460 		if (r)	return (r);
3461 	}
3462 
3463 	if (sc->midi[1] != NULL) {
3464 		func = device_get_ivars(sc->midi[1]);
3465 		if (func != NULL && func->func == SCF_MIDI) {
3466 			device_set_ivars(sc->midi[1], NULL);
3467 			free(func->varinfo, M_DEVBUF);
3468 			free(func, M_DEVBUF);
3469 		}
3470 		r = device_delete_child(dev, sc->midi[1]);
3471 		if (r)	return (r);
3472 	}
3473 
3474 	if (device_get_children(dev, &childlist, &devcount) == 0)
3475 		for (i = 0; i < devcount - 1; i++) {
3476 			device_printf(dev, "removing stale child %d (unit %d)\n", i, device_get_unit(childlist[i]));
3477 			func = device_get_ivars(childlist[i]);
3478 			if (func != NULL && (func->func == SCF_MIDI || func->func == SCF_PCM)) {
3479 				device_set_ivars(childlist[i], NULL);
3480 				free(func->varinfo, M_DEVBUF);
3481 				free(func, M_DEVBUF);
3482 			}
3483 			device_delete_child(dev, childlist[i]);
3484 		}
3485 	if (childlist != NULL)
3486 		free(childlist, M_TEMP);
3487 
3488 	r = emu10kx_dev_uninit(sc);
3489 	if (r)
3490 		return (r);
3491 
3492 	/* shutdown chip */
3493 	emu_uninit(sc);
3494 	emu_rm_uninit(sc);
3495 
3496 	if (sc->mem.dmat)
3497 		bus_dma_tag_destroy(sc->mem.dmat);
3498 
3499 	if (sc->reg)
3500 		bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->reg);
3501 	bus_teardown_intr(dev, sc->irq, sc->ih);
3502 	bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
3503 	mtx_destroy(&sc->rw);
3504 	mtx_destroy(&sc->lock);
3505 
3506 	return (bus_generic_detach(dev));
3507 }
3508 /* add suspend, resume */
3509 static device_method_t emu_methods[] = {
3510 	/* Device interface */
3511 	DEVMETHOD(device_probe, emu_pci_probe),
3512 	DEVMETHOD(device_attach, emu_pci_attach),
3513 	DEVMETHOD(device_detach, emu_pci_detach),
3514 	/* Bus methods */
3515 	DEVMETHOD(bus_read_ivar, emu_read_ivar),
3516 	DEVMETHOD(bus_write_ivar, emu_write_ivar),
3517 
3518 	{0, 0}
3519 };
3520 
3521 
3522 static driver_t emu_driver = {
3523 	"emu10kx",
3524 	emu_methods,
3525 	sizeof(struct emu_sc_info),
3526 	NULL,
3527 	0,
3528 	NULL
3529 };
3530 
3531 static int
3532 emu_modevent(module_t mod __unused, int cmd, void *data __unused)
3533 {
3534 	int err = 0;
3535 
3536 	switch (cmd) {
3537 	case MOD_LOAD:
3538 		break;		/* Success */
3539 
3540 	case MOD_UNLOAD:
3541 	case MOD_SHUTDOWN:
3542 
3543 		/* XXX  Should we check state of pcm & midi subdevices here? */
3544 
3545 		break;		/* Success */
3546 
3547 	default:
3548 		err = EINVAL;
3549 		break;
3550 	}
3551 
3552 	return (err);
3553 
3554 }
3555 
3556 static devclass_t emu_devclass;
3557 
3558 DRIVER_MODULE(snd_emu10kx, pci, emu_driver, emu_devclass, emu_modevent, NULL);
3559 DRIVER_MODULE(snd_emu10kx, cardbus, emu_driver, emu_devclass, emu_modevent, NULL);
3560 MODULE_VERSION(snd_emu10kx, SND_EMU10KX_PREFVER);
3561