?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "sound: Drop midi support"
[dragonfly.git] / sys / dev / sound / pci / emu10k1.c
blob362b71a84b7f15cf140158afc5c68b35eba011a2
1 /*-
2 * Copyright (c) 2004 David O'Brien <obrien@FreeBSD.org>
3 * Copyright (c) 2003 Orlando Bassotto <orlando.bassotto@ieo-research.it>
4 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #ifdef HAVE_KERNEL_OPTION_HEADERS
30 #include "opt_snd.h"
31 #endif
32
33 #include <dev/sound/pcm/sound.h>
34 #include <dev/sound/pcm/ac97.h>
35 #include <dev/sound/pci/emuxkireg.h>
36
37 #include <bus/pci/pcireg.h>
38 #include <bus/pci/pcivar.h>
39 #include <sys/queue.h>
40
41 #include <dev/sound/midi/mpu401.h>
42 #include "mpufoi_if.h"
43
44 SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pci/emu10k1.c 267581 2014-06-17 16:07:57Z jhb $");
45
46 /* -------------------------------------------------------------------- */
47
48 #define NUM_G 64 /* use all channels */
49 #define WAVEOUT_MAXBUFSIZE 32768
50 #define EMUPAGESIZE 4096 /* don't change */
51 #define EMUMAXPAGES (WAVEOUT_MAXBUFSIZE * NUM_G / EMUPAGESIZE)
52 #define EMU10K1_PCI_ID 0x00021102 /* 1102 => Creative Labs Vendor ID */
53 #define EMU10K2_PCI_ID 0x00041102
54 #define EMU10K3_PCI_ID 0x00081102
55 #define EMU_DEFAULT_BUFSZ 4096
56 #define EMU_MAX_CHANS 8
57 #define EMU_CHANS 4
58
59 #define MAXREQVOICES 8
60 #define RESERVED 0
61 #define NUM_MIDI 16
62 #define NUM_FXSENDS 4
63
64 #define TMEMSIZE 256*1024
65 #define TMEMSIZEREG 4
66
67 #define ENABLE 0xffffffff
68 #define DISABLE 0x00000000
69 #define ENV_ON EMU_CHAN_DCYSUSV_CHANNELENABLE_MASK
70 #define ENV_OFF 0x00 /* XXX: should this be 1? */
71
72 #define EMU_A_IOCFG_GPOUT_A 0x40
73 #define EMU_A_IOCFG_GPOUT_D 0x04
74 #define EMU_A_IOCFG_GPOUT_AD (EMU_A_IOCFG_GPOUT_A|EMU_A_IOCFG_GPOUT_D) /* EMU_A_IOCFG_GPOUT0 */
75
76 #define EMU_HCFG_GPOUT1 0x00000800
77
78 /* instruction set */
79 #define iACC3 0x06
80 #define iMACINT0 0x04
81 #define iINTERP 0x0e
82
83 #define C_00000000 0x40
84 #define C_00000001 0x41
85 #define C_00000004 0x44
86 #define C_40000000 0x4d
87 /* Audigy constants */
88 #define A_C_00000000 0xc0
89 #define A_C_40000000 0xcd
90
91 /* GPRs */
92 #define FXBUS(x) (0x00 + (x))
93 #define EXTIN(x) (0x10 + (x))
94 #define EXTOUT(x) (0x20 + (x))
95
96 #define GPR(x) (EMU_FXGPREGBASE + (x))
97 #define A_EXTIN(x) (0x40 + (x))
98 #define A_FXBUS(x) (0x00 + (x))
99 #define A_EXTOUT(x) (0x60 + (x))
100 #define A_GPR(x) (EMU_A_FXGPREGBASE + (x))
101
102 /* FX buses */
103 #define FXBUS_PCM_LEFT 0x00
104 #define FXBUS_PCM_RIGHT 0x01
105 #define FXBUS_MIDI_LEFT 0x04
106 #define FXBUS_MIDI_RIGHT 0x05
107 #define FXBUS_MIDI_REVERB 0x0c
108 #define FXBUS_MIDI_CHORUS 0x0d
109
110 /* Inputs */
111 #define EXTIN_AC97_L 0x00
112 #define EXTIN_AC97_R 0x01
113 #define EXTIN_SPDIF_CD_L 0x02
114 #define EXTIN_SPDIF_CD_R 0x03
115 #define EXTIN_TOSLINK_L 0x06
116 #define EXTIN_TOSLINK_R 0x07
117 #define EXTIN_COAX_SPDIF_L 0x0a
118 #define EXTIN_COAX_SPDIF_R 0x0b
119 /* Audigy Inputs */
120 #define A_EXTIN_AC97_L 0x00
121 #define A_EXTIN_AC97_R 0x01
122
123 /* Outputs */
124 #define EXTOUT_AC97_L 0x00
125 #define EXTOUT_AC97_R 0x01
126 #define EXTOUT_TOSLINK_L 0x02
127 #define EXTOUT_TOSLINK_R 0x03
128 #define EXTOUT_AC97_CENTER 0x04
129 #define EXTOUT_AC97_LFE 0x05
130 #define EXTOUT_HEADPHONE_L 0x06
131 #define EXTOUT_HEADPHONE_R 0x07
132 #define EXTOUT_REAR_L 0x08
133 #define EXTOUT_REAR_R 0x09
134 #define EXTOUT_ADC_CAP_L 0x0a
135 #define EXTOUT_ADC_CAP_R 0x0b
136 #define EXTOUT_ACENTER 0x11
137 #define EXTOUT_ALFE 0x12
138 /* Audigy Outputs */
139 #define A_EXTOUT_FRONT_L 0x00
140 #define A_EXTOUT_FRONT_R 0x01
141 #define A_EXTOUT_CENTER 0x02
142 #define A_EXTOUT_LFE 0x03
143 #define A_EXTOUT_HEADPHONE_L 0x04
144 #define A_EXTOUT_HEADPHONE_R 0x05
145 #define A_EXTOUT_REAR_L 0x06
146 #define A_EXTOUT_REAR_R 0x07
147 #define A_EXTOUT_AFRONT_L 0x08
148 #define A_EXTOUT_AFRONT_R 0x09
149 #define A_EXTOUT_ACENTER 0x0a
150 #define A_EXTOUT_ALFE 0x0b
151 #define A_EXTOUT_AREAR_L 0x0e
152 #define A_EXTOUT_AREAR_R 0x0f
153 #define A_EXTOUT_AC97_L 0x10
154 #define A_EXTOUT_AC97_R 0x11
155 #define A_EXTOUT_ADC_CAP_L 0x16
156 #define A_EXTOUT_ADC_CAP_R 0x17
157
158 struct emu_memblk {
159 SLIST_ENTRY(emu_memblk) link;
160 void *buf;
161 bus_addr_t buf_addr;
162 u_int32_t pte_start, pte_size;
163 bus_dmamap_t buf_map;
164 };
165
166 struct emu_mem {
167 u_int8_t bmap[EMUMAXPAGES / 8];
168 u_int32_t *ptb_pages;
169 void *silent_page;
170 bus_addr_t silent_page_addr;
171 bus_addr_t ptb_pages_addr;
172 bus_dmamap_t ptb_map;
173 bus_dmamap_t silent_map;
174 SLIST_HEAD(, emu_memblk) blocks;
175 };
176
177 struct emu_voice {
178 int vnum;
179 unsigned int b16:1, stereo:1, busy:1, running:1, ismaster:1;
180 int speed;
181 int start, end, vol;
182 int fxrt1; /* FX routing */
183 int fxrt2; /* FX routing (only for audigy) */
184 u_int32_t buf;
185 struct emu_voice *slave;
186 struct pcm_channel *channel;
187 };
188
189 struct sc_info;
190
191 /* channel registers */
192 struct sc_pchinfo {
193 int spd, fmt, blksz, run;
194 struct emu_voice *master, *slave;
195 struct snd_dbuf *buffer;
196 struct pcm_channel *channel;
197 struct sc_info *parent;
198 };
199
200 struct sc_rchinfo {
201 int spd, fmt, run, blksz, num;
202 u_int32_t idxreg, basereg, sizereg, setupreg, irqmask;
203 struct snd_dbuf *buffer;
204 struct pcm_channel *channel;
205 struct sc_info *parent;
206 };
207
208 /* device private data */
209 struct sc_info {
210 device_t dev;
211 u_int32_t type, rev;
212 u_int32_t tos_link:1, APS:1, audigy:1, audigy2:1;
213 u_int32_t addrmask; /* wider if audigy */
214
215 bus_space_tag_t st;
216 bus_space_handle_t sh;
217 bus_dma_tag_t parent_dmat;
218
219 struct resource *reg, *irq;
220 void *ih;
221 struct lock *lock;
222
223 unsigned int bufsz;
224 int timer, timerinterval;
225 int pnum, rnum;
226 int nchans;
227 struct emu_mem mem;
228 struct emu_voice voice[64];
229 struct sc_pchinfo pch[EMU_MAX_CHANS];
230 struct sc_rchinfo rch[3];
231 struct mpu401 *mpu;
232 mpu401_intr_t *mpu_intr;
233 int mputx;
234 };
235
236 /* -------------------------------------------------------------------- */
237
238 /*
239 * prototypes
240 */
241
242 /* stuff */
243 static int emu_init(struct sc_info *);
244 static void emu_intr(void *);
245 static void *emu_malloc(struct sc_info *sc, u_int32_t sz, bus_addr_t *addr, bus_dmamap_t *map);
246 static void *emu_memalloc(struct sc_info *sc, u_int32_t sz, bus_addr_t *addr);
247 static int emu_memfree(struct sc_info *sc, void *buf);
248 static int emu_memstart(struct sc_info *sc, void *buf);
249 #ifdef EMUDEBUG
250 static void emu_vdump(struct sc_info *sc, struct emu_voice *v);
251 #endif
252
253 /* talk to the card */
254 static u_int32_t emu_rd(struct sc_info *, int, int);
255 static void emu_wr(struct sc_info *, int, u_int32_t, int);
256
257 /* -------------------------------------------------------------------- */
258
259 static u_int32_t emu_rfmt_ac97[] = {
260 SND_FORMAT(AFMT_S16_LE, 1, 0),
261 SND_FORMAT(AFMT_S16_LE, 2, 0),
262 0
263 };
264
265 static u_int32_t emu_rfmt_mic[] = {
266 SND_FORMAT(AFMT_U8, 1, 0),
267 0
268 };
269
270 static u_int32_t emu_rfmt_efx[] = {
271 SND_FORMAT(AFMT_S16_LE, 2, 0),
272 0
273 };
274
275 static struct pcmchan_caps emu_reccaps[3] = {
276 {8000, 48000, emu_rfmt_ac97, 0},
277 {8000, 8000, emu_rfmt_mic, 0},
278 {48000, 48000, emu_rfmt_efx, 0},
279 };
280
281 static u_int32_t emu_pfmt[] = {
282 SND_FORMAT(AFMT_U8, 1, 0),
283 SND_FORMAT(AFMT_U8, 2, 0),
284 SND_FORMAT(AFMT_S16_LE, 1, 0),
285 SND_FORMAT(AFMT_S16_LE, 2, 0),
286 0
287 };
288
289 static struct pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0};
290
291 static int adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000};
292 /* audigy supports 12kHz. */
293 static int audigy_adcspeed[9] = {
294 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000
295 };
296
297 /* -------------------------------------------------------------------- */
298 /* Hardware */
299 static u_int32_t
300 emu_rd(struct sc_info *sc, int regno, int size)
301 {
302 switch (size) {
303 case 1:
304 return bus_space_read_1(sc->st, sc->sh, regno);
305 case 2:
306 return bus_space_read_2(sc->st, sc->sh, regno);
307 case 4:
308 return bus_space_read_4(sc->st, sc->sh, regno);
309 default:
310 return 0xffffffff;
311 }
312 }
313
314 static void
315 emu_wr(struct sc_info *sc, int regno, u_int32_t data, int size)
316 {
317 switch (size) {
318 case 1:
319 bus_space_write_1(sc->st, sc->sh, regno, data);
320 break;
321 case 2:
322 bus_space_write_2(sc->st, sc->sh, regno, data);
323 break;
324 case 4:
325 bus_space_write_4(sc->st, sc->sh, regno, data);
326 break;
327 }
328 }
329
330 static u_int32_t
331 emu_rdptr(struct sc_info *sc, int chn, int reg)
332 {
333 u_int32_t ptr, val, mask, size, offset;
334
335 ptr = ((reg << 16) & sc->addrmask) | (chn & EMU_PTR_CHNO_MASK);
336 emu_wr(sc, EMU_PTR, ptr, 4);
337 val = emu_rd(sc, EMU_DATA, 4);
338 if (reg & 0xff000000) {
339 size = (reg >> 24) & 0x3f;
340 offset = (reg >> 16) & 0x1f;
341 mask = ((1 << size) - 1) << offset;
342 val &= mask;
343 val >>= offset;
344 }
345 return val;
346 }
347
348 static void
349 emu_wrptr(struct sc_info *sc, int chn, int reg, u_int32_t data)
350 {
351 u_int32_t ptr, mask, size, offset;
352
353 ptr = ((reg << 16) & sc->addrmask) | (chn & EMU_PTR_CHNO_MASK);
354 emu_wr(sc, EMU_PTR, ptr, 4);
355 if (reg & 0xff000000) {
356 size = (reg >> 24) & 0x3f;
357 offset = (reg >> 16) & 0x1f;
358 mask = ((1 << size) - 1) << offset;
359 data <<= offset;
360 data &= mask;
361 data |= emu_rd(sc, EMU_DATA, 4) & ~mask;
362 }
363 emu_wr(sc, EMU_DATA, data, 4);
364 }
365
366 static void
367 emu_wrefx(struct sc_info *sc, unsigned int pc, unsigned int data)
368 {
369 pc += sc->audigy ? EMU_A_MICROCODEBASE : EMU_MICROCODEBASE;
370 emu_wrptr(sc, 0, pc, data);
371 }
372
373 /* -------------------------------------------------------------------- */
374 /* ac97 codec */
375 /* no locking needed */
376
377 static int
378 emu_rdcd(kobj_t obj, void *devinfo, int regno)
379 {
380 struct sc_info *sc = (struct sc_info *)devinfo;
381
382 emu_wr(sc, EMU_AC97ADDR, regno, 1);
383 return emu_rd(sc, EMU_AC97DATA, 2);
384 }
385
386 static int
387 emu_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
388 {
389 struct sc_info *sc = (struct sc_info *)devinfo;
390
391 emu_wr(sc, EMU_AC97ADDR, regno, 1);
392 emu_wr(sc, EMU_AC97DATA, data, 2);
393 return 0;
394 }
395
396 static kobj_method_t emu_ac97_methods[] = {
397 KOBJMETHOD(ac97_read, emu_rdcd),
398 KOBJMETHOD(ac97_write, emu_wrcd),
399 KOBJMETHOD_END
400 };
401 AC97_DECLARE(emu_ac97);
402
403 /* -------------------------------------------------------------------- */
404 /* stuff */
405 static int
406 emu_settimer(struct sc_info *sc)
407 {
408 struct sc_pchinfo *pch;
409 struct sc_rchinfo *rch;
410 int i, tmp, rate;
411
412 rate = 0;
413 for (i = 0; i < sc->nchans; i++) {
414 pch = &sc->pch[i];
415 if (pch->buffer) {
416 tmp = (pch->spd * sndbuf_getalign(pch->buffer))
417 / pch->blksz;
418 if (tmp > rate)
419 rate = tmp;
420 }
421 }
422
423 for (i = 0; i < 3; i++) {
424 rch = &sc->rch[i];
425 if (rch->buffer) {
426 tmp = (rch->spd * sndbuf_getalign(rch->buffer))
427 / rch->blksz;
428 if (tmp > rate)
429 rate = tmp;
430 }
431 }
432 RANGE(rate, 48, 9600);
433 sc->timerinterval = 48000 / rate;
434 emu_wr(sc, EMU_TIMER, sc->timerinterval & 0x03ff, 2);
435
436 return sc->timerinterval;
437 }
438
439 static int
440 emu_enatimer(struct sc_info *sc, int go)
441 {
442 u_int32_t x;
443 if (go) {
444 if (sc->timer++ == 0) {
445 x = emu_rd(sc, EMU_INTE, 4);
446 x |= EMU_INTE_INTERTIMERENB;
447 emu_wr(sc, EMU_INTE, x, 4);
448 }
449 } else {
450 sc->timer = 0;
451 x = emu_rd(sc, EMU_INTE, 4);
452 x &= ~EMU_INTE_INTERTIMERENB;
453 emu_wr(sc, EMU_INTE, x, 4);
454 }
455 return 0;
456 }
457
458 static void
459 emu_enastop(struct sc_info *sc, char channel, int enable)
460 {
461 int reg = (channel & 0x20) ? EMU_SOLEH : EMU_SOLEL;
462 channel &= 0x1f;
463 reg |= 1 << 24;
464 reg |= channel << 16;
465 emu_wrptr(sc, 0, reg, enable);
466 }
467
468 static int
469 emu_recval(int speed) {
470 int val;
471
472 val = 0;
473 while (val < 7 && speed < adcspeed[val])
474 val++;
475 return val;
476 }
477
478 static int
479 audigy_recval(int speed) {
480 int val;
481
482 val = 0;
483 while (val < 8 && speed < audigy_adcspeed[val])
484 val++;
485 return val;
486 }
487
488 static u_int32_t
489 emu_rate_to_pitch(u_int32_t rate)
490 {
491 static u_int32_t logMagTable[128] = {
492 0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3, 0x13aa2,
493 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a, 0x2655d, 0x28ed5,
494 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb, 0x381b6, 0x3a93d, 0x3d081,
495 0x3f782, 0x41e42, 0x444c1, 0x46b01, 0x49101, 0x4b6c4, 0x4dc49, 0x50191,
496 0x5269e, 0x54b6f, 0x57006, 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7,
497 0x646ee, 0x66a00, 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829,
498 0x759d4, 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
499 0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20, 0x93d26,
500 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec, 0xa11d8, 0xa2f9d,
501 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241, 0xadf26, 0xafbe7, 0xb1885,
502 0xb3500, 0xb5157, 0xb6d8c, 0xb899f, 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899,
503 0xc1404, 0xc2f50, 0xc4a7b, 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c,
504 0xceaec, 0xd053f, 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3,
505 0xdba4a, 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
506 0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a, 0xf2c83,
507 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57, 0xfd1a7, 0xfe8df
508 };
509 static char logSlopeTable[128] = {
510 0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
511 0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
512 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
513 0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
514 0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
515 0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
516 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
517 0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
518 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
519 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
520 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
521 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
522 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
523 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
524 0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
525 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
526 };
527 int i;
528
529 if (rate == 0)
530 return 0; /* Bail out if no leading "1" */
531 rate *= 11185; /* Scale 48000 to 0x20002380 */
532 for (i = 31; i > 0; i--) {
533 if (rate & 0x80000000) { /* Detect leading "1" */
534 return (((u_int32_t) (i - 15) << 20) +
535 logMagTable[0x7f & (rate >> 24)] +
536 (0x7f & (rate >> 17)) *
537 logSlopeTable[0x7f & (rate >> 24)]);
538 }
539 rate <<= 1;
540 }
541
542 return 0; /* Should never reach this point */
543 }
544
545 static u_int32_t
546 emu_rate_to_linearpitch(u_int32_t rate)
547 {
548 rate = (rate << 8) / 375;
549 return (rate >> 1) + (rate & 1);
550 }
551
552 static struct emu_voice *
553 emu_valloc(struct sc_info *sc)
554 {
555 struct emu_voice *v;
556 int i;
557
558 v = NULL;
559 for (i = 0; i < 64 && sc->voice[i].busy; i++);
560 if (i < 64) {
561 v = &sc->voice[i];
562 v->busy = 1;
563 }
564 return v;
565 }
566
567 static int
568 emu_vinit(struct sc_info *sc, struct emu_voice *m, struct emu_voice *s,
569 u_int32_t sz, struct snd_dbuf *b)
570 {
571 void *buf;
572 bus_addr_t tmp_addr;
573
574 buf = emu_memalloc(sc, sz, &tmp_addr);
575 if (buf == NULL)
576 return -1;
577 if (b != NULL)
578 sndbuf_setup(b, buf, sz);
579 m->start = emu_memstart(sc, buf) * EMUPAGESIZE;
580 m->end = m->start + sz;
581 m->channel = NULL;
582 m->speed = 0;
583 m->b16 = 0;
584 m->stereo = 0;
585 m->running = 0;
586 m->ismaster = 1;
587 m->vol = 0xff;
588 m->buf = tmp_addr;
589 m->slave = s;
590 if (sc->audigy) {
591 m->fxrt1 = FXBUS_MIDI_CHORUS | FXBUS_PCM_RIGHT << 8 |
592 FXBUS_PCM_LEFT << 16 | FXBUS_MIDI_REVERB << 24;
593 m->fxrt2 = 0x3f3f3f3f; /* No effects on second route */
594 } else {
595 m->fxrt1 = FXBUS_MIDI_CHORUS | FXBUS_PCM_RIGHT << 4 |
596 FXBUS_PCM_LEFT << 8 | FXBUS_MIDI_REVERB << 12;
597 m->fxrt2 = 0;
598 }
599
600 if (s != NULL) {
601 s->start = m->start;
602 s->end = m->end;
603 s->channel = NULL;
604 s->speed = 0;
605 s->b16 = 0;
606 s->stereo = 0;
607 s->running = 0;
608 s->ismaster = 0;
609 s->vol = m->vol;
610 s->buf = m->buf;
611 s->fxrt1 = m->fxrt1;
612 s->fxrt2 = m->fxrt2;
613 s->slave = NULL;
614 }
615 return 0;
616 }
617
618 static void
619 emu_vsetup(struct sc_pchinfo *ch)
620 {
621 struct emu_voice *v = ch->master;
622
623 if (ch->fmt) {
624 v->b16 = (ch->fmt & AFMT_16BIT) ? 1 : 0;
625 v->stereo = (AFMT_CHANNEL(ch->fmt) > 1) ? 1 : 0;
626 if (v->slave != NULL) {
627 v->slave->b16 = v->b16;
628 v->slave->stereo = v->stereo;
629 }
630 }
631 if (ch->spd) {
632 v->speed = ch->spd;
633 if (v->slave != NULL)
634 v->slave->speed = v->speed;
635 }
636 }
637
638 static void
639 emu_vwrite(struct sc_info *sc, struct emu_voice *v)
640 {
641 int s;
642 int l, r, x, y;
643 u_int32_t sa, ea, start, val, silent_page;
644
645 s = (v->stereo ? 1 : 0) + (v->b16 ? 1 : 0);
646
647 sa = v->start >> s;
648 ea = v->end >> s;
649
650 l = r = x = y = v->vol;
651 if (v->stereo) {
652 l = v->ismaster ? l : 0;
653 r = v->ismaster ? 0 : r;
654 }
655
656 emu_wrptr(sc, v->vnum, EMU_CHAN_CPF, v->stereo ? EMU_CHAN_CPF_STEREO_MASK : 0);
657 val = v->stereo ? 28 : 30;
658 val *= v->b16 ? 1 : 2;
659 start = sa + val;
660
661 if (sc->audigy) {
662 emu_wrptr(sc, v->vnum, EMU_A_CHAN_FXRT1, v->fxrt1);
663 emu_wrptr(sc, v->vnum, EMU_A_CHAN_FXRT2, v->fxrt2);
664 emu_wrptr(sc, v->vnum, EMU_A_CHAN_SENDAMOUNTS, 0);
665 }
666 else
667 emu_wrptr(sc, v->vnum, EMU_CHAN_FXRT, v->fxrt1 << 16);
668
669 emu_wrptr(sc, v->vnum, EMU_CHAN_PTRX, (x << 8) | r);
670 emu_wrptr(sc, v->vnum, EMU_CHAN_DSL, ea | (y << 24));
671 emu_wrptr(sc, v->vnum, EMU_CHAN_PSST, sa | (l << 24));
672 emu_wrptr(sc, v->vnum, EMU_CHAN_CCCA, start | (v->b16 ? 0 : EMU_CHAN_CCCA_8BITSELECT));
673
674 emu_wrptr(sc, v->vnum, EMU_CHAN_Z1, 0);
675 emu_wrptr(sc, v->vnum, EMU_CHAN_Z2, 0);
676
677 silent_page = ((u_int32_t)(sc->mem.silent_page_addr) << 1)
678 | EMU_CHAN_MAP_PTI_MASK;
679 emu_wrptr(sc, v->vnum, EMU_CHAN_MAPA, silent_page);
680 emu_wrptr(sc, v->vnum, EMU_CHAN_MAPB, silent_page);
681
682 emu_wrptr(sc, v->vnum, EMU_CHAN_CVCF, EMU_CHAN_CVCF_CURRFILTER_MASK);
683 emu_wrptr(sc, v->vnum, EMU_CHAN_VTFT, EMU_CHAN_VTFT_FILTERTARGET_MASK);
684 emu_wrptr(sc, v->vnum, EMU_CHAN_ATKHLDM, 0);
685 emu_wrptr(sc, v->vnum, EMU_CHAN_DCYSUSM, EMU_CHAN_DCYSUSM_DECAYTIME_MASK);
686 emu_wrptr(sc, v->vnum, EMU_CHAN_LFOVAL1, 0x8000);
687 emu_wrptr(sc, v->vnum, EMU_CHAN_LFOVAL2, 0x8000);
688 emu_wrptr(sc, v->vnum, EMU_CHAN_FMMOD, 0);
689 emu_wrptr(sc, v->vnum, EMU_CHAN_TREMFRQ, 0);
690 emu_wrptr(sc, v->vnum, EMU_CHAN_FM2FRQ2, 0);
691 emu_wrptr(sc, v->vnum, EMU_CHAN_ENVVAL, 0x8000);
692
693 emu_wrptr(sc, v->vnum, EMU_CHAN_ATKHLDV,
694 EMU_CHAN_ATKHLDV_HOLDTIME_MASK | EMU_CHAN_ATKHLDV_ATTACKTIME_MASK);
695 emu_wrptr(sc, v->vnum, EMU_CHAN_ENVVOL, 0x8000);
696
697 emu_wrptr(sc, v->vnum, EMU_CHAN_PEFE_FILTERAMOUNT, 0x7f);
698 emu_wrptr(sc, v->vnum, EMU_CHAN_PEFE_PITCHAMOUNT, 0);
699
700 if (v->slave != NULL)
701 emu_vwrite(sc, v->slave);
702 }
703
704 static void
705 emu_vtrigger(struct sc_info *sc, struct emu_voice *v, int go)
706 {
707 u_int32_t pitch_target, initial_pitch;
708 u_int32_t cra, cs, ccis;
709 u_int32_t sample, i;
710
711 if (go) {
712 cra = 64;
713 cs = v->stereo ? 4 : 2;
714 ccis = v->stereo ? 28 : 30;
715 ccis *= v->b16 ? 1 : 2;
716 sample = v->b16 ? 0x00000000 : 0x80808080;
717
718 for (i = 0; i < cs; i++)
719 emu_wrptr(sc, v->vnum, EMU_CHAN_CD0 + i, sample);
720 emu_wrptr(sc, v->vnum, EMU_CHAN_CCR_CACHEINVALIDSIZE, 0);
721 emu_wrptr(sc, v->vnum, EMU_CHAN_CCR_READADDRESS, cra);
722 emu_wrptr(sc, v->vnum, EMU_CHAN_CCR_CACHEINVALIDSIZE, ccis);
723
724 emu_wrptr(sc, v->vnum, EMU_CHAN_IFATN, 0xff00);
725 emu_wrptr(sc, v->vnum, EMU_CHAN_VTFT, 0xffffffff);
726 emu_wrptr(sc, v->vnum, EMU_CHAN_CVCF, 0xffffffff);
727 emu_wrptr(sc, v->vnum, EMU_CHAN_DCYSUSV, 0x00007f7f);
728 emu_enastop(sc, v->vnum, 0);
729
730 pitch_target = emu_rate_to_linearpitch(v->speed);
731 initial_pitch = emu_rate_to_pitch(v->speed) >> 8;
732 emu_wrptr(sc, v->vnum, EMU_CHAN_PTRX_PITCHTARGET, pitch_target);
733 emu_wrptr(sc, v->vnum, EMU_CHAN_CPF_PITCH, pitch_target);
734 emu_wrptr(sc, v->vnum, EMU_CHAN_IP, initial_pitch);
735 } else {
736 emu_wrptr(sc, v->vnum, EMU_CHAN_PTRX_PITCHTARGET, 0);
737 emu_wrptr(sc, v->vnum, EMU_CHAN_CPF_PITCH, 0);
738 emu_wrptr(sc, v->vnum, EMU_CHAN_IFATN, 0xffff);
739 emu_wrptr(sc, v->vnum, EMU_CHAN_VTFT, 0x0000ffff);
740 emu_wrptr(sc, v->vnum, EMU_CHAN_CVCF, 0x0000ffff);
741 emu_wrptr(sc, v->vnum, EMU_CHAN_IP, 0);
742 emu_enastop(sc, v->vnum, 1);
743 }
744 if (v->slave != NULL)
745 emu_vtrigger(sc, v->slave, go);
746 }
747
748 static int
749 emu_vpos(struct sc_info *sc, struct emu_voice *v)
750 {
751 int s, ptr;
752
753 s = (v->b16 ? 1 : 0) + (v->stereo ? 1 : 0);
754 ptr = (emu_rdptr(sc, v->vnum, EMU_CHAN_CCCA_CURRADDR) - (v->start >> s)) << s;
755 return ptr & ~0x0000001f;
756 }
757
758 #ifdef EMUDEBUG
759 static void
760 emu_vdump(struct sc_info *sc, struct emu_voice *v)
761 {
762 char *regname[] = {
763 "cpf", "ptrx", "cvcf", "vtft", "z2", "z1", "psst", "dsl",
764 "ccca", "ccr", "clp", "fxrt", "mapa", "mapb", NULL, NULL,
765 "envvol", "atkhldv", "dcysusv", "lfoval1",
766 "envval", "atkhldm", "dcysusm", "lfoval2",
767 "ip", "ifatn", "pefe", "fmmod", "tremfrq", "fmfrq2",
768 "tempenv"
769 };
770 char *regname2[] = {
771 "mudata1", "mustat1", "mudata2", "mustat2",
772 "fxwc1", "fxwc2", "spdrate", NULL, NULL,
773 NULL, NULL, NULL, "fxrt2", "sndamnt", "fxrt1",
774 NULL, NULL
775 };
776 int i, x;
777
778 printf("voice number %d\n", v->vnum);
779 for (i = 0, x = 0; i <= 0x1e; i++) {
780 if (regname[i] == NULL)
781 continue;
782 printf("%s\t[%08x]", regname[i], emu_rdptr(sc, v->vnum, i));
783 printf("%s", (x == 2) ? "\n" : "\t");
784 x++;
785 if (x > 2)
786 x = 0;
787 }
788
789 /* Print out audigy extra registers */
790 if (sc->audigy) {
791 for (i = 0; i <= 0xe; i++) {
792 if (regname2[i] == NULL)
793 continue;
794 printf("%s\t[%08x]", regname2[i],
795 emu_rdptr(sc, v->vnum, i + 0x70));
796 printf("%s", (x == 2)? "\n" : "\t");
797 x++;
798 if (x > 2)
799 x = 0;
800 }
801 }
802 printf("\n\n");
803 }
804 #endif
805
806 /* channel interface */
807 static void *
808 emupchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
809 struct pcm_channel *c, int dir)
810 {
811 struct sc_info *sc = devinfo;
812 struct sc_pchinfo *ch;
813 void *r;
814
815 KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction"));
816 ch = &sc->pch[sc->pnum++];
817 ch->buffer = b;
818 ch->parent = sc;
819 ch->channel = c;
820 ch->blksz = sc->bufsz / 2;
821 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
822 ch->spd = 8000;
823 snd_mtxlock(sc->lock);
824 ch->master = emu_valloc(sc);
825 ch->slave = emu_valloc(sc);
826 snd_mtxunlock(sc->lock);
827 r = (emu_vinit(sc, ch->master, ch->slave, sc->bufsz, ch->buffer))
828 ? NULL : ch;
829
830 return r;
831 }
832
833 static int
834 emupchan_free(kobj_t obj, void *data)
835 {
836 struct sc_pchinfo *ch = data;
837 struct sc_info *sc = ch->parent;
838 int r;
839
840 snd_mtxlock(sc->lock);
841 r = emu_memfree(sc, sndbuf_getbuf(ch->buffer));
842 snd_mtxunlock(sc->lock);
843
844 return r;
845 }
846
847 static int
848 emupchan_setformat(kobj_t obj, void *data, u_int32_t format)
849 {
850 struct sc_pchinfo *ch = data;
851
852 ch->fmt = format;
853 return 0;
854 }
855
856 static u_int32_t
857 emupchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
858 {
859 struct sc_pchinfo *ch = data;
860
861 ch->spd = speed;
862 return ch->spd;
863 }
864
865 static u_int32_t
866 emupchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
867 {
868 struct sc_pchinfo *ch = data;
869 struct sc_info *sc = ch->parent;
870 int irqrate, blksz;
871
872 ch->blksz = blocksize;
873 snd_mtxlock(sc->lock);
874 emu_settimer(sc);
875 irqrate = 48000 / sc->timerinterval;
876 snd_mtxunlock(sc->lock);
877 blksz = (ch->spd * sndbuf_getalign(ch->buffer)) / irqrate;
878 return blocksize;
879 }
880
881 static int
882 emupchan_trigger(kobj_t obj, void *data, int go)
883 {
884 struct sc_pchinfo *ch = data;
885 struct sc_info *sc = ch->parent;
886
887 if (!PCMTRIG_COMMON(go))
888 return 0;
889
890 snd_mtxlock(sc->lock);
891 if (go == PCMTRIG_START) {
892 emu_vsetup(ch);
893 emu_vwrite(sc, ch->master);
894 emu_settimer(sc);
895 emu_enatimer(sc, 1);
896 #ifdef EMUDEBUG
897 printf("start [%d bit, %s, %d hz]\n",
898 ch->master->b16 ? 16 : 8,
899 ch->master->stereo ? "stereo" : "mono",
900 ch->master->speed);
901 emu_vdump(sc, ch->master);
902 emu_vdump(sc, ch->slave);
903 #endif
904 }
905 ch->run = (go == PCMTRIG_START) ? 1 : 0;
906 emu_vtrigger(sc, ch->master, ch->run);
907 snd_mtxunlock(sc->lock);
908 return 0;
909 }
910
911 static u_int32_t
912 emupchan_getptr(kobj_t obj, void *data)
913 {
914 struct sc_pchinfo *ch = data;
915 struct sc_info *sc = ch->parent;
916 int r;
917
918 snd_mtxlock(sc->lock);
919 r = emu_vpos(sc, ch->master);
920 snd_mtxunlock(sc->lock);
921
922 return r;
923 }
924
925 static struct pcmchan_caps *
926 emupchan_getcaps(kobj_t obj, void *data)
927 {
928 return &emu_playcaps;
929 }
930
931 static kobj_method_t emupchan_methods[] = {
932 KOBJMETHOD(channel_init, emupchan_init),
933 KOBJMETHOD(channel_free, emupchan_free),
934 KOBJMETHOD(channel_setformat, emupchan_setformat),
935 KOBJMETHOD(channel_setspeed, emupchan_setspeed),
936 KOBJMETHOD(channel_setblocksize, emupchan_setblocksize),
937 KOBJMETHOD(channel_trigger, emupchan_trigger),
938 KOBJMETHOD(channel_getptr, emupchan_getptr),
939 KOBJMETHOD(channel_getcaps, emupchan_getcaps),
940 KOBJMETHOD_END
941 };
942 CHANNEL_DECLARE(emupchan);
943
944 /* channel interface */
945 static void *
946 emurchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
947 struct pcm_channel *c, int dir)
948 {
949 struct sc_info *sc = devinfo;
950 struct sc_rchinfo *ch;
951
952 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
953 ch = &sc->rch[sc->rnum];
954 ch->buffer = b;
955 ch->parent = sc;
956 ch->channel = c;
957 ch->blksz = sc->bufsz / 2;
958 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
959 ch->spd = 8000;
960 ch->num = sc->rnum;
961 switch(sc->rnum) {
962 case 0:
963 ch->idxreg = sc->audigy ? EMU_A_ADCIDX : EMU_ADCIDX;
964 ch->basereg = EMU_ADCBA;
965 ch->sizereg = EMU_ADCBS;
966 ch->setupreg = EMU_ADCCR;
967 ch->irqmask = EMU_INTE_ADCBUFENABLE;
968 break;
969
970 case 1:
971 ch->idxreg = EMU_FXIDX;
972 ch->basereg = EMU_FXBA;
973 ch->sizereg = EMU_FXBS;
974 ch->setupreg = EMU_FXWC;
975 ch->irqmask = EMU_INTE_EFXBUFENABLE;
976 break;
977
978 case 2:
979 ch->idxreg = EMU_MICIDX;
980 ch->basereg = EMU_MICBA;
981 ch->sizereg = EMU_MICBS;
982 ch->setupreg = 0;
983 ch->irqmask = EMU_INTE_MICBUFENABLE;
984 break;
985 }
986 sc->rnum++;
987 if (sndbuf_alloc(ch->buffer, sc->parent_dmat, 0, sc->bufsz) != 0)
988 return NULL;
989 else {
990 snd_mtxlock(sc->lock);
991 emu_wrptr(sc, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
992 emu_wrptr(sc, 0, ch->sizereg, 0); /* off */
993 snd_mtxunlock(sc->lock);
994 return ch;
995 }
996 }
997
998 static int
999 emurchan_setformat(kobj_t obj, void *data, u_int32_t format)
1000 {
1001 struct sc_rchinfo *ch = data;
1002
1003 ch->fmt = format;
1004 return 0;
1005 }
1006
1007 static u_int32_t
1008 emurchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
1009 {
1010 struct sc_rchinfo *ch = data;
1011
1012 if (ch->num == 0) {
1013 if (ch->parent->audigy)
1014 speed = audigy_adcspeed[audigy_recval(speed)];
1015 else
1016 speed = adcspeed[emu_recval(speed)];
1017 }
1018 if (ch->num == 1)
1019 speed = 48000;
1020 if (ch->num == 2)
1021 speed = 8000;
1022 ch->spd = speed;
1023 return ch->spd;
1024 }
1025
1026 static u_int32_t
1027 emurchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
1028 {
1029 struct sc_rchinfo *ch = data;
1030 struct sc_info *sc = ch->parent;
1031 int irqrate, blksz;
1032
1033 ch->blksz = blocksize;
1034 snd_mtxlock(sc->lock);
1035 emu_settimer(sc);
1036 irqrate = 48000 / sc->timerinterval;
1037 snd_mtxunlock(sc->lock);
1038 blksz = (ch->spd * sndbuf_getalign(ch->buffer)) / irqrate;
1039 return blocksize;
1040 }
1041
1042 /* semantic note: must start at beginning of buffer */
1043 static int
1044 emurchan_trigger(kobj_t obj, void *data, int go)
1045 {
1046 struct sc_rchinfo *ch = data;
1047 struct sc_info *sc = ch->parent;
1048 u_int32_t val, sz;
1049
1050 if (!PCMTRIG_COMMON(go))
1051 return 0;
1052
1053 switch(sc->bufsz) {
1054 case 4096:
1055 sz = EMU_RECBS_BUFSIZE_4096;
1056 break;
1057
1058 case 8192:
1059 sz = EMU_RECBS_BUFSIZE_8192;
1060 break;
1061
1062 case 16384:
1063 sz = EMU_RECBS_BUFSIZE_16384;
1064 break;
1065
1066 case 32768:
1067 sz = EMU_RECBS_BUFSIZE_32768;
1068 break;
1069
1070 case 65536:
1071 sz = EMU_RECBS_BUFSIZE_65536;
1072 break;
1073
1074 default:
1075 sz = EMU_RECBS_BUFSIZE_4096;
1076 }
1077
1078 snd_mtxlock(sc->lock);
1079 switch(go) {
1080 case PCMTRIG_START:
1081 ch->run = 1;
1082 emu_wrptr(sc, 0, ch->sizereg, sz);
1083 if (ch->num == 0) {
1084 if (sc->audigy) {
1085 val = EMU_A_ADCCR_LCHANENABLE;
1086 if (AFMT_CHANNEL(ch->fmt) > 1)
1087 val |= EMU_A_ADCCR_RCHANENABLE;
1088 val |= audigy_recval(ch->spd);
1089 } else {
1090 val = EMU_ADCCR_LCHANENABLE;
1091 if (AFMT_CHANNEL(ch->fmt) > 1)
1092 val |= EMU_ADCCR_RCHANENABLE;
1093 val |= emu_recval(ch->spd);
1094 }
1095
1096 emu_wrptr(sc, 0, ch->setupreg, 0);
1097 emu_wrptr(sc, 0, ch->setupreg, val);
1098 }
1099 val = emu_rd(sc, EMU_INTE, 4);
1100 val |= ch->irqmask;
1101 emu_wr(sc, EMU_INTE, val, 4);
1102 break;
1103
1104 case PCMTRIG_STOP:
1105 case PCMTRIG_ABORT:
1106 ch->run = 0;
1107 emu_wrptr(sc, 0, ch->sizereg, 0);
1108 if (ch->setupreg)
1109 emu_wrptr(sc, 0, ch->setupreg, 0);
1110 val = emu_rd(sc, EMU_INTE, 4);
1111 val &= ~ch->irqmask;
1112 emu_wr(sc, EMU_INTE, val, 4);
1113 break;
1114
1115 case PCMTRIG_EMLDMAWR:
1116 case PCMTRIG_EMLDMARD:
1117 default:
1118 break;
1119 }
1120 snd_mtxunlock(sc->lock);
1121
1122 return 0;
1123 }
1124
1125 static u_int32_t
1126 emurchan_getptr(kobj_t obj, void *data)
1127 {
1128 struct sc_rchinfo *ch = data;
1129 struct sc_info *sc = ch->parent;
1130 int r;
1131
1132 snd_mtxlock(sc->lock);
1133 r = emu_rdptr(sc, 0, ch->idxreg) & 0x0000ffff;
1134 snd_mtxunlock(sc->lock);
1135
1136 return r;
1137 }
1138
1139 static struct pcmchan_caps *
1140 emurchan_getcaps(kobj_t obj, void *data)
1141 {
1142 struct sc_rchinfo *ch = data;
1143
1144 return &emu_reccaps[ch->num];
1145 }
1146
1147 static kobj_method_t emurchan_methods[] = {
1148 KOBJMETHOD(channel_init, emurchan_init),
1149 KOBJMETHOD(channel_setformat, emurchan_setformat),
1150 KOBJMETHOD(channel_setspeed, emurchan_setspeed),
1151 KOBJMETHOD(channel_setblocksize, emurchan_setblocksize),
1152 KOBJMETHOD(channel_trigger, emurchan_trigger),
1153 KOBJMETHOD(channel_getptr, emurchan_getptr),
1154 KOBJMETHOD(channel_getcaps, emurchan_getcaps),
1155 KOBJMETHOD_END
1156 };
1157 CHANNEL_DECLARE(emurchan);
1158
1159 static unsigned char
1160 emu_mread(struct mpu401 *arg, void *sc, int reg)
1161 {
1162 unsigned int d;
1163
1164 d = emu_rd((struct sc_info *)sc, 0x18 + reg, 1);
1165 return d;
1166 }
1167
1168 static void
1169 emu_mwrite(struct mpu401 *arg, void *sc, int reg, unsigned char b)
1170 {
1171
1172 emu_wr((struct sc_info *)sc, 0x18 + reg, b, 1);
1173 }
1174
1175 static int
1176 emu_muninit(struct mpu401 *arg, void *cookie)
1177 {
1178 struct sc_info *sc = cookie;
1179
1180 snd_mtxlock(sc->lock);
1181 sc->mpu_intr = 0;
1182 snd_mtxunlock(sc->lock);
1183
1184 return 0;
1185 }
1186
1187 static kobj_method_t emu_mpu_methods[] = {
1188 KOBJMETHOD(mpufoi_read, emu_mread),
1189 KOBJMETHOD(mpufoi_write, emu_mwrite),
1190 KOBJMETHOD(mpufoi_uninit, emu_muninit),
1191 KOBJMETHOD_END
1192 };
1193
1194 static DEFINE_CLASS(emu_mpu, emu_mpu_methods, 0);
1195
1196 static void
1197 emu_intr2(void *p)
1198 {
1199 struct sc_info *sc = (struct sc_info *)p;
1200
1201 if (sc->mpu_intr)
1202 (sc->mpu_intr)(sc->mpu);
1203 }
1204
1205 static void
1206 emu_midiattach(struct sc_info *sc)
1207 {
1208 int i;
1209
1210 i = emu_rd(sc, EMU_INTE, 4);
1211 i |= EMU_INTE_MIDIRXENABLE;
1212 emu_wr(sc, EMU_INTE, i, 4);
1213
1214 sc->mpu = mpu401_init(&emu_mpu_class, sc, emu_intr2, &sc->mpu_intr);
1215 }
1216 /* -------------------------------------------------------------------- */
1217 /* The interrupt handler */
1218
1219 static void
1220 emu_intr(void *data)
1221 {
1222 struct sc_info *sc = data;
1223 u_int32_t stat, ack, i, x;
1224
1225 snd_mtxlock(sc->lock);
1226 while (1) {
1227 stat = emu_rd(sc, EMU_IPR, 4);
1228 if (stat == 0)
1229 break;
1230 ack = 0;
1231
1232 /* process irq */
1233 if (stat & EMU_IPR_INTERVALTIMER)
1234 ack |= EMU_IPR_INTERVALTIMER;
1235
1236 if (stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL))
1237 ack |= stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL);
1238
1239 if (stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL))
1240 ack |= stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL);
1241
1242 if (stat & (EMU_IPR_MICBUFFULL | EMU_IPR_MICBUFHALFFULL))
1243 ack |= stat & (EMU_IPR_MICBUFFULL | EMU_IPR_MICBUFHALFFULL);
1244
1245 if (stat & EMU_PCIERROR) {
1246 ack |= EMU_PCIERROR;
1247 device_printf(sc->dev, "pci error\n");
1248 /* we still get an nmi with ecc ram even if we ack this */
1249 }
1250 if (stat & EMU_IPR_RATETRCHANGE) {
1251 ack |= EMU_IPR_RATETRCHANGE;
1252 #ifdef EMUDEBUG
1253 device_printf(sc->dev,
1254 "sample rate tracker lock status change\n");
1255 #endif
1256 }
1257
1258 if (stat & EMU_IPR_MIDIRECVBUFE)
1259 if (sc->mpu_intr) {
1260 (sc->mpu_intr)(sc->mpu);
1261 ack |= EMU_IPR_MIDIRECVBUFE | EMU_IPR_MIDITRANSBUFE;
1262 }
1263 if (stat & ~ack)
1264 device_printf(sc->dev, "dodgy irq: %x (harmless)\n",
1265 stat & ~ack);
1266
1267 emu_wr(sc, EMU_IPR, stat, 4);
1268
1269 if (ack) {
1270 snd_mtxunlock(sc->lock);
1271
1272 if (ack & EMU_IPR_INTERVALTIMER) {
1273 x = 0;
1274 for (i = 0; i < sc->nchans; i++) {
1275 if (sc->pch[i].run) {
1276 x = 1;
1277 chn_intr(sc->pch[i].channel);
1278 }
1279 }
1280 if (x == 0)
1281 emu_enatimer(sc, 0);
1282 }
1283
1284
1285 if (ack & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL)) {
1286 if (sc->rch[0].channel)
1287 chn_intr(sc->rch[0].channel);
1288 }
1289 if (ack & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL)) {
1290 if (sc->rch[1].channel)
1291 chn_intr(sc->rch[1].channel);
1292 }
1293 if (ack & (EMU_IPR_MICBUFFULL | EMU_IPR_MICBUFHALFFULL)) {
1294 if (sc->rch[2].channel)
1295 chn_intr(sc->rch[2].channel);
1296 }
1297
1298 snd_mtxlock(sc->lock);
1299 }
1300 }
1301 snd_mtxunlock(sc->lock);
1302 }
1303
1304 /* -------------------------------------------------------------------- */
1305
1306 static void
1307 emu_setmap(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1308 {
1309 bus_addr_t *phys = arg;
1310
1311 *phys = error ? 0 : (bus_addr_t)segs->ds_addr;
1312
1313 if (bootverbose) {
1314 kprintf("emu: setmap (%lx, %lx), nseg=%d, error=%d\n",
1315 (unsigned long)segs->ds_addr, (unsigned long)segs->ds_len,
1316 nseg, error);
1317 }
1318 }
1319
1320 static void *
1321 emu_malloc(struct sc_info *sc, u_int32_t sz, bus_addr_t *addr,
1322 bus_dmamap_t *map)
1323 {
1324 void *buf;
1325
1326 *addr = 0;
1327 if (bus_dmamem_alloc(sc->parent_dmat, &buf, BUS_DMA_NOWAIT, map))
1328 return NULL;
1329 if (bus_dmamap_load(sc->parent_dmat, *map, buf, sz, emu_setmap, addr, 0)
1330 || !*addr) {
1331 bus_dmamem_free(sc->parent_dmat, buf, *map);
1332 return NULL;
1333 }
1334 return buf;
1335 }
1336
1337 static void
1338 emu_free(struct sc_info *sc, void *buf, bus_dmamap_t map)
1339 {
1340 bus_dmamap_unload(sc->parent_dmat, map);
1341 bus_dmamem_free(sc->parent_dmat, buf, map);
1342 }
1343
1344 static void *
1345 emu_memalloc(struct sc_info *sc, u_int32_t sz, bus_addr_t *addr)
1346 {
1347 u_int32_t blksz, start, idx, ofs, tmp, found;
1348 struct emu_mem *mem = &sc->mem;
1349 struct emu_memblk *blk;
1350 void *buf;
1351
1352 blksz = sz / EMUPAGESIZE;
1353 if (sz > (blksz * EMUPAGESIZE))
1354 blksz++;
1355 /* find a free block in the bitmap */
1356 found = 0;
1357 start = 1;
1358 while (!found && start + blksz < EMUMAXPAGES) {
1359 found = 1;
1360 for (idx = start; idx < start + blksz; idx++)
1361 if (mem->bmap[idx >> 3] & (1 << (idx & 7)))
1362 found = 0;
1363 if (!found)
1364 start++;
1365 }
1366 if (!found)
1367 return NULL;
1368 blk = kmalloc(sizeof(*blk), M_DEVBUF, M_WAITOK | M_ZERO);
1369 if (blk == NULL)
1370 return NULL;
1371 buf = emu_malloc(sc, sz, &blk->buf_addr, &blk->buf_map);
1372 *addr = blk->buf_addr;
1373 if (buf == NULL) {
1374 kfree(blk, M_DEVBUF);
1375 return NULL;
1376 }
1377 blk->buf = buf;
1378 blk->pte_start = start;
1379 blk->pte_size = blksz;
1380 #ifdef EMUDEBUG
1381 printf("buf %p, pte_start %d, pte_size %d\n", blk->buf,
1382 blk->pte_start, blk->pte_size);
1383 #endif
1384 ofs = 0;
1385 for (idx = start; idx < start + blksz; idx++) {
1386 mem->bmap[idx >> 3] |= 1 << (idx & 7);
1387 tmp = (uint32_t)(blk->buf_addr + ofs);
1388 #ifdef EMUDEBUG
1389 printf("pte[%d] -> %x phys, %x virt\n", idx, tmp,
1390 ((u_int32_t)buf) + ofs);
1391 #endif
1392 mem->ptb_pages[idx] = (tmp << 1) | idx;
1393 ofs += EMUPAGESIZE;
1394 }
1395 SLIST_INSERT_HEAD(&mem->blocks, blk, link);
1396 return buf;
1397 }
1398
1399 static int
1400 emu_memfree(struct sc_info *sc, void *buf)
1401 {
1402 u_int32_t idx, tmp;
1403 struct emu_mem *mem = &sc->mem;
1404 struct emu_memblk *blk, *i;
1405
1406 blk = NULL;
1407 SLIST_FOREACH(i, &mem->blocks, link) {
1408 if (i->buf == buf)
1409 blk = i;
1410 }
1411 if (blk == NULL)
1412 return EINVAL;
1413 SLIST_REMOVE(&mem->blocks, blk, emu_memblk, link);
1414 emu_free(sc, buf, blk->buf_map);
1415 tmp = (u_int32_t)(sc->mem.silent_page_addr) << 1;
1416 for (idx = blk->pte_start; idx < blk->pte_start + blk->pte_size; idx++) {
1417 mem->bmap[idx >> 3] &= ~(1 << (idx & 7));
1418 mem->ptb_pages[idx] = tmp | idx;
1419 }
1420 kfree(blk, M_DEVBUF);
1421 return 0;
1422 }
1423
1424 static int
1425 emu_memstart(struct sc_info *sc, void *buf)
1426 {
1427 struct emu_mem *mem = &sc->mem;
1428 struct emu_memblk *blk, *i;
1429
1430 blk = NULL;
1431 SLIST_FOREACH(i, &mem->blocks, link) {
1432 if (i->buf == buf)
1433 blk = i;
1434 }
1435 if (blk == NULL)
1436 return -EINVAL;
1437 return blk->pte_start;
1438 }
1439
1440 static void
1441 emu_addefxop(struct sc_info *sc, int op, int z, int w, int x, int y,
1442 u_int32_t *pc)
1443 {
1444 emu_wrefx(sc, (*pc) * 2, (x << 10) | y);
1445 emu_wrefx(sc, (*pc) * 2 + 1, (op << 20) | (z << 10) | w);
1446 (*pc)++;
1447 }
1448
1449 static void
1450 audigy_addefxop(struct sc_info *sc, int op, int z, int w, int x, int y,
1451 u_int32_t *pc)
1452 {
1453 emu_wrefx(sc, (*pc) * 2, (x << 12) | y);
1454 emu_wrefx(sc, (*pc) * 2 + 1, (op << 24) | (z << 12) | w);
1455 (*pc)++;
1456 }
1457
1458 static void
1459 audigy_initefx(struct sc_info *sc)
1460 {
1461 int i;
1462 u_int32_t pc = 0;
1463
1464 /* skip 0, 0, -1, 0 - NOPs */
1465 for (i = 0; i < 512; i++)
1466 audigy_addefxop(sc, 0x0f, 0x0c0, 0x0c0, 0x0cf, 0x0c0, &pc);
1467
1468 for (i = 0; i < 512; i++)
1469 emu_wrptr(sc, 0, EMU_A_FXGPREGBASE + i, 0x0);
1470
1471 pc = 16;
1472
1473 /* stop fx processor */
1474 emu_wrptr(sc, 0, EMU_A_DBG, EMU_A_DBG_SINGLE_STEP);
1475
1476 /* Audigy 2 (EMU10K2) DSP Registers:
1477 FX Bus
1478 0x000-0x00f : 16 registers (?)
1479 Input
1480 0x040/0x041 : AC97 Codec (l/r)
1481 0x042/0x043 : ADC, S/PDIF (l/r)
1482 0x044/0x045 : Optical S/PDIF in (l/r)
1483 0x046/0x047 : ?
1484 0x048/0x049 : Line/Mic 2 (l/r)
1485 0x04a/0x04b : RCA S/PDIF (l/r)
1486 0x04c/0x04d : Aux 2 (l/r)
1487 Output
1488 0x060/0x061 : Digital Front (l/r)
1489 0x062/0x063 : Digital Center/LFE
1490 0x064/0x065 : AudigyDrive Heaphone (l/r)
1491 0x066/0x067 : Digital Rear (l/r)
1492 0x068/0x069 : Analog Front (l/r)
1493 0x06a/0x06b : Analog Center/LFE
1494 0x06c/0x06d : ?
1495 0x06e/0x06f : Analog Rear (l/r)
1496 0x070/0x071 : AC97 Output (l/r)
1497 0x072/0x073 : ?
1498 0x074/0x075 : ?
1499 0x076/0x077 : ADC Recording Buffer (l/r)
1500 Constants
1501 0x0c0 - 0x0c4 = 0 - 4
1502 0x0c5 = 0x8, 0x0c6 = 0x10, 0x0c7 = 0x20
1503 0x0c8 = 0x100, 0x0c9 = 0x10000, 0x0ca = 0x80000
1504 0x0cb = 0x10000000, 0x0cc = 0x20000000, 0x0cd = 0x40000000
1505 0x0ce = 0x80000000, 0x0cf = 0x7fffffff, 0x0d0 = 0xffffffff
1506 0x0d1 = 0xfffffffe, 0x0d2 = 0xc0000000, 0x0d3 = 0x41fbbcdc
1507 0x0d4 = 0x5a7ef9db, 0x0d5 = 0x00100000, 0x0dc = 0x00000001 (?)
1508 Temporary Values
1509 0x0d6 : Accumulator (?)
1510 0x0d7 : Condition Register
1511 0x0d8 : Noise source
1512 0x0d9 : Noise source
1513 Tank Memory Data Registers
1514 0x200 - 0x2ff
1515 Tank Memory Address Registers
1516 0x300 - 0x3ff
1517 General Purpose Registers
1518 0x400 - 0x5ff
1519 */
1520
1521 /* AC97Output[l/r] = FXBus PCM[l/r] */
1522 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AC97_L), A_C_00000000,
1523 A_C_00000000, A_FXBUS(FXBUS_PCM_LEFT), &pc);
1524 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AC97_R), A_C_00000000,
1525 A_C_00000000, A_FXBUS(FXBUS_PCM_RIGHT), &pc);
1526
1527 /* GPR[0/1] = RCA S/PDIF[l/r] -- Master volume */
1528 audigy_addefxop(sc, iACC3, A_GPR(0), A_C_00000000,
1529 A_C_00000000, A_EXTIN(EXTIN_COAX_SPDIF_L), &pc);
1530 audigy_addefxop(sc, iACC3, A_GPR(1), A_C_00000000,
1531 A_C_00000000, A_EXTIN(EXTIN_COAX_SPDIF_R), &pc);
1532
1533 /* GPR[2] = GPR[0] (Left) / 2 + GPR[1] (Right) / 2 -- Central volume */
1534 audigy_addefxop(sc, iINTERP, A_GPR(2), A_GPR(1),
1535 A_C_40000000, A_GPR(0), &pc);
1536
1537 /* Headphones[l/r] = GPR[0/1] */
1538 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_HEADPHONE_L),
1539 A_C_00000000, A_C_00000000, A_GPR(0), &pc);
1540 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_HEADPHONE_R),
1541 A_C_00000000, A_C_00000000, A_GPR(1), &pc);
1542
1543 /* Analog Front[l/r] = GPR[0/1] */
1544 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AFRONT_L), A_C_00000000,
1545 A_C_00000000, A_GPR(0), &pc);
1546 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AFRONT_R), A_C_00000000,
1547 A_C_00000000, A_GPR(1), &pc);
1548
1549 /* Digital Front[l/r] = GPR[0/1] */
1550 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L), A_C_00000000,
1551 A_C_00000000, A_GPR(0), &pc);
1552 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_FRONT_R), A_C_00000000,
1553 A_C_00000000, A_GPR(1), &pc);
1554
1555 /* Center and Subwoofer configuration */
1556 /* Analog Center = GPR[0] + GPR[2] */
1557 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_ACENTER), A_C_00000000,
1558 A_GPR(0), A_GPR(2), &pc);
1559 /* Analog Sub = GPR[1] + GPR[2] */
1560 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_ALFE), A_C_00000000,
1561 A_GPR(1), A_GPR(2), &pc);
1562
1563 /* Digital Center = GPR[0] + GPR[2] */
1564 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_CENTER), A_C_00000000,
1565 A_GPR(0), A_GPR(2), &pc);
1566 /* Digital Sub = GPR[1] + GPR[2] */
1567 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_LFE), A_C_00000000,
1568 A_GPR(1), A_GPR(2), &pc);
1569
1570 #if 0
1571 /* Analog Rear[l/r] = (GPR[0/1] * RearVolume[l/r]) >> 31 */
1572 /* RearVolume = GPR[0x10/0x11] (Will this ever be implemented?) */
1573 audigy_addefxop(sc, iMAC0, A_EXTOUT(A_EXTOUT_AREAR_L), A_C_00000000,
1574 A_GPR(16), A_GPR(0), &pc);
1575 audigy_addefxop(sc, iMAC0, A_EXTOUT(A_EXTOUT_AREAR_R), A_C_00000000,
1576 A_GPR(17), A_GPR(1), &pc);
1577
1578 /* Digital Rear[l/r] = (GPR[0/1] * RearVolume[l/r]) >> 31 */
1579 /* RearVolume = GPR[0x10/0x11] (Will this ever be implemented?) */
1580 audigy_addefxop(sc, iMAC0, A_EXTOUT(A_EXTOUT_REAR_L), A_C_00000000,
1581 A_GPR(16), A_GPR(0), &pc);
1582 audigy_addefxop(sc, iMAC0, A_EXTOUT(A_EXTOUT_REAR_R), A_C_00000000,
1583 A_GPR(17), A_GPR(1), &pc);
1584 #else
1585 /* XXX This is just a copy to the channel, since we do not have
1586 * a patch manager, it is useful for have another output enabled.
1587 */
1588
1589 /* Analog Rear[l/r] = GPR[0/1] */
1590 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AREAR_L), A_C_00000000,
1591 A_C_00000000, A_GPR(0), &pc);
1592 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AREAR_R), A_C_00000000,
1593 A_C_00000000, A_GPR(1), &pc);
1594
1595 /* Digital Rear[l/r] = GPR[0/1] */
1596 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_REAR_L), A_C_00000000,
1597 A_C_00000000, A_GPR(0), &pc);
1598 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_REAR_R), A_C_00000000,
1599 A_C_00000000, A_GPR(1), &pc);
1600 #endif
1601
1602 /* ADC Recording buffer[l/r] = AC97Input[l/r] */
1603 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_ADC_CAP_L), A_C_00000000,
1604 A_C_00000000, A_EXTIN(A_EXTIN_AC97_L), &pc);
1605 audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_ADC_CAP_R), A_C_00000000,
1606 A_C_00000000, A_EXTIN(A_EXTIN_AC97_R), &pc);
1607
1608 /* resume normal operations */
1609 emu_wrptr(sc, 0, EMU_A_DBG, 0);
1610 }
1611
1612 static void
1613 emu_initefx(struct sc_info *sc)
1614 {
1615 int i;
1616 u_int32_t pc = 16;
1617
1618 /* acc3 0,0,0,0 - NOPs */
1619 for (i = 0; i < 512; i++) {
1620 emu_wrefx(sc, i * 2, 0x10040);
1621 emu_wrefx(sc, i * 2 + 1, 0x610040);
1622 }
1623
1624 for (i = 0; i < 256; i++)
1625 emu_wrptr(sc, 0, EMU_FXGPREGBASE + i, 0);
1626
1627 /* FX-8010 DSP Registers:
1628 FX Bus
1629 0x000-0x00f : 16 registers
1630 Input
1631 0x010/0x011 : AC97 Codec (l/r)
1632 0x012/0x013 : ADC, S/PDIF (l/r)
1633 0x014/0x015 : Mic(left), Zoom (l/r)
1634 0x016/0x017 : TOS link in (l/r)
1635 0x018/0x019 : Line/Mic 1 (l/r)
1636 0x01a/0x01b : COAX S/PDIF (l/r)
1637 0x01c/0x01d : Line/Mic 2 (l/r)
1638 Output
1639 0x020/0x021 : AC97 Output (l/r)
1640 0x022/0x023 : TOS link out (l/r)
1641 0x024/0x025 : Center/LFE
1642 0x026/0x027 : LiveDrive Headphone (l/r)
1643 0x028/0x029 : Rear Channel (l/r)
1644 0x02a/0x02b : ADC Recording Buffer (l/r)
1645 0x02c : Mic Recording Buffer
1646 0x031/0x032 : Analog Center/LFE
1647 Constants
1648 0x040 - 0x044 = 0 - 4
1649 0x045 = 0x8, 0x046 = 0x10, 0x047 = 0x20
1650 0x048 = 0x100, 0x049 = 0x10000, 0x04a = 0x80000
1651 0x04b = 0x10000000, 0x04c = 0x20000000, 0x04d = 0x40000000
1652 0x04e = 0x80000000, 0x04f = 0x7fffffff, 0x050 = 0xffffffff
1653 0x051 = 0xfffffffe, 0x052 = 0xc0000000, 0x053 = 0x41fbbcdc
1654 0x054 = 0x5a7ef9db, 0x055 = 0x00100000
1655 Temporary Values
1656 0x056 : Accumulator
1657 0x057 : Condition Register
1658 0x058 : Noise source
1659 0x059 : Noise source
1660 0x05a : IRQ Register
1661 0x05b : TRAM Delay Base Address Count
1662 General Purpose Registers
1663 0x100 - 0x1ff
1664 Tank Memory Data Registers
1665 0x200 - 0x2ff
1666 Tank Memory Address Registers
1667 0x300 - 0x3ff
1668 */
1669
1670 /* Routing - this will be configurable in later version */
1671
1672 /* GPR[0/1] = FX * 4 + SPDIF-in */
1673 emu_addefxop(sc, iMACINT0, GPR(0), EXTIN(EXTIN_SPDIF_CD_L),
1674 FXBUS(FXBUS_PCM_LEFT), C_00000004, &pc);
1675 emu_addefxop(sc, iMACINT0, GPR(1), EXTIN(EXTIN_SPDIF_CD_R),
1676 FXBUS(FXBUS_PCM_RIGHT), C_00000004, &pc);
1677
1678 /* GPR[0/1] += APS-input */
1679 emu_addefxop(sc, iACC3, GPR(0), GPR(0), C_00000000,
1680 sc->APS ? EXTIN(EXTIN_TOSLINK_L) : C_00000000, &pc);
1681 emu_addefxop(sc, iACC3, GPR(1), GPR(1), C_00000000,
1682 sc->APS ? EXTIN(EXTIN_TOSLINK_R) : C_00000000, &pc);
1683
1684 /* FrontOut (AC97) = GPR[0/1] */
1685 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_AC97_L), C_00000000,
1686 C_00000000, GPR(0), &pc);
1687 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_AC97_R), C_00000000,
1688 C_00000001, GPR(1), &pc);
1689
1690 /* GPR[2] = GPR[0] (Left) / 2 + GPR[1] (Right) / 2 -- Central volume */
1691 emu_addefxop(sc, iINTERP, GPR(2), GPR(1), C_40000000, GPR(0), &pc);
1692
1693 #if 0
1694 /* RearOut = (GPR[0/1] * RearVolume) >> 31 */
1695 /* RearVolume = GPR[0x10/0x11] */
1696 emu_addefxop(sc, iMAC0, EXTOUT(EXTOUT_REAR_L), C_00000000,
1697 GPR(16), GPR(0), &pc);
1698 emu_addefxop(sc, iMAC0, EXTOUT(EXTOUT_REAR_R), C_00000000,
1699 GPR(17), GPR(1), &pc);
1700 #else
1701 /* XXX This is just a copy to the channel, since we do not have
1702 * a patch manager, it is useful for have another output enabled.
1703 */
1704
1705 /* Rear[l/r] = GPR[0/1] */
1706 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_REAR_L), C_00000000,
1707 C_00000000, GPR(0), &pc);
1708 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_REAR_R), C_00000000,
1709 C_00000000, GPR(1), &pc);
1710 #endif
1711
1712 /* TOS out[l/r] = GPR[0/1] */
1713 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_TOSLINK_L), C_00000000,
1714 C_00000000, GPR(0), &pc);
1715 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_TOSLINK_R), C_00000000,
1716 C_00000000, GPR(1), &pc);
1717
1718 /* Center and Subwoofer configuration */
1719 /* Analog Center = GPR[0] + GPR[2] */
1720 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_ACENTER), C_00000000,
1721 GPR(0), GPR(2), &pc);
1722 /* Analog Sub = GPR[1] + GPR[2] */
1723 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_ALFE), C_00000000,
1724 GPR(1), GPR(2), &pc);
1725 /* Digital Center = GPR[0] + GPR[2] */
1726 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_AC97_CENTER), C_00000000,
1727 GPR(0), GPR(2), &pc);
1728 /* Digital Sub = GPR[1] + GPR[2] */
1729 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_AC97_LFE), C_00000000,
1730 GPR(1), GPR(2), &pc);
1731
1732 /* Headphones[l/r] = GPR[0/1] */
1733 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_HEADPHONE_L), C_00000000,
1734 C_00000000, GPR(0), &pc);
1735 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_HEADPHONE_R), C_00000000,
1736 C_00000000, GPR(1), &pc);
1737
1738 /* ADC Recording buffer[l/r] = AC97Input[l/r] */
1739 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_ADC_CAP_L), C_00000000,
1740 C_00000000, EXTIN(EXTIN_AC97_L), &pc);
1741 emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_ADC_CAP_R), C_00000000,
1742 C_00000000, EXTIN(EXTIN_AC97_R), &pc);
1743
1744 /* resume normal operations */
1745 emu_wrptr(sc, 0, EMU_DBG, 0);
1746 }
1747
1748 /* Probe and attach the card */
1749 static int
1750 emu_init(struct sc_info *sc)
1751 {
1752 u_int32_t spcs, ch, tmp, i;
1753
1754 if (sc->audigy) {
1755 /* enable additional AC97 slots */
1756 emu_wrptr(sc, 0, EMU_AC97SLOT, EMU_AC97SLOT_CENTER | EMU_AC97SLOT_LFE);
1757 }
1758
1759 /* disable audio and lock cache */
1760 emu_wr(sc, EMU_HCFG,
1761 EMU_HCFG_LOCKSOUNDCACHE | EMU_HCFG_LOCKTANKCACHE_MASK | EMU_HCFG_MUTEBUTTONENABLE,
1762 4);
1763
1764 /* reset recording buffers */
1765 emu_wrptr(sc, 0, EMU_MICBS, EMU_RECBS_BUFSIZE_NONE);
1766 emu_wrptr(sc, 0, EMU_MICBA, 0);
1767 emu_wrptr(sc, 0, EMU_FXBS, EMU_RECBS_BUFSIZE_NONE);
1768 emu_wrptr(sc, 0, EMU_FXBA, 0);
1769 emu_wrptr(sc, 0, EMU_ADCBS, EMU_RECBS_BUFSIZE_NONE);
1770 emu_wrptr(sc, 0, EMU_ADCBA, 0);
1771
1772 /* disable channel interrupt */
1773 emu_wr(sc, EMU_INTE,
1774 EMU_INTE_INTERTIMERENB | EMU_INTE_SAMPLERATER | EMU_INTE_PCIERRENABLE,
1775 4);
1776 emu_wrptr(sc, 0, EMU_CLIEL, 0);
1777 emu_wrptr(sc, 0, EMU_CLIEH, 0);
1778 emu_wrptr(sc, 0, EMU_SOLEL, 0);
1779 emu_wrptr(sc, 0, EMU_SOLEH, 0);
1780
1781 /* wonder what these do... */
1782 if (sc->audigy) {
1783 emu_wrptr(sc, 0, EMU_SPBYPASS, 0xf00);
1784 emu_wrptr(sc, 0, EMU_AC97SLOT, 0x3);
1785 }
1786
1787 /* init envelope engine */
1788 for (ch = 0; ch < NUM_G; ch++) {
1789 emu_wrptr(sc, ch, EMU_CHAN_DCYSUSV, ENV_OFF);
1790 emu_wrptr(sc, ch, EMU_CHAN_IP, 0);
1791 emu_wrptr(sc, ch, EMU_CHAN_VTFT, 0xffff);
1792 emu_wrptr(sc, ch, EMU_CHAN_CVCF, 0xffff);
1793 emu_wrptr(sc, ch, EMU_CHAN_PTRX, 0);
1794 emu_wrptr(sc, ch, EMU_CHAN_CPF, 0);
1795 emu_wrptr(sc, ch, EMU_CHAN_CCR, 0);
1796
1797 emu_wrptr(sc, ch, EMU_CHAN_PSST, 0);
1798 emu_wrptr(sc, ch, EMU_CHAN_DSL, 0x10);
1799 emu_wrptr(sc, ch, EMU_CHAN_CCCA, 0);
1800 emu_wrptr(sc, ch, EMU_CHAN_Z1, 0);
1801 emu_wrptr(sc, ch, EMU_CHAN_Z2, 0);
1802 emu_wrptr(sc, ch, EMU_CHAN_FXRT, 0xd01c0000);
1803
1804 emu_wrptr(sc, ch, EMU_CHAN_ATKHLDM, 0);
1805 emu_wrptr(sc, ch, EMU_CHAN_DCYSUSM, 0);
1806 emu_wrptr(sc, ch, EMU_CHAN_IFATN, 0xffff);
1807 emu_wrptr(sc, ch, EMU_CHAN_PEFE, 0);
1808 emu_wrptr(sc, ch, EMU_CHAN_FMMOD, 0);
1809 emu_wrptr(sc, ch, EMU_CHAN_TREMFRQ, 24); /* 1 Hz */
1810 emu_wrptr(sc, ch, EMU_CHAN_FM2FRQ2, 24); /* 1 Hz */
1811 emu_wrptr(sc, ch, EMU_CHAN_TEMPENV, 0);
1812
1813 /*** these are last so OFF prevents writing ***/
1814 emu_wrptr(sc, ch, EMU_CHAN_LFOVAL2, 0);
1815 emu_wrptr(sc, ch, EMU_CHAN_LFOVAL1, 0);
1816 emu_wrptr(sc, ch, EMU_CHAN_ATKHLDV, 0);
1817 emu_wrptr(sc, ch, EMU_CHAN_ENVVOL, 0);
1818 emu_wrptr(sc, ch, EMU_CHAN_ENVVAL, 0);
1819
1820 if (sc->audigy) {
1821 /* audigy cards need this to initialize correctly */
1822 emu_wrptr(sc, ch, 0x4c, 0);
1823 emu_wrptr(sc, ch, 0x4d, 0);
1824 emu_wrptr(sc, ch, 0x4e, 0);
1825 emu_wrptr(sc, ch, 0x4f, 0);
1826 /* set default routing */
1827 emu_wrptr(sc, ch, EMU_A_CHAN_FXRT1, 0x03020100);
1828 emu_wrptr(sc, ch, EMU_A_CHAN_FXRT2, 0x3f3f3f3f);
1829 emu_wrptr(sc, ch, EMU_A_CHAN_SENDAMOUNTS, 0);
1830 }
1831
1832 sc->voice[ch].vnum = ch;
1833 sc->voice[ch].slave = NULL;
1834 sc->voice[ch].busy = 0;
1835 sc->voice[ch].ismaster = 0;
1836 sc->voice[ch].running = 0;
1837 sc->voice[ch].b16 = 0;
1838 sc->voice[ch].stereo = 0;
1839 sc->voice[ch].speed = 0;
1840 sc->voice[ch].start = 0;
1841 sc->voice[ch].end = 0;
1842 sc->voice[ch].channel = NULL;
1843 }
1844 sc->pnum = sc->rnum = 0;
1845
1846 /*
1847 * Init to 0x02109204 :
1848 * Clock accuracy = 0 (1000ppm)
1849 * Sample Rate = 2 (48kHz)
1850 * Audio Channel = 1 (Left of 2)
1851 * Source Number = 0 (Unspecified)
1852 * Generation Status = 1 (Original for Cat Code 12)
1853 * Cat Code = 12 (Digital Signal Mixer)
1854 * Mode = 0 (Mode 0)
1855 * Emphasis = 0 (None)
1856 * CP = 1 (Copyright unasserted)
1857 * AN = 0 (Audio data)
1858 * P = 0 (Consumer)
1859 */
1860 spcs = EMU_SPCS_CLKACCY_1000PPM | EMU_SPCS_SAMPLERATE_48 |
1861 EMU_SPCS_CHANNELNUM_LEFT | EMU_SPCS_SOURCENUM_UNSPEC |
1862 EMU_SPCS_GENERATIONSTATUS | 0x00001200 | 0x00000000 |
1863 EMU_SPCS_EMPHASIS_NONE | EMU_SPCS_COPYRIGHT;
1864 emu_wrptr(sc, 0, EMU_SPCS0, spcs);
1865 emu_wrptr(sc, 0, EMU_SPCS1, spcs);
1866 emu_wrptr(sc, 0, EMU_SPCS2, spcs);
1867
1868 if (!sc->audigy)
1869 emu_initefx(sc);
1870 else if (sc->audigy2) { /* Audigy 2 */
1871 /* from ALSA initialization code: */
1872
1873 /* Hack for Alice3 to work independent of haP16V driver */
1874 u_int32_t tmp;
1875
1876 /* Setup SRCMulti_I2S SamplingRate */
1877 tmp = emu_rdptr(sc, 0, EMU_A_SPDIF_SAMPLERATE) & 0xfffff1ff;
1878 emu_wrptr(sc, 0, EMU_A_SPDIF_SAMPLERATE, tmp | 0x400);
1879
1880 /* Setup SRCSel (Enable SPDIF, I2S SRCMulti) */
1881 emu_wr(sc, 0x20, 0x00600000, 4);
1882 emu_wr(sc, 0x24, 0x00000014, 4);
1883
1884 /* Setup SRCMulti Input Audio Enable */
1885 emu_wr(sc, 0x20, 0x006e0000, 4);
1886 emu_wr(sc, 0x24, 0xff00ff00, 4);
1887 }
1888
1889 SLIST_INIT(&sc->mem.blocks);
1890 sc->mem.ptb_pages = emu_malloc(sc, EMUMAXPAGES * sizeof(u_int32_t),
1891 &sc->mem.ptb_pages_addr, &sc->mem.ptb_map);
1892 if (sc->mem.ptb_pages == NULL)
1893 return -1;
1894
1895 sc->mem.silent_page = emu_malloc(sc, EMUPAGESIZE,
1896 &sc->mem.silent_page_addr, &sc->mem.silent_map);
1897 if (sc->mem.silent_page == NULL) {
1898 emu_free(sc, sc->mem.ptb_pages, sc->mem.ptb_map);
1899 return -1;
1900 }
1901 /* Clear page with silence & setup all pointers to this page */
1902 bzero(sc->mem.silent_page, EMUPAGESIZE);
1903 tmp = (u_int32_t)(sc->mem.silent_page_addr) << 1;
1904 for (i = 0; i < EMUMAXPAGES; i++)
1905 sc->mem.ptb_pages[i] = tmp | i;
1906
1907 emu_wrptr(sc, 0, EMU_PTB, (sc->mem.ptb_pages_addr));
1908 emu_wrptr(sc, 0, EMU_TCB, 0); /* taken from original driver */
1909 emu_wrptr(sc, 0, EMU_TCBS, 0); /* taken from original driver */
1910
1911 for (ch = 0; ch < NUM_G; ch++) {
1912 emu_wrptr(sc, ch, EMU_CHAN_MAPA, tmp | EMU_CHAN_MAP_PTI_MASK);
1913 emu_wrptr(sc, ch, EMU_CHAN_MAPB, tmp | EMU_CHAN_MAP_PTI_MASK);
1914 }
1915
1916 /* emu_memalloc(sc, EMUPAGESIZE); */
1917 /*
1918 * Hokay, now enable the AUD bit
1919 *
1920 * Audigy
1921 * Enable Audio = 0 (enabled after fx processor initialization)
1922 * Mute Disable Audio = 0
1923 * Joystick = 1
1924 *
1925 * Audigy 2
1926 * Enable Audio = 1
1927 * Mute Disable Audio = 0
1928 * Joystick = 1
1929 * GP S/PDIF AC3 Enable = 1
1930 * CD S/PDIF AC3 Enable = 1
1931 *
1932 * EMU10K1
1933 * Enable Audio = 1
1934 * Mute Disable Audio = 0
1935 * Lock Tank Memory = 1
1936 * Lock Sound Memory = 0
1937 * Auto Mute = 1
1938 */
1939
1940 if (sc->audigy) {
1941 tmp = EMU_HCFG_AUTOMUTE | EMU_HCFG_JOYENABLE;
1942 if (sc->audigy2) /* Audigy 2 */
1943 tmp = EMU_HCFG_AUDIOENABLE | EMU_HCFG_AC3ENABLE_CDSPDIF |
1944 EMU_HCFG_AC3ENABLE_GPSPDIF;
1945 emu_wr(sc, EMU_HCFG, tmp, 4);
1946
1947 audigy_initefx(sc);
1948
1949 /* from ALSA initialization code: */
1950
1951 /* enable audio and disable both audio/digital outputs */
1952 emu_wr(sc, EMU_HCFG, emu_rd(sc, EMU_HCFG, 4) | EMU_HCFG_AUDIOENABLE, 4);
1953 emu_wr(sc, EMU_A_IOCFG, emu_rd(sc, EMU_A_IOCFG, 4) & ~EMU_A_IOCFG_GPOUT_AD,
1954 4);
1955 if (sc->audigy2) { /* Audigy 2 */
1956 /* Unmute Analog.
1957 * Set GPO6 to 1 for Apollo. This has to be done after
1958 * init Alice3 I2SOut beyond 48kHz.
1959 * So, sequence is important.
1960 */
1961 emu_wr(sc, EMU_A_IOCFG,
1962 emu_rd(sc, EMU_A_IOCFG, 4) | EMU_A_IOCFG_GPOUT_A, 4);
1963 }
1964 } else {
1965 /* EMU10K1 initialization code */
1966 tmp = EMU_HCFG_AUDIOENABLE | EMU_HCFG_LOCKTANKCACHE_MASK
1967 | EMU_HCFG_AUTOMUTE;
1968 if (sc->rev >= 6)
1969 tmp |= EMU_HCFG_JOYENABLE;
1970
1971 emu_wr(sc, EMU_HCFG, tmp, 4);
1972
1973 /* TOSLink detection */
1974 sc->tos_link = 0;
1975 tmp = emu_rd(sc, EMU_HCFG, 4);
1976 if (tmp & (EMU_HCFG_GPINPUT0 | EMU_HCFG_GPINPUT1)) {
1977 emu_wr(sc, EMU_HCFG, tmp | EMU_HCFG_GPOUT1, 4);
1978 DELAY(50);
1979 if (tmp != (emu_rd(sc, EMU_HCFG, 4) & ~EMU_HCFG_GPOUT1)) {
1980 sc->tos_link = 1;
1981 emu_wr(sc, EMU_HCFG, tmp, 4);
1982 }
1983 }
1984 }
1985
1986 return 0;
1987 }
1988
1989 static int
1990 emu_uninit(struct sc_info *sc)
1991 {
1992 u_int32_t ch;
1993
1994 emu_wr(sc, EMU_INTE, 0, 4);
1995 for (ch = 0; ch < NUM_G; ch++)
1996 emu_wrptr(sc, ch, EMU_CHAN_DCYSUSV, ENV_OFF);
1997 for (ch = 0; ch < NUM_G; ch++) {
1998 emu_wrptr(sc, ch, EMU_CHAN_VTFT, 0);
1999 emu_wrptr(sc, ch, EMU_CHAN_CVCF, 0);
2000 emu_wrptr(sc, ch, EMU_CHAN_PTRX, 0);
2001 emu_wrptr(sc, ch, EMU_CHAN_CPF, 0);
2002 }
2003
2004 if (sc->audigy) { /* stop fx processor */
2005 emu_wrptr(sc, 0, EMU_A_DBG, EMU_A_DBG_SINGLE_STEP);
2006 }
2007
2008 /* disable audio and lock cache */
2009 emu_wr(sc, EMU_HCFG,
2010 EMU_HCFG_LOCKSOUNDCACHE | EMU_HCFG_LOCKTANKCACHE_MASK | EMU_HCFG_MUTEBUTTONENABLE,
2011 4);
2012
2013 emu_wrptr(sc, 0, EMU_PTB, 0);
2014 /* reset recording buffers */
2015 emu_wrptr(sc, 0, EMU_MICBS, EMU_RECBS_BUFSIZE_NONE);
2016 emu_wrptr(sc, 0, EMU_MICBA, 0);
2017 emu_wrptr(sc, 0, EMU_FXBS, EMU_RECBS_BUFSIZE_NONE);
2018 emu_wrptr(sc, 0, EMU_FXBA, 0);
2019 emu_wrptr(sc, 0, EMU_FXWC, 0);
2020 emu_wrptr(sc, 0, EMU_ADCBS, EMU_RECBS_BUFSIZE_NONE);
2021 emu_wrptr(sc, 0, EMU_ADCBA, 0);
2022 emu_wrptr(sc, 0, EMU_TCB, 0);
2023 emu_wrptr(sc, 0, EMU_TCBS, 0);
2024
2025 /* disable channel interrupt */
2026 emu_wrptr(sc, 0, EMU_CLIEL, 0);
2027 emu_wrptr(sc, 0, EMU_CLIEH, 0);
2028 emu_wrptr(sc, 0, EMU_SOLEL, 0);
2029 emu_wrptr(sc, 0, EMU_SOLEH, 0);
2030
2031 /* init envelope engine */
2032 if (!SLIST_EMPTY(&sc->mem.blocks))
2033 device_printf(sc->dev, "warning: memblock list not empty\n");
2034 emu_free(sc, sc->mem.ptb_pages, sc->mem.ptb_map);
2035 emu_free(sc, sc->mem.silent_page, sc->mem.silent_map);
2036
2037 if(sc->mpu)
2038 mpu401_uninit(sc->mpu);
2039 return 0;
2040 }
2041
2042 static int
2043 emu_pci_probe(device_t dev)
2044 {
2045 char *s = NULL;
2046
2047 switch (pci_get_devid(dev)) {
2048 case EMU10K1_PCI_ID:
2049 s = "Creative EMU10K1";
2050 break;
2051
2052 case EMU10K2_PCI_ID:
2053 if (pci_get_revid(dev) == 0x04)
2054 s = "Creative Audigy 2 (EMU10K2)";
2055 else
2056 s = "Creative Audigy (EMU10K2)";
2057 break;
2058
2059 case EMU10K3_PCI_ID:
2060 s = "Creative Audigy 2 (EMU10K3)";
2061 break;
2062
2063 default:
2064 return ENXIO;
2065 }
2066
2067 device_set_desc(dev, s);
2068 return BUS_PROBE_LOW_PRIORITY;
2069 }
2070
2071 static int
2072 emu_pci_attach(device_t dev)
2073 {
2074 struct ac97_info *codec = NULL;
2075 struct sc_info *sc;
2076 int i, gotmic;
2077 char status[SND_STATUSLEN];
2078
2079 sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
2080 sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10k1 softc");
2081 sc->dev = dev;
2082 sc->type = pci_get_devid(dev);
2083 sc->rev = pci_get_revid(dev);
2084 sc->audigy = sc->type == EMU10K2_PCI_ID || sc->type == EMU10K3_PCI_ID;
2085 sc->audigy2 = (sc->audigy && sc->rev == 0x04);
2086 sc->nchans = sc->audigy ? 8 : 4;
2087 sc->addrmask = sc->audigy ? EMU_A_PTR_ADDR_MASK : EMU_PTR_ADDR_MASK;
2088
2089 pci_enable_busmaster(dev);
2090
2091 i = PCIR_BAR(0);
2092 sc->reg = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &i, RF_ACTIVE);
2093 if (sc->reg == NULL) {
2094 device_printf(dev, "unable to map register space\n");
2095 goto bad;
2096 }
2097 sc->st = rman_get_bustag(sc->reg);
2098 sc->sh = rman_get_bushandle(sc->reg);
2099
2100 sc->bufsz = pcm_getbuffersize(dev, 4096, EMU_DEFAULT_BUFSZ, 65536);
2101
2102 if (bus_dma_tag_create(/*parent*/bus_get_dma_tag(dev), /*alignment*/2,
2103 /*boundary*/0,
2104 /*lowaddr*/(1U << 31) - 1, /* can only access 0-2gb */
2105 /*highaddr*/BUS_SPACE_MAXADDR,
2106 /*filter*/NULL, /*filterarg*/NULL,
2107 /*maxsize*/sc->bufsz, /*nsegments*/1, /*maxsegz*/0x3ffff,
2108 /*flags*/0,
2109 &sc->parent_dmat) != 0) {
2110 device_printf(dev, "unable to create dma tag\n");
2111 goto bad;
2112 }
2113
2114 if (emu_init(sc) == -1) {
2115 device_printf(dev, "unable to initialize the card\n");
2116 goto bad;
2117 }
2118
2119 codec = AC97_CREATE(dev, sc, emu_ac97);
2120 if (codec == NULL) goto bad;
2121 gotmic = (ac97_getcaps(codec) & AC97_CAP_MICCHANNEL) ? 1 : 0;
2122 if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto bad;
2123
2124 emu_midiattach(sc);
2125
2126 i = 0;
2127 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &i,
2128 RF_ACTIVE | RF_SHAREABLE);
2129 if (!sc->irq ||
2130 snd_setup_intr(dev, sc->irq, INTR_MPSAFE, emu_intr, sc, &sc->ih)) {
2131 device_printf(dev, "unable to map interrupt\n");
2132 goto bad;
2133 }
2134
2135 ksnprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld %s",
2136 rman_get_start(sc->reg), rman_get_start(sc->irq),
2137 PCM_KLDSTRING(snd_emu10k1));
2138
2139 if (pcm_register(dev, sc, sc->nchans, gotmic ? 3 : 2)) goto bad;
2140 for (i = 0; i < sc->nchans; i++)
2141 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
2142 for (i = 0; i < (gotmic ? 3 : 2); i++)
2143 pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc);
2144
2145 pcm_setstatus(dev, status);
2146
2147 return 0;
2148
2149 bad:
2150 if (codec) ac97_destroy(codec);
2151 if (sc->reg) bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->reg);
2152 if (sc->ih) bus_teardown_intr(dev, sc->irq, sc->ih);
2153 if (sc->irq) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
2154 if (sc->parent_dmat) bus_dma_tag_destroy(sc->parent_dmat);
2155 if (sc->lock) snd_mtxfree(sc->lock);
2156 kfree(sc, M_DEVBUF);
2157 return ENXIO;
2158 }
2159
2160 static int
2161 emu_pci_detach(device_t dev)
2162 {
2163 int r;
2164 struct sc_info *sc;
2165
2166 r = pcm_unregister(dev);
2167 if (r)
2168 return r;
2169
2170 sc = pcm_getdevinfo(dev);
2171 /* shutdown chip */
2172 emu_uninit(sc);
2173
2174 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->reg);
2175 bus_teardown_intr(dev, sc->irq, sc->ih);
2176 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
2177 bus_dma_tag_destroy(sc->parent_dmat);
2178 snd_mtxfree(sc->lock);
2179 kfree(sc, M_DEVBUF);
2180
2181 return 0;
2182 }
2183
2184 /* add suspend, resume */
2185 static device_method_t emu_methods[] = {
2186 /* Device interface */
2187 DEVMETHOD(device_probe, emu_pci_probe),
2188 DEVMETHOD(device_attach, emu_pci_attach),
2189 DEVMETHOD(device_detach, emu_pci_detach),
2190
2191 DEVMETHOD_END
2192 };
2193
2194 static driver_t emu_driver = {
2195 "pcm",
2196 emu_methods,
2197 PCM_SOFTC_SIZE,
2198 };
2199
2200 DRIVER_MODULE(snd_emu10k1, pci, emu_driver, pcm_devclass, NULL, NULL);
2201 MODULE_DEPEND(snd_emu10k1, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
2202 MODULE_VERSION(snd_emu10k1, 1);
2203 MODULE_DEPEND(snd_emu10k1, midi, 1, 1, 1);
2204
2205 /* dummy driver to silence the joystick device */
2206 static int
2207 emujoy_pci_probe(device_t dev)
2208 {
2209 char *s = NULL;
2210
2211 switch (pci_get_devid(dev)) {
2212 case 0x70021102:
2213 s = "Creative EMU10K1 Joystick";
2214 device_quiet(dev);
2215 break;
2216 case 0x70031102:
2217 s = "Creative EMU10K2 Joystick";
2218 device_quiet(dev);
2219 break;
2220 }
2221
2222 if (s) device_set_desc(dev, s);
2223 return s ? -1000 : ENXIO;
2224 }
2225
2226 static int
2227 emujoy_pci_attach(device_t dev)
2228 {
2229
2230 return 0;
2231 }
2232
2233 static int
2234 emujoy_pci_detach(device_t dev)
2235 {
2236
2237 return 0;
2238 }
2239
2240 static device_method_t emujoy_methods[] = {
2241 DEVMETHOD(device_probe, emujoy_pci_probe),
2242 DEVMETHOD(device_attach, emujoy_pci_attach),
2243 DEVMETHOD(device_detach, emujoy_pci_detach),
2244
2245 DEVMETHOD_END
2246 };
2247
2248 static driver_t emujoy_driver = {
2249 "emujoy",
2250 emujoy_methods,
2251 1 /* no softc */
2252 };
2253
2254 static devclass_t emujoy_devclass;
2255
2256 DRIVER_MODULE(emujoy, pci, emujoy_driver, emujoy_devclass, NULL, NULL);
DragonFly BSD