1 /*-
2 * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
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: head/sys/dev/sound/pci/emu10kx-pcm.c 246128 2013-01-30 18:01:20Z sbz $
28 */
29
30 #include <sys/param.h>
31 #include <sys/types.h>
32 #include <sys/bus.h>
33 #include <sys/rman.h>
34 #include <sys/systm.h>
35 #include <sys/sbuf.h>
36 #include <sys/queue.h>
37 #include <sys/lock.h>
38
39 #ifdef HAVE_KERNEL_OPTION_HEADERS
40 #include "opt_snd.h"
41 #endif
42
43 #include <dev/sound/chip.h>
44 #include <dev/sound/pcm/sound.h>
45 #include <dev/sound/pcm/ac97.h>
46
47 #include "mixer_if.h"
48
49 #include <dev/sound/pci/emuxkireg.h>
50 #include <dev/sound/pci/emu10kx.h>
51
52 struct emu_pcm_pchinfo {
53 int spd;
54 int fmt;
55 unsigned int blksz;
56 int run;
57 struct emu_voice *master;
58 struct emu_voice *slave;
59 struct snd_dbuf *buffer;
60 struct pcm_channel *channel;
61 struct emu_pcm_info *pcm;
62 int timer;
63 };
64
65 struct emu_pcm_rchinfo {
66 int spd;
67 int fmt;
68 unsigned int blksz;
69 int run;
70 uint32_t idxreg;
71 uint32_t basereg;
72 uint32_t sizereg;
73 uint32_t setupreg;
74 uint32_t irqmask;
75 uint32_t iprmask;
76 int ihandle;
77 struct snd_dbuf *buffer;
78 struct pcm_channel *channel;
79 struct emu_pcm_info *pcm;
80 int timer;
81 };
82
83 /* XXX Hardware playback channels */
84 #define MAX_CHANNELS 4
85
86 #if MAX_CHANNELS > 13
87 #error Too many hardware channels defined. 13 is the maximum
88 #endif
89
90 struct emu_pcm_info {
91 struct lock *lock;
92 device_t dev; /* device information */
93 struct emu_sc_info *card;
94 struct emu_pcm_pchinfo pch[MAX_CHANNELS]; /* hardware channels */
95 int pnum; /* next free channel number */
96 struct emu_pcm_rchinfo rch_adc;
97 struct emu_pcm_rchinfo rch_efx;
98 struct emu_route rt;
99 struct emu_route rt_mono;
100 int route;
101 int ihandle; /* interrupt handler */
102 unsigned int bufsz;
103 int is_emu10k1;
104 struct ac97_info *codec;
105 uint32_t ac97_state[0x7F];
106 kobj_class_t ac97_mixerclass;
107 uint32_t ac97_recdevs;
108 uint32_t ac97_playdevs;
109 struct snd_mixer *sm;
110 int mch_disabled;
111 unsigned int emu10k1_volcache[2][2];
112 };
113
114
115 static uint32_t emu_rfmt_adc[] = {
116 SND_FORMAT(AFMT_S16_LE, 1, 0),
117 SND_FORMAT(AFMT_S16_LE, 2, 0),
118 0
119 };
120 static struct pcmchan_caps emu_reccaps_adc = {
121 8000, 48000, emu_rfmt_adc, 0
122 };
123
124 static uint32_t emu_rfmt_efx[] = {
125 SND_FORMAT(AFMT_S16_LE, 1, 0),
126 0
127 };
128
129 static struct pcmchan_caps emu_reccaps_efx_live = {
130 48000*32, 48000*32, emu_rfmt_efx, 0
131 };
132
133 static struct pcmchan_caps emu_reccaps_efx_audigy = {
134 48000*64, 48000*64, emu_rfmt_efx, 0
135 };
136
137 static int emu_rates_live[] = {
138 48000*32
139 };
140
141 static int emu_rates_audigy[] = {
142 48000*64
143 };
144
145 static uint32_t emu_pfmt[] = {
146 SND_FORMAT(AFMT_U8, 1, 0),
147 SND_FORMAT(AFMT_U8, 2, 0),
148 SND_FORMAT(AFMT_S16_LE, 1, 0),
149 SND_FORMAT(AFMT_S16_LE, 2, 0),
150 0
151 };
152 static uint32_t emu_pfmt_mono[] = {
153 SND_FORMAT(AFMT_U8, 1, 0),
154 SND_FORMAT(AFMT_S16_LE, 1, 0),
155 0
156 };
157
158 static struct pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0};
159 static struct pcmchan_caps emu_playcaps_mono = {4000, 48000, emu_pfmt_mono, 0};
160
161 static int emu10k1_adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000};
162 /* audigy supports 12kHz. */
163 static int emu10k2_adcspeed[9] = {48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000};
164
165 static uint32_t emu_pcm_intr(void *pcm, uint32_t stat);
166
167 static const struct emu_dspmix_props_k1 {
168 uint8_t present;
169 uint8_t recdev;
170 int8_t input;
171 } dspmix_k1 [SOUND_MIXER_NRDEVICES] = {
172 /* no mixer device for ac97 */ /* in0 AC97 */
173 [SOUND_MIXER_DIGITAL1] = {1, 1, 1}, /* in1 CD SPDIF */
174 /* not connected */ /* in2 (zoom) */
175 [SOUND_MIXER_DIGITAL2] = {1, 1, 3}, /* in3 toslink */
176 [SOUND_MIXER_LINE2] = {1, 1, 4}, /* in4 Line-In2 */
177 [SOUND_MIXER_DIGITAL3] = {1, 1, 5}, /* in5 on-card SPDIF */
178 [SOUND_MIXER_LINE3] = {1, 1, 6}, /* in6 AUX2 */
179 /* not connected */ /* in7 */
180 };
181 static const struct emu_dspmix_props_k2 {
182 uint8_t present;
183 uint8_t recdev;
184 int8_t input;
185 } dspmix_k2 [SOUND_MIXER_NRDEVICES] = {
186 [SOUND_MIXER_VOLUME] = {1, 0, (-1)},
187 [SOUND_MIXER_PCM] = {1, 0, (-1)},
188
189 /* no mixer device */ /* in0 AC97 */
190 [SOUND_MIXER_DIGITAL1] = {1, 1, 1}, /* in1 CD SPDIF */
191 [SOUND_MIXER_DIGITAL2] = {1, 1, 2}, /* in2 COAX SPDIF */
192 /* not connected */ /* in3 */
193 [SOUND_MIXER_LINE2] = {1, 1, 4}, /* in4 Line-In2 */
194 [SOUND_MIXER_DIGITAL3] = {1, 1, 5}, /* in5 on-card SPDIF */
195 [SOUND_MIXER_LINE3] = {1, 1, 6}, /* in6 AUX2 */
196 /* not connected */ /* in7 */
197 };
198
199 static int
emu_dspmixer_init(struct snd_mixer * m)200 emu_dspmixer_init(struct snd_mixer *m)
201 {
202 struct emu_pcm_info *sc;
203 int i;
204 int p, r;
205
206 p = 0;
207 r = 0;
208
209 sc = mix_getdevinfo(m);
210
211 if (sc->route == RT_FRONT) {
212 /* create submixer for AC97 codec */
213 if ((sc->ac97_mixerclass != NULL) && (sc->codec != NULL)) {
214 sc->sm = mixer_create(sc->dev, sc->ac97_mixerclass, sc->codec, "ac97");
215 if (sc->sm != NULL) {
216 p = mix_getdevs(sc->sm);
217 r = mix_getrecdevs(sc->sm);
218 }
219 }
220
221 sc->ac97_playdevs = p;
222 sc->ac97_recdevs = r;
223 }
224
225 /* This two are always here */
226 p |= (1 << SOUND_MIXER_PCM);
227 p |= (1 << SOUND_MIXER_VOLUME);
228
229 if (sc->route == RT_FRONT) {
230 if (sc->is_emu10k1) {
231 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
232 if (dspmix_k1[i].present)
233 p |= (1 << i);
234 if (dspmix_k1[i].recdev)
235 r |= (1 << i);
236 }
237 } else {
238 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
239 if (dspmix_k2[i].present)
240 p |= (1 << i);
241 if (dspmix_k2[i].recdev)
242 r |= (1 << i);
243 }
244 }
245 }
246
247 mix_setdevs(m, p);
248 mix_setrecdevs(m, r);
249
250 return (0);
251 }
252
253 static int
emu_dspmixer_uninit(struct snd_mixer * m)254 emu_dspmixer_uninit(struct snd_mixer *m)
255 {
256 struct emu_pcm_info *sc;
257 int err = 0;
258
259 /* drop submixer for AC97 codec */
260 sc = mix_getdevinfo(m);
261 if (sc->sm != NULL) {
262 err = mixer_delete(sc->sm);
263 if (err)
264 return (err);
265 sc->sm = NULL;
266 }
267 return (0);
268 }
269
270 static int
emu_dspmixer_set(struct snd_mixer * m,unsigned dev,unsigned left,unsigned right)271 emu_dspmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
272 {
273 struct emu_pcm_info *sc;
274
275 sc = mix_getdevinfo(m);
276
277 switch (dev) {
278 case SOUND_MIXER_VOLUME:
279 switch (sc->route) {
280 case RT_FRONT:
281 if (sc->sm != NULL)
282 mix_set(sc->sm, dev, left, right);
283 if (sc->mch_disabled) {
284 /* In emu10k1 case PCM volume does not affect
285 sound routed to rear & center/sub (it is connected
286 to AC97 codec). Calculate it manually. */
287 /* This really should belong to emu10kx.c */
288 if (sc->is_emu10k1) {
289 sc->emu10k1_volcache[0][0] = left;
290 left = left * sc->emu10k1_volcache[1][0] / 100;
291 sc->emu10k1_volcache[0][1] = right;
292 right = right * sc->emu10k1_volcache[1][1] / 100;
293 }
294
295 emumix_set_volume(sc->card, M_MASTER_REAR_L, left);
296 emumix_set_volume(sc->card, M_MASTER_REAR_R, right);
297 if (!sc->is_emu10k1) {
298 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2);
299 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2);
300 /* XXX side */
301 }
302 } /* mch disabled */
303 break;
304 case RT_REAR:
305 emumix_set_volume(sc->card, M_MASTER_REAR_L, left);
306 emumix_set_volume(sc->card, M_MASTER_REAR_R, right);
307 break;
308 case RT_CENTER:
309 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2);
310 break;
311 case RT_SUB:
312 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2);
313 break;
314 }
315 break;
316 case SOUND_MIXER_PCM:
317 switch (sc->route) {
318 case RT_FRONT:
319 if (sc->sm != NULL)
320 mix_set(sc->sm, dev, left, right);
321 if (sc->mch_disabled) {
322 /* See SOUND_MIXER_VOLUME case */
323 if (sc->is_emu10k1) {
324 sc->emu10k1_volcache[1][0] = left;
325 left = left * sc->emu10k1_volcache[0][0] / 100;
326 sc->emu10k1_volcache[1][1] = right;
327 right = right * sc->emu10k1_volcache[0][1] / 100;
328 }
329 emumix_set_volume(sc->card, M_MASTER_REAR_L, left);
330 emumix_set_volume(sc->card, M_MASTER_REAR_R, right);
331
332 if (!sc->is_emu10k1) {
333 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2);
334 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2);
335 /* XXX side */
336 }
337 } /* mch_disabled */
338 break;
339 case RT_REAR:
340 emumix_set_volume(sc->card, M_FX2_REAR_L, left);
341 emumix_set_volume(sc->card, M_FX3_REAR_R, right);
342 break;
343 case RT_CENTER:
344 emumix_set_volume(sc->card, M_FX4_CENTER, (left+right)/2);
345 break;
346 case RT_SUB:
347 emumix_set_volume(sc->card, M_FX5_SUBWOOFER, (left+right)/2);
348 break;
349 }
350 break;
351 case SOUND_MIXER_DIGITAL1: /* CD SPDIF, in1 */
352 emumix_set_volume(sc->card, M_IN1_FRONT_L, left);
353 emumix_set_volume(sc->card, M_IN1_FRONT_R, right);
354 break;
355 case SOUND_MIXER_DIGITAL2:
356 if (sc->is_emu10k1) {
357 /* TOSLink, in3 */
358 emumix_set_volume(sc->card, M_IN3_FRONT_L, left);
359 emumix_set_volume(sc->card, M_IN3_FRONT_R, right);
360 } else {
361 /* COAX SPDIF, in2 */
362 emumix_set_volume(sc->card, M_IN2_FRONT_L, left);
363 emumix_set_volume(sc->card, M_IN2_FRONT_R, right);
364 }
365 break;
366 case SOUND_MIXER_LINE2: /* Line-In2, in4 */
367 emumix_set_volume(sc->card, M_IN4_FRONT_L, left);
368 emumix_set_volume(sc->card, M_IN4_FRONT_R, right);
369 break;
370 case SOUND_MIXER_DIGITAL3: /* on-card SPDIF, in5 */
371 emumix_set_volume(sc->card, M_IN5_FRONT_L, left);
372 emumix_set_volume(sc->card, M_IN5_FRONT_R, right);
373 break;
374 case SOUND_MIXER_LINE3: /* AUX2, in6 */
375 emumix_set_volume(sc->card, M_IN6_FRONT_L, left);
376 emumix_set_volume(sc->card, M_IN6_FRONT_R, right);
377 break;
378 default:
379 if (sc->sm != NULL) {
380 /* XXX emumix_set_volume is not required here */
381 emumix_set_volume(sc->card, M_IN0_FRONT_L, 100);
382 emumix_set_volume(sc->card, M_IN0_FRONT_R, 100);
383 mix_set(sc->sm, dev, left, right);
384 } else
385 device_printf(sc->dev, "mixer error: unknown device %d\n", dev);
386 }
387 return (0);
388 }
389
390 static u_int32_t
emu_dspmixer_setrecsrc(struct snd_mixer * m,u_int32_t src)391 emu_dspmixer_setrecsrc(struct snd_mixer *m, u_int32_t src)
392 {
393 struct emu_pcm_info *sc;
394 int i;
395 u_int32_t recmask;
396 int input[8];
397
398 sc = mix_getdevinfo(m);
399 recmask = 0;
400 for (i=0; i < 8; i++)
401 input[i]=0;
402
403 if (sc->sm != NULL)
404 if ((src & sc->ac97_recdevs) !=0)
405 if (mix_setrecsrc(sc->sm, src & sc->ac97_recdevs) == 0) {
406 recmask |= (src & sc->ac97_recdevs);
407 /* Recording from AC97 codec.
408 Enable AC97 route to rec on DSP */
409 input[0] = 1;
410 }
411 if (sc->is_emu10k1) {
412 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
413 if (dspmix_k1[i].recdev)
414 if ((src & (1 << i)) == ((uint32_t)1 << i)) {
415 recmask |= (1 << i);
416 /* enable device i */
417 input[dspmix_k1[i].input] = 1;
418 }
419 }
420 } else {
421 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
422 if (dspmix_k2[i].recdev)
423 if ((src & (1 << i)) == ((uint32_t)1 << i)) {
424 recmask |= (1 << i);
425 /* enable device i */
426 input[dspmix_k2[i].input] = 1;
427 }
428 }
429 }
430 emumix_set_volume(sc->card, M_IN0_REC_L, input[0] == 1 ? 100 : 0);
431 emumix_set_volume(sc->card, M_IN0_REC_R, input[0] == 1 ? 100 : 0);
432
433 emumix_set_volume(sc->card, M_IN1_REC_L, input[1] == 1 ? 100 : 0);
434 emumix_set_volume(sc->card, M_IN1_REC_R, input[1] == 1 ? 100 : 0);
435
436 if (!sc->is_emu10k1) {
437 emumix_set_volume(sc->card, M_IN2_REC_L, input[2] == 1 ? 100 : 0);
438 emumix_set_volume(sc->card, M_IN2_REC_R, input[2] == 1 ? 100 : 0);
439 }
440
441 if (sc->is_emu10k1) {
442 emumix_set_volume(sc->card, M_IN3_REC_L, input[3] == 1 ? 100 : 0);
443 emumix_set_volume(sc->card, M_IN3_REC_R, input[3] == 1 ? 100 : 0);
444 }
445
446 emumix_set_volume(sc->card, M_IN4_REC_L, input[4] == 1 ? 100 : 0);
447 emumix_set_volume(sc->card, M_IN4_REC_R, input[4] == 1 ? 100 : 0);
448
449 emumix_set_volume(sc->card, M_IN5_REC_L, input[5] == 1 ? 100 : 0);
450 emumix_set_volume(sc->card, M_IN5_REC_R, input[5] == 1 ? 100 : 0);
451
452 emumix_set_volume(sc->card, M_IN6_REC_L, input[6] == 1 ? 100 : 0);
453 emumix_set_volume(sc->card, M_IN6_REC_R, input[6] == 1 ? 100 : 0);
454
455 /* XXX check for K1/k2 differences? */
456 if ((src & (1 << SOUND_MIXER_PCM)) == (1 << SOUND_MIXER_PCM)) {
457 emumix_set_volume(sc->card, M_FX0_REC_L, emumix_get_volume(sc->card, M_FX0_FRONT_L));
458 emumix_set_volume(sc->card, M_FX1_REC_R, emumix_get_volume(sc->card, M_FX1_FRONT_R));
459 } else {
460 emumix_set_volume(sc->card, M_FX0_REC_L, 0);
461 emumix_set_volume(sc->card, M_FX1_REC_R, 0);
462 }
463
464 return (recmask);
465 }
466
467 static kobj_method_t emudspmixer_methods[] = {
468 KOBJMETHOD(mixer_init, emu_dspmixer_init),
469 KOBJMETHOD(mixer_uninit, emu_dspmixer_uninit),
470 KOBJMETHOD(mixer_set, emu_dspmixer_set),
471 KOBJMETHOD(mixer_setrecsrc, emu_dspmixer_setrecsrc),
472 KOBJMETHOD_END
473 };
474 MIXER_DECLARE(emudspmixer);
475
476 static int
emu_efxmixer_init(struct snd_mixer * m)477 emu_efxmixer_init(struct snd_mixer *m)
478 {
479 mix_setdevs(m, SOUND_MASK_VOLUME);
480 mix_setrecdevs(m, SOUND_MASK_MONITOR);
481 return (0);
482 }
483
484 static int
emu_efxmixer_set(struct snd_mixer * m,unsigned dev,unsigned left,unsigned right)485 emu_efxmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
486 {
487 if (left + right == 200) return (0);
488 return (0);
489 }
490
491 static u_int32_t
emu_efxmixer_setrecsrc(struct snd_mixer * m __unused,u_int32_t src __unused)492 emu_efxmixer_setrecsrc(struct snd_mixer *m __unused, u_int32_t src __unused)
493 {
494 return (SOUND_MASK_MONITOR);
495 }
496
497 static kobj_method_t emuefxmixer_methods[] = {
498 KOBJMETHOD(mixer_init, emu_efxmixer_init),
499 KOBJMETHOD(mixer_set, emu_efxmixer_set),
500 KOBJMETHOD(mixer_setrecsrc, emu_efxmixer_setrecsrc),
501 KOBJMETHOD_END
502 };
503 MIXER_DECLARE(emuefxmixer);
504
505 /*
506 * AC97 emulation code for Audigy and later cards.
507 * Some parts of AC97 codec are not used by hardware, but can be used
508 * to change some DSP controls via AC97 mixer interface. This includes:
509 * - master volume controls MASTER_FRONT_[R|L]
510 * - pcm volume controls FX[0|1]_FRONT_[R|L]
511 * - rec volume controls MASTER_REC_[R|L]
512 * We do it because we need to put it under user control....
513 * We also keep some parts of AC97 disabled to get better sound quality
514 */
515
516 #define AC97LEFT(x) ((x & 0x7F00)>>8)
517 #define AC97RIGHT(x) (x & 0x007F)
518 #define AC97MUTE(x) ((x & 0x8000)>>15)
519 #define BIT4_TO100(x) (100-(x)*100/(0x0f))
520 #define BIT6_TO100(x) (100-(x)*100/(0x3f))
521 #define BIT4_TO255(x) (255-(x)*255/(0x0f))
522 #define BIT6_TO255(x) (255-(x)*255/(0x3f))
523 #define V100_TOBIT6(x) (0x3f*(100-x)/100)
524 #define V100_TOBIT4(x) (0x0f*(100-x)/100)
525 #define AC97ENCODE(x_muted, x_left, x_right) (((x_muted & 1)<<15) | ((x_left & 0x3f)<<8) | (x_right & 0x3f))
526
527 static int
emu_ac97_read_emulation(struct emu_pcm_info * sc,int regno)528 emu_ac97_read_emulation(struct emu_pcm_info *sc, int regno)
529 {
530 int use_ac97;
531 int emulated;
532 int tmp;
533
534 use_ac97 = 1;
535 emulated = 0;
536
537 switch (regno) {
538 case AC97_MIX_MASTER:
539 emulated = sc->ac97_state[AC97_MIX_MASTER];
540 use_ac97 = 0;
541 break;
542 case AC97_MIX_PCM:
543 emulated = sc->ac97_state[AC97_MIX_PCM];
544 use_ac97 = 0;
545 break;
546 case AC97_REG_RECSEL:
547 emulated = 0x0505;
548 use_ac97 = 0;
549 break;
550 case AC97_MIX_RGAIN:
551 emulated = sc->ac97_state[AC97_MIX_RGAIN];
552 use_ac97 = 0;
553 break;
554 }
555
556 emu_wr(sc->card, EMU_AC97ADDR, regno, 1);
557 tmp = emu_rd(sc->card, EMU_AC97DATA, 2);
558
559 if (use_ac97)
560 emulated = tmp;
561
562 return (emulated);
563 }
564
565 static void
emu_ac97_write_emulation(struct emu_pcm_info * sc,int regno,uint32_t data)566 emu_ac97_write_emulation(struct emu_pcm_info *sc, int regno, uint32_t data)
567 {
568 int write_ac97;
569 int left, right;
570 uint32_t emu_left, emu_right;
571 int is_mute;
572
573 write_ac97 = 1;
574
575 left = AC97LEFT(data);
576 emu_left = BIT6_TO100(left); /* We show us as 6-bit AC97 mixer */
577 right = AC97RIGHT(data);
578 emu_right = BIT6_TO100(right);
579 is_mute = AC97MUTE(data);
580 if (is_mute)
581 emu_left = emu_right = 0;
582
583 switch (regno) {
584 /* TODO: reset emulator on AC97_RESET */
585 case AC97_MIX_MASTER:
586 emumix_set_volume(sc->card, M_MASTER_FRONT_L, emu_left);
587 emumix_set_volume(sc->card, M_MASTER_FRONT_R, emu_right);
588 sc->ac97_state[AC97_MIX_MASTER] = data & (0x8000 | 0x3f3f);
589 data = 0x8000; /* Mute AC97 main out */
590 break;
591 case AC97_MIX_PCM: /* PCM OUT VOL */
592 emumix_set_volume(sc->card, M_FX0_FRONT_L, emu_left);
593 emumix_set_volume(sc->card, M_FX1_FRONT_R, emu_right);
594 sc->ac97_state[AC97_MIX_PCM] = data & (0x8000 | 0x3f3f);
595 data = 0x8000; /* Mute AC97 PCM out */
596 break;
597 case AC97_REG_RECSEL:
598 /*
599 * PCM recording source is set to "stereo mix" (labeled "vol"
600 * in mixer). There is no 'playback' from AC97 codec -
601 * if you want to hear anything from AC97 you have to _record_
602 * it. Keep things simple and record "stereo mix".
603 */
604 data = 0x0505;
605 break;
606 case AC97_MIX_RGAIN: /* RECORD GAIN */
607 emu_left = BIT4_TO100(left); /* rgain is 4-bit */
608 emu_right = BIT4_TO100(right);
609 emumix_set_volume(sc->card, M_MASTER_REC_L, 100-emu_left);
610 emumix_set_volume(sc->card, M_MASTER_REC_R, 100-emu_right);
611 /*
612 * Record gain on AC97 should stay zero to get AC97 sound on
613 * AC97_[RL] connectors on EMU10K2 chip. AC97 on Audigy is not
614 * directly connected to any output, only to EMU10K2 chip Use
615 * this control to set AC97 mix volume inside EMU10K2 chip
616 */
617 sc->ac97_state[AC97_MIX_RGAIN] = data & (0x8000 | 0x0f0f);
618 data = 0x0000;
619 break;
620 }
621 if (write_ac97) {
622 emu_wr(sc->card, EMU_AC97ADDR, regno, 1);
623 emu_wr(sc->card, EMU_AC97DATA, data, 2);
624 }
625 }
626
627 static int
emu_erdcd(kobj_t obj __unused,void * devinfo,int regno)628 emu_erdcd(kobj_t obj __unused, void *devinfo, int regno)
629 {
630 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
631
632 return (emu_ac97_read_emulation(sc, regno));
633 }
634
635 static int
emu_ewrcd(kobj_t obj __unused,void * devinfo,int regno,uint32_t data)636 emu_ewrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data)
637 {
638 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
639
640 emu_ac97_write_emulation(sc, regno, data);
641 return (0);
642 }
643
644 static kobj_method_t emu_eac97_methods[] = {
645 KOBJMETHOD(ac97_read, emu_erdcd),
646 KOBJMETHOD(ac97_write, emu_ewrcd),
647 KOBJMETHOD_END
648 };
649 AC97_DECLARE(emu_eac97);
650
651 /* real ac97 codec */
652 static int
emu_rdcd(kobj_t obj __unused,void * devinfo,int regno)653 emu_rdcd(kobj_t obj __unused, void *devinfo, int regno)
654 {
655 int rd;
656 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
657
658 KASSERT(sc->card != NULL, ("emu_rdcd: no soundcard"));
659 emu_wr(sc->card, EMU_AC97ADDR, regno, 1);
660 rd = emu_rd(sc->card, EMU_AC97DATA, 2);
661 return (rd);
662 }
663
664 static int
emu_wrcd(kobj_t obj __unused,void * devinfo,int regno,uint32_t data)665 emu_wrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data)
666 {
667 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
668
669 KASSERT(sc->card != NULL, ("emu_wrcd: no soundcard"));
670 emu_wr(sc->card, EMU_AC97ADDR, regno, 1);
671 emu_wr(sc->card, EMU_AC97DATA, data, 2);
672 return (0);
673 }
674
675 static kobj_method_t emu_ac97_methods[] = {
676 KOBJMETHOD(ac97_read, emu_rdcd),
677 KOBJMETHOD(ac97_write, emu_wrcd),
678 KOBJMETHOD_END
679 };
680 AC97_DECLARE(emu_ac97);
681
682
683 static int
emu_k1_recval(int speed)684 emu_k1_recval(int speed)
685 {
686 int val;
687
688 val = 0;
689 while ((val < 7) && (speed < emu10k1_adcspeed[val]))
690 val++;
691 return (val);
692 }
693
694 static int
emu_k2_recval(int speed)695 emu_k2_recval(int speed)
696 {
697 int val;
698
699 val = 0;
700 while ((val < 8) && (speed < emu10k2_adcspeed[val]))
701 val++;
702 return (val);
703 }
704
705 static void *
emupchan_init(kobj_t obj __unused,void * devinfo,struct snd_dbuf * b,struct pcm_channel * c,int dir __unused)706 emupchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
707 {
708 struct emu_pcm_info *sc = devinfo;
709 struct emu_pcm_pchinfo *ch;
710 void *r;
711
712 KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction"));
713 KASSERT(sc->card != NULL, ("empchan_init: no soundcard"));
714
715
716 if (sc->pnum >= MAX_CHANNELS)
717 return (NULL);
718 ch = &(sc->pch[sc->pnum++]);
719 ch->buffer = b;
720 ch->pcm = sc;
721 ch->channel = c;
722 ch->blksz = sc->bufsz;
723 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
724 ch->spd = 8000;
725 ch->master = emu_valloc(sc->card);
726 /*
727 * XXX we have to allocate slave even for mono channel until we
728 * fix emu_vfree to handle this case.
729 */
730 ch->slave = emu_valloc(sc->card);
731 ch->timer = emu_timer_create(sc->card);
732 r = (emu_vinit(sc->card, ch->master, ch->slave, EMU_PLAY_BUFSZ, ch->buffer)) ? NULL : ch;
733 return (r);
734 }
735
736 static int
emupchan_free(kobj_t obj __unused,void * c_devinfo)737 emupchan_free(kobj_t obj __unused, void *c_devinfo)
738 {
739 struct emu_pcm_pchinfo *ch = c_devinfo;
740 struct emu_pcm_info *sc = ch->pcm;
741
742 emu_timer_clear(sc->card, ch->timer);
743 if (ch->slave != NULL)
744 emu_vfree(sc->card, ch->slave);
745 emu_vfree(sc->card, ch->master);
746 return (0);
747 }
748
749 static int
emupchan_setformat(kobj_t obj __unused,void * c_devinfo,uint32_t format)750 emupchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format)
751 {
752 struct emu_pcm_pchinfo *ch = c_devinfo;
753
754 ch->fmt = format;
755 return (0);
756 }
757
758 static uint32_t
emupchan_setspeed(kobj_t obj __unused,void * c_devinfo,uint32_t speed)759 emupchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
760 {
761 struct emu_pcm_pchinfo *ch = c_devinfo;
762
763 ch->spd = speed;
764 return (ch->spd);
765 }
766
767 static uint32_t
emupchan_setblocksize(kobj_t obj __unused,void * c_devinfo,uint32_t blocksize)768 emupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
769 {
770 struct emu_pcm_pchinfo *ch = c_devinfo;
771 struct emu_pcm_info *sc = ch->pcm;
772
773 if (blocksize > ch->pcm->bufsz)
774 blocksize = ch->pcm->bufsz;
775 snd_mtxlock(sc->lock);
776 ch->blksz = blocksize;
777 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
778 snd_mtxunlock(sc->lock);
779 return (ch->blksz);
780 }
781
782 static int
emupchan_trigger(kobj_t obj __unused,void * c_devinfo,int go)783 emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
784 {
785 struct emu_pcm_pchinfo *ch = c_devinfo;
786 struct emu_pcm_info *sc = ch->pcm;
787
788 if (!PCMTRIG_COMMON(go))
789 return (0);
790
791 snd_mtxlock(sc->lock); /* XXX can we trigger on parallel threads ? */
792 if (go == PCMTRIG_START) {
793 emu_vsetup(ch->master, ch->fmt, ch->spd);
794 if (AFMT_CHANNEL(ch->fmt) > 1)
795 emu_vroute(sc->card, &(sc->rt), ch->master);
796 else
797 emu_vroute(sc->card, &(sc->rt_mono), ch->master);
798 emu_vwrite(sc->card, ch->master);
799 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
800 emu_timer_enable(sc->card, ch->timer, 1);
801 }
802 /* PCM interrupt handler will handle PCMTRIG_STOP event */
803 ch->run = (go == PCMTRIG_START) ? 1 : 0;
804 emu_vtrigger(sc->card, ch->master, ch->run);
805 snd_mtxunlock(sc->lock);
806 return (0);
807 }
808
809 static uint32_t
emupchan_getptr(kobj_t obj __unused,void * c_devinfo)810 emupchan_getptr(kobj_t obj __unused, void *c_devinfo)
811 {
812 struct emu_pcm_pchinfo *ch = c_devinfo;
813 struct emu_pcm_info *sc = ch->pcm;
814 int r;
815
816 r = emu_vpos(sc->card, ch->master);
817
818 return (r);
819 }
820
821 static struct pcmchan_caps *
emupchan_getcaps(kobj_t obj __unused,void * c_devinfo __unused)822 emupchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused)
823 {
824 struct emu_pcm_pchinfo *ch = c_devinfo;
825 struct emu_pcm_info *sc = ch->pcm;
826
827 switch (sc->route) {
828 case RT_FRONT:
829 /* FALLTHROUGH */
830 case RT_REAR:
831 /* FALLTHROUGH */
832 case RT_SIDE:
833 return (&emu_playcaps);
834 break;
835 case RT_CENTER:
836 /* FALLTHROUGH */
837 case RT_SUB:
838 return (&emu_playcaps_mono);
839 break;
840 }
841 return (NULL);
842 }
843
844 static kobj_method_t emupchan_methods[] = {
845 KOBJMETHOD(channel_init, emupchan_init),
846 KOBJMETHOD(channel_free, emupchan_free),
847 KOBJMETHOD(channel_setformat, emupchan_setformat),
848 KOBJMETHOD(channel_setspeed, emupchan_setspeed),
849 KOBJMETHOD(channel_setblocksize, emupchan_setblocksize),
850 KOBJMETHOD(channel_trigger, emupchan_trigger),
851 KOBJMETHOD(channel_getptr, emupchan_getptr),
852 KOBJMETHOD(channel_getcaps, emupchan_getcaps),
853 KOBJMETHOD_END
854 };
855 CHANNEL_DECLARE(emupchan);
856
857 static void *
emurchan_init(kobj_t obj __unused,void * devinfo,struct snd_dbuf * b,struct pcm_channel * c,int dir __unused)858 emurchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
859 {
860 struct emu_pcm_info *sc = devinfo;
861 struct emu_pcm_rchinfo *ch;
862
863 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
864 ch = &sc->rch_adc;
865 ch->buffer = b;
866 ch->pcm = sc;
867 ch->channel = c;
868 ch->blksz = sc->bufsz / 2; /* We rise interrupt for half-full buffer */
869 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
870 ch->spd = 8000;
871 ch->idxreg = sc->is_emu10k1 ? EMU_ADCIDX : EMU_A_ADCIDX;
872 ch->basereg = EMU_ADCBA;
873 ch->sizereg = EMU_ADCBS;
874 ch->setupreg = EMU_ADCCR;
875 ch->irqmask = EMU_INTE_ADCBUFENABLE;
876 ch->iprmask = EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL;
877
878 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
879 return (NULL);
880 else {
881 ch->timer = emu_timer_create(sc->card);
882 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
883 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
884 return (ch);
885 }
886 }
887
888 static int
emurchan_free(kobj_t obj __unused,void * c_devinfo)889 emurchan_free(kobj_t obj __unused, void *c_devinfo)
890 {
891 struct emu_pcm_rchinfo *ch = c_devinfo;
892 struct emu_pcm_info *sc = ch->pcm;
893
894 emu_timer_clear(sc->card, ch->timer);
895 return (0);
896 }
897
898 static int
emurchan_setformat(kobj_t obj __unused,void * c_devinfo,uint32_t format)899 emurchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format)
900 {
901 struct emu_pcm_rchinfo *ch = c_devinfo;
902
903 ch->fmt = format;
904 return (0);
905 }
906
907 static uint32_t
emurchan_setspeed(kobj_t obj __unused,void * c_devinfo,uint32_t speed)908 emurchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
909 {
910 struct emu_pcm_rchinfo *ch = c_devinfo;
911
912 if (ch->pcm->is_emu10k1) {
913 speed = emu10k1_adcspeed[emu_k1_recval(speed)];
914 } else {
915 speed = emu10k2_adcspeed[emu_k2_recval(speed)];
916 }
917 ch->spd = speed;
918 return (ch->spd);
919 }
920
921 static uint32_t
emurchan_setblocksize(kobj_t obj __unused,void * c_devinfo,uint32_t blocksize)922 emurchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
923 {
924 struct emu_pcm_rchinfo *ch = c_devinfo;
925 struct emu_pcm_info *sc = ch->pcm;
926
927 ch->blksz = blocksize;
928 /*
929 * If blocksize is less than half of buffer size we will not get
930 * BUFHALFFULL interrupt in time and channel will need to generate
931 * (and use) timer interrupts. Otherwise channel will be marked dead.
932 */
933 if (ch->blksz < (ch->pcm->bufsz / 2)) {
934 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
935 emu_timer_enable(sc->card, ch->timer, 1);
936 } else {
937 emu_timer_enable(sc->card, ch->timer, 0);
938 }
939 return (ch->blksz);
940 }
941
942 static int
emurchan_trigger(kobj_t obj __unused,void * c_devinfo,int go)943 emurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
944 {
945 struct emu_pcm_rchinfo *ch = c_devinfo;
946 struct emu_pcm_info *sc = ch->pcm;
947 uint32_t val, sz;
948
949 if (!PCMTRIG_COMMON(go))
950 return (0);
951
952 switch (sc->bufsz) {
953 case 4096:
954 sz = EMU_RECBS_BUFSIZE_4096;
955 break;
956 case 8192:
957 sz = EMU_RECBS_BUFSIZE_8192;
958 break;
959 case 16384:
960 sz = EMU_RECBS_BUFSIZE_16384;
961 break;
962 case 32768:
963 sz = EMU_RECBS_BUFSIZE_32768;
964 break;
965 case 65536:
966 sz = EMU_RECBS_BUFSIZE_65536;
967 break;
968 default:
969 sz = EMU_RECBS_BUFSIZE_4096;
970 }
971
972 snd_mtxlock(sc->lock);
973 switch (go) {
974 case PCMTRIG_START:
975 ch->run = 1;
976 emu_wrptr(sc->card, 0, ch->sizereg, sz);
977 val = sc->is_emu10k1 ? EMU_ADCCR_LCHANENABLE : EMU_A_ADCCR_LCHANENABLE;
978 if (AFMT_CHANNEL(ch->fmt) > 1)
979 val |= sc->is_emu10k1 ? EMU_ADCCR_RCHANENABLE : EMU_A_ADCCR_RCHANENABLE;
980 val |= sc->is_emu10k1 ? emu_k1_recval(ch->spd) : emu_k2_recval(ch->spd);
981 emu_wrptr(sc->card, 0, ch->setupreg, 0);
982 emu_wrptr(sc->card, 0, ch->setupreg, val);
983 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc);
984 break;
985 case PCMTRIG_STOP:
986 /* FALLTHROUGH */
987 case PCMTRIG_ABORT:
988 ch->run = 0;
989 emu_wrptr(sc->card, 0, ch->sizereg, 0);
990 if (ch->setupreg)
991 emu_wrptr(sc->card, 0, ch->setupreg, 0);
992 (void)emu_intr_unregister(sc->card, ch->ihandle);
993 break;
994 case PCMTRIG_EMLDMAWR:
995 /* FALLTHROUGH */
996 case PCMTRIG_EMLDMARD:
997 /* FALLTHROUGH */
998 default:
999 break;
1000 }
1001 snd_mtxunlock(sc->lock);
1002
1003 return (0);
1004 }
1005
1006 static uint32_t
emurchan_getptr(kobj_t obj __unused,void * c_devinfo)1007 emurchan_getptr(kobj_t obj __unused, void *c_devinfo)
1008 {
1009 struct emu_pcm_rchinfo *ch = c_devinfo;
1010 struct emu_pcm_info *sc = ch->pcm;
1011 int r;
1012
1013 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff;
1014
1015 return (r);
1016 }
1017
1018 static struct pcmchan_caps *
emurchan_getcaps(kobj_t obj __unused,void * c_devinfo __unused)1019 emurchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused)
1020 {
1021 return (&emu_reccaps_adc);
1022 }
1023
1024 static kobj_method_t emurchan_methods[] = {
1025 KOBJMETHOD(channel_init, emurchan_init),
1026 KOBJMETHOD(channel_free, emurchan_free),
1027 KOBJMETHOD(channel_setformat, emurchan_setformat),
1028 KOBJMETHOD(channel_setspeed, emurchan_setspeed),
1029 KOBJMETHOD(channel_setblocksize, emurchan_setblocksize),
1030 KOBJMETHOD(channel_trigger, emurchan_trigger),
1031 KOBJMETHOD(channel_getptr, emurchan_getptr),
1032 KOBJMETHOD(channel_getcaps, emurchan_getcaps),
1033 KOBJMETHOD_END
1034 };
1035 CHANNEL_DECLARE(emurchan);
1036
1037 static void *
emufxrchan_init(kobj_t obj __unused,void * devinfo,struct snd_dbuf * b,struct pcm_channel * c,int dir __unused)1038 emufxrchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
1039 {
1040 struct emu_pcm_info *sc = devinfo;
1041 struct emu_pcm_rchinfo *ch;
1042
1043 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
1044
1045 if (sc == NULL) return (NULL);
1046
1047 ch = &(sc->rch_efx);
1048 ch->fmt = SND_FORMAT(AFMT_S16_LE, 1, 0);
1049 ch->spd = sc->is_emu10k1 ? 48000*32 : 48000 * 64;
1050 ch->idxreg = EMU_FXIDX;
1051 ch->basereg = EMU_FXBA;
1052 ch->sizereg = EMU_FXBS;
1053 ch->irqmask = EMU_INTE_EFXBUFENABLE;
1054 ch->iprmask = EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL;
1055 ch->buffer = b;
1056 ch->pcm = sc;
1057 ch->channel = c;
1058 ch->blksz = sc->bufsz / 2;
1059
1060 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
1061 return (NULL);
1062 else {
1063 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
1064 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
1065 return (ch);
1066 }
1067 }
1068
1069 static int
emufxrchan_setformat(kobj_t obj __unused,void * c_devinfo __unused,uint32_t format)1070 emufxrchan_setformat(kobj_t obj __unused, void *c_devinfo __unused, uint32_t format)
1071 {
1072 if (format == SND_FORMAT(AFMT_S16_LE, 1, 0)) return (0);
1073 return (EINVAL);
1074 }
1075
1076 static uint32_t
emufxrchan_setspeed(kobj_t obj __unused,void * c_devinfo,uint32_t speed)1077 emufxrchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
1078 {
1079 struct emu_pcm_rchinfo *ch = c_devinfo;
1080
1081 /* FIXED RATE CHANNEL */
1082 return (ch->spd);
1083 }
1084
1085 static uint32_t
emufxrchan_setblocksize(kobj_t obj __unused,void * c_devinfo,uint32_t blocksize)1086 emufxrchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
1087 {
1088 struct emu_pcm_rchinfo *ch = c_devinfo;
1089
1090 ch->blksz = blocksize;
1091 /*
1092 * XXX If blocksize is less than half of buffer size we will not get
1093 * interrupt in time and channel will die due to interrupt timeout.
1094 * This should not happen with FX rchan, because it will fill buffer
1095 * very fast (64K buffer is 0.021seconds on Audigy).
1096 */
1097 if (ch->blksz < (ch->pcm->bufsz / 2))
1098 ch->blksz = ch->pcm->bufsz / 2;
1099 return (ch->blksz);
1100 }
1101
1102 static int
emufxrchan_trigger(kobj_t obj __unused,void * c_devinfo,int go)1103 emufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
1104 {
1105 struct emu_pcm_rchinfo *ch = c_devinfo;
1106 struct emu_pcm_info *sc = ch->pcm;
1107 uint32_t sz;
1108
1109 if (!PCMTRIG_COMMON(go))
1110 return (0);
1111
1112 switch (sc->bufsz) {
1113 case 4096:
1114 sz = EMU_RECBS_BUFSIZE_4096;
1115 break;
1116 case 8192:
1117 sz = EMU_RECBS_BUFSIZE_8192;
1118 break;
1119 case 16384:
1120 sz = EMU_RECBS_BUFSIZE_16384;
1121 break;
1122 case 32768:
1123 sz = EMU_RECBS_BUFSIZE_32768;
1124 break;
1125 case 65536:
1126 sz = EMU_RECBS_BUFSIZE_65536;
1127 break;
1128 default:
1129 sz = EMU_RECBS_BUFSIZE_4096;
1130 }
1131
1132 snd_mtxlock(sc->lock);
1133 switch (go) {
1134 case PCMTRIG_START:
1135 ch->run = 1;
1136 emu_wrptr(sc->card, 0, ch->sizereg, sz);
1137 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc);
1138 /*
1139 * SB Live! is limited to 32 mono channels. Audigy
1140 * has 64 mono channels. Channels are enabled
1141 * by setting a bit in EMU_A_FXWC[1|2] registers.
1142 */
1143 /* XXX there is no way to demultiplex this streams for now */
1144 if (sc->is_emu10k1) {
1145 emu_wrptr(sc->card, 0, EMU_FXWC, 0xffffffff);
1146 } else {
1147 emu_wrptr(sc->card, 0, EMU_A_FXWC1, 0xffffffff);
1148 emu_wrptr(sc->card, 0, EMU_A_FXWC2, 0xffffffff);
1149 }
1150 break;
1151 case PCMTRIG_STOP:
1152 /* FALLTHROUGH */
1153 case PCMTRIG_ABORT:
1154 ch->run = 0;
1155 if (sc->is_emu10k1) {
1156 emu_wrptr(sc->card, 0, EMU_FXWC, 0x0);
1157 } else {
1158 emu_wrptr(sc->card, 0, EMU_A_FXWC1, 0x0);
1159 emu_wrptr(sc->card, 0, EMU_A_FXWC2, 0x0);
1160 }
1161 emu_wrptr(sc->card, 0, ch->sizereg, 0);
1162 (void)emu_intr_unregister(sc->card, ch->ihandle);
1163 break;
1164 case PCMTRIG_EMLDMAWR:
1165 /* FALLTHROUGH */
1166 case PCMTRIG_EMLDMARD:
1167 /* FALLTHROUGH */
1168 default:
1169 break;
1170 }
1171 snd_mtxunlock(sc->lock);
1172
1173 return (0);
1174 }
1175
1176 static uint32_t
emufxrchan_getptr(kobj_t obj __unused,void * c_devinfo)1177 emufxrchan_getptr(kobj_t obj __unused, void *c_devinfo)
1178 {
1179 struct emu_pcm_rchinfo *ch = c_devinfo;
1180 struct emu_pcm_info *sc = ch->pcm;
1181 int r;
1182
1183 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff;
1184
1185 return (r);
1186 }
1187
1188 static struct pcmchan_caps *
emufxrchan_getcaps(kobj_t obj __unused,void * c_devinfo)1189 emufxrchan_getcaps(kobj_t obj __unused, void *c_devinfo)
1190 {
1191 struct emu_pcm_rchinfo *ch = c_devinfo;
1192 struct emu_pcm_info *sc = ch->pcm;
1193
1194 if (sc->is_emu10k1)
1195 return (&emu_reccaps_efx_live);
1196 return (&emu_reccaps_efx_audigy);
1197
1198 }
1199
1200 static int
emufxrchan_getrates(kobj_t obj __unused,void * c_devinfo,int ** rates)1201 emufxrchan_getrates(kobj_t obj __unused, void *c_devinfo, int **rates)
1202 {
1203 struct emu_pcm_rchinfo *ch = c_devinfo;
1204 struct emu_pcm_info *sc = ch->pcm;
1205
1206 if (sc->is_emu10k1)
1207 *rates = emu_rates_live;
1208 else
1209 *rates = emu_rates_audigy;
1210
1211 return 1;
1212 }
1213
1214 static kobj_method_t emufxrchan_methods[] = {
1215 KOBJMETHOD(channel_init, emufxrchan_init),
1216 KOBJMETHOD(channel_setformat, emufxrchan_setformat),
1217 KOBJMETHOD(channel_setspeed, emufxrchan_setspeed),
1218 KOBJMETHOD(channel_setblocksize, emufxrchan_setblocksize),
1219 KOBJMETHOD(channel_trigger, emufxrchan_trigger),
1220 KOBJMETHOD(channel_getptr, emufxrchan_getptr),
1221 KOBJMETHOD(channel_getcaps, emufxrchan_getcaps),
1222 KOBJMETHOD(channel_getrates, emufxrchan_getrates),
1223 KOBJMETHOD_END
1224 };
1225 CHANNEL_DECLARE(emufxrchan);
1226
1227
1228 static uint32_t
emu_pcm_intr(void * pcm,uint32_t stat)1229 emu_pcm_intr(void *pcm, uint32_t stat)
1230 {
1231 struct emu_pcm_info *sc = (struct emu_pcm_info *)pcm;
1232 uint32_t ack;
1233 int i;
1234
1235 ack = 0;
1236
1237 snd_mtxlock(sc->lock);
1238
1239 if (stat & EMU_IPR_INTERVALTIMER) {
1240 ack |= EMU_IPR_INTERVALTIMER;
1241 for (i = 0; i < MAX_CHANNELS; i++)
1242 if (sc->pch[i].channel) {
1243 if (sc->pch[i].run == 1) {
1244 snd_mtxunlock(sc->lock);
1245 chn_intr(sc->pch[i].channel);
1246 snd_mtxlock(sc->lock);
1247 } else
1248 emu_timer_enable(sc->card, sc->pch[i].timer, 0);
1249 }
1250 /* ADC may install timer to get low-latency interrupts */
1251 if ((sc->rch_adc.channel) && (sc->rch_adc.run)) {
1252 snd_mtxunlock(sc->lock);
1253 chn_intr(sc->rch_adc.channel);
1254 snd_mtxlock(sc->lock);
1255 }
1256 /*
1257 * EFX does not use timer, because it will fill
1258 * buffer at least 32x times faster than ADC.
1259 */
1260 }
1261
1262
1263 if (stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL)) {
1264 ack |= stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL);
1265 if (sc->rch_adc.channel) {
1266 snd_mtxunlock(sc->lock);
1267 chn_intr(sc->rch_adc.channel);
1268 snd_mtxlock(sc->lock);
1269 }
1270 }
1271
1272 if (stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL)) {
1273 ack |= stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL);
1274 if (sc->rch_efx.channel) {
1275 snd_mtxunlock(sc->lock);
1276 chn_intr(sc->rch_efx.channel);
1277 snd_mtxlock(sc->lock);
1278 }
1279 }
1280 snd_mtxunlock(sc->lock);
1281
1282 return (ack);
1283 }
1284
1285 static int
emu_pcm_init(struct emu_pcm_info * sc)1286 emu_pcm_init(struct emu_pcm_info *sc)
1287 {
1288 sc->bufsz = pcm_getbuffersize(sc->dev, EMUPAGESIZE, EMU_REC_BUFSZ, EMU_MAX_BUFSZ);
1289 return (0);
1290 }
1291
1292 static int
emu_pcm_uninit(struct emu_pcm_info * sc __unused)1293 emu_pcm_uninit(struct emu_pcm_info *sc __unused)
1294 {
1295 return (0);
1296 }
1297
1298 static int
emu_pcm_probe(device_t dev)1299 emu_pcm_probe(device_t dev)
1300 {
1301 uintptr_t func, route, r;
1302 const char *rt;
1303 char buffer[255];
1304
1305 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_FUNC, &func);
1306
1307 if (func != SCF_PCM)
1308 return (ENXIO);
1309
1310 rt = "UNKNOWN";
1311 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route);
1312 switch (route) {
1313 case RT_FRONT:
1314 rt = "front";
1315 break;
1316 case RT_REAR:
1317 rt = "rear";
1318 break;
1319 case RT_CENTER:
1320 rt = "center";
1321 break;
1322 case RT_SUB:
1323 rt = "subwoofer";
1324 break;
1325 case RT_SIDE:
1326 rt = "side";
1327 break;
1328 case RT_MCHRECORD:
1329 rt = "multichannel recording";
1330 break;
1331 }
1332
1333 ksnprintf(buffer, 255, "EMU10Kx DSP %s PCM interface", rt);
1334 device_set_desc_copy(dev, buffer);
1335 return (0);
1336 }
1337
1338 static int
emu_pcm_attach(device_t dev)1339 emu_pcm_attach(device_t dev)
1340 {
1341 struct emu_pcm_info *sc;
1342 unsigned int i;
1343 char status[SND_STATUSLEN];
1344 uint32_t inte, ipr;
1345 uintptr_t route, r, ivar;
1346
1347 sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
1348 sc->card = (struct emu_sc_info *)(device_get_softc(device_get_parent(dev)));
1349 if (sc->card == NULL) {
1350 device_printf(dev, "cannot get bridge conf\n");
1351 kfree(sc, M_DEVBUF);
1352 return (ENXIO);
1353 }
1354
1355 sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10kx pcm softc");
1356 sc->dev = dev;
1357
1358 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ISEMU10K1, &ivar);
1359 sc->is_emu10k1 = ivar ? 1 : 0;
1360
1361 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_MCH_DISABLED, &ivar);
1362 sc->mch_disabled = ivar ? 1 : 0;
1363
1364 sc->codec = NULL;
1365
1366 for (i = 0; i < 8; i++) {
1367 sc->rt.routing_left[i] = i;
1368 sc->rt.amounts_left[i] = 0x00;
1369 sc->rt.routing_right[i] = i;
1370 sc->rt.amounts_right[i] = 0x00;
1371 }
1372
1373 for (i = 0; i < 8; i++) {
1374 sc->rt_mono.routing_left[i] = i;
1375 sc->rt_mono.amounts_left[i] = 0x00;
1376 sc->rt_mono.routing_right[i] = i;
1377 sc->rt_mono.amounts_right[i] = 0x00;
1378 }
1379
1380 sc->emu10k1_volcache[0][0] = 75;
1381 sc->emu10k1_volcache[1][0] = 75;
1382 sc->emu10k1_volcache[0][1] = 75;
1383 sc->emu10k1_volcache[1][1] = 75;
1384 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route);
1385 sc->route = route;
1386 switch (route) {
1387 case RT_FRONT:
1388 sc->rt.amounts_left[0] = 0xff;
1389 sc->rt.amounts_right[1] = 0xff;
1390 sc->rt_mono.amounts_left[0] = 0xff;
1391 sc->rt_mono.amounts_left[1] = 0xff;
1392 if (sc->is_emu10k1)
1393 sc->codec = AC97_CREATE(dev, sc, emu_ac97);
1394 else
1395 sc->codec = AC97_CREATE(dev, sc, emu_eac97);
1396 sc->ac97_mixerclass = NULL;
1397 if (sc->codec != NULL)
1398 sc->ac97_mixerclass = ac97_getmixerclass();
1399 if (mixer_init(dev, &emudspmixer_class, sc)) {
1400 device_printf(dev, "failed to initialize DSP mixer\n");
1401 goto bad;
1402 }
1403 break;
1404 case RT_REAR:
1405 sc->rt.amounts_left[2] = 0xff;
1406 sc->rt.amounts_right[3] = 0xff;
1407 sc->rt_mono.amounts_left[2] = 0xff;
1408 sc->rt_mono.amounts_left[3] = 0xff;
1409 if (mixer_init(dev, &emudspmixer_class, sc)) {
1410 device_printf(dev, "failed to initialize mixer\n");
1411 goto bad;
1412 }
1413 break;
1414 case RT_CENTER:
1415 sc->rt.amounts_left[4] = 0xff;
1416 sc->rt_mono.amounts_left[4] = 0xff;
1417 if (mixer_init(dev, &emudspmixer_class, sc)) {
1418 device_printf(dev, "failed to initialize mixer\n");
1419 goto bad;
1420 }
1421 break;
1422 case RT_SUB:
1423 sc->rt.amounts_left[5] = 0xff;
1424 sc->rt_mono.amounts_left[5] = 0xff;
1425 if (mixer_init(dev, &emudspmixer_class, sc)) {
1426 device_printf(dev, "failed to initialize mixer\n");
1427 goto bad;
1428 }
1429 break;
1430 case RT_SIDE:
1431 sc->rt.amounts_left[6] = 0xff;
1432 sc->rt.amounts_right[7] = 0xff;
1433 sc->rt_mono.amounts_left[6] = 0xff;
1434 sc->rt_mono.amounts_left[7] = 0xff;
1435 if (mixer_init(dev, &emudspmixer_class, sc)) {
1436 device_printf(dev, "failed to initialize mixer\n");
1437 goto bad;
1438 }
1439 break;
1440 case RT_MCHRECORD:
1441 if (mixer_init(dev, &emuefxmixer_class, sc)) {
1442 device_printf(dev, "failed to initialize EFX mixer\n");
1443 goto bad;
1444 }
1445 break;
1446 default:
1447 device_printf(dev, "invalid default route\n");
1448 goto bad;
1449 }
1450
1451 inte = EMU_INTE_INTERTIMERENB;
1452 ipr = EMU_IPR_INTERVALTIMER; /* Used by playback & ADC */
1453 sc->ihandle = emu_intr_register(sc->card, inte, ipr, &emu_pcm_intr, sc);
1454
1455 if (emu_pcm_init(sc) == -1) {
1456 device_printf(dev, "unable to initialize PCM part of the card\n");
1457 goto bad;
1458 }
1459
1460 /*
1461 * We don't register interrupt handler with snd_setup_intr
1462 * in pcm device. Mark pcm device as MPSAFE manually.
1463 */
1464 pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE);
1465
1466 /* XXX we should better get number of available channels from parent */
1467 if (pcm_register(dev, sc, (route == RT_FRONT) ? MAX_CHANNELS : 1, (route == RT_FRONT) ? 1 : 0)) {
1468 device_printf(dev, "can't register PCM channels!\n");
1469 goto bad;
1470 }
1471 sc->pnum = 0;
1472 if (route != RT_MCHRECORD)
1473 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1474 if (route == RT_FRONT) {
1475 for (i = 1; i < MAX_CHANNELS; i++)
1476 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1477 pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc);
1478 }
1479 if (route == RT_MCHRECORD)
1480 pcm_addchan(dev, PCMDIR_REC, &emufxrchan_class, sc);
1481
1482 ksnprintf(status, SND_STATUSLEN, "on %s",
1483 device_get_nameunit(device_get_parent(dev)));
1484 pcm_setstatus(dev, status);
1485
1486 return (0);
1487
1488 bad:
1489 if (sc->codec)
1490 ac97_destroy(sc->codec);
1491 if (sc->lock)
1492 snd_mtxfree(sc->lock);
1493 kfree(sc, M_DEVBUF);
1494 return (ENXIO);
1495 }
1496
1497 static int
emu_pcm_detach(device_t dev)1498 emu_pcm_detach(device_t dev)
1499 {
1500 int r;
1501 struct emu_pcm_info *sc;
1502
1503 sc = pcm_getdevinfo(dev);
1504
1505 r = pcm_unregister(dev);
1506
1507 if (r) return (r);
1508
1509 emu_pcm_uninit(sc);
1510
1511 if (sc->lock)
1512 snd_mtxfree(sc->lock);
1513 kfree(sc, M_DEVBUF);
1514
1515 return (0);
1516 }
1517
1518 static device_method_t emu_pcm_methods[] = {
1519 DEVMETHOD(device_probe, emu_pcm_probe),
1520 DEVMETHOD(device_attach, emu_pcm_attach),
1521 DEVMETHOD(device_detach, emu_pcm_detach),
1522
1523 DEVMETHOD_END
1524 };
1525
1526 static driver_t emu_pcm_driver = {
1527 "pcm",
1528 emu_pcm_methods,
1529 PCM_SOFTC_SIZE,
1530 NULL,
1531 0,
1532 NULL
1533 };
1534 DRIVER_MODULE(snd_emu10kx_pcm, emu10kx, emu_pcm_driver, pcm_devclass, NULL, NULL);
1535 MODULE_DEPEND(snd_emu10kx_pcm, snd_emu10kx, SND_EMU10KX_MINVER, SND_EMU10KX_PREFVER, SND_EMU10KX_MAXVER);
1536 MODULE_DEPEND(snd_emu10kx_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
1537 MODULE_VERSION(snd_emu10kx_pcm, SND_EMU10KX_PREFVER);
1538