2 * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
3 * Copyright (c) 2003-2007 Yuriy Tsibizov <yuriy.tsibizov@gfk.ru>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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
27 * $FreeBSD: head/sys/dev/sound/pci/emu10kx-pcm.c 246128 2013-01-30 18:01:20Z sbz $
30 #include <sys/param.h>
31 #include <sys/types.h>
34 #include <sys/systm.h>
36 #include <sys/queue.h>
37 #include <sys/systm.h>
39 #include <sys/mutex.h>
41 #ifdef HAVE_KERNEL_OPTION_HEADERS
45 #include <dev/sound/chip.h>
46 #include <dev/sound/pcm/sound.h>
47 #include <dev/sound/pcm/ac97.h>
51 #include <dev/sound/pci/emuxkireg.h>
52 #include <dev/sound/pci/emu10kx.h>
54 struct emu_pcm_pchinfo {
59 struct emu_voice *master;
60 struct emu_voice *slave;
61 struct snd_dbuf *buffer;
62 struct pcm_channel *channel;
63 struct emu_pcm_info *pcm;
67 struct emu_pcm_rchinfo {
79 struct snd_dbuf *buffer;
80 struct pcm_channel *channel;
81 struct emu_pcm_info *pcm;
85 /* XXX Hardware playback channels */
86 #define MAX_CHANNELS 4
89 #error Too many hardware channels defined. 13 is the maximum
94 device_t dev; /* device information */
95 struct emu_sc_info *card;
96 struct emu_pcm_pchinfo pch[MAX_CHANNELS]; /* hardware channels */
97 int pnum; /* next free channel number */
98 struct emu_pcm_rchinfo rch_adc;
99 struct emu_pcm_rchinfo rch_efx;
101 struct emu_route rt_mono;
103 int ihandle; /* interrupt handler */
106 struct ac97_info *codec;
107 uint32_t ac97_state[0x7F];
108 kobj_class_t ac97_mixerclass;
109 uint32_t ac97_recdevs;
110 uint32_t ac97_playdevs;
111 struct snd_mixer *sm;
113 unsigned int emu10k1_volcache[2][2];
117 static uint32_t emu_rfmt_adc[] = {
118 SND_FORMAT(AFMT_S16_LE, 1, 0),
119 SND_FORMAT(AFMT_S16_LE, 2, 0),
122 static struct pcmchan_caps emu_reccaps_adc = {
123 8000, 48000, emu_rfmt_adc, 0
126 static uint32_t emu_rfmt_efx[] = {
127 SND_FORMAT(AFMT_S16_LE, 1, 0),
131 static struct pcmchan_caps emu_reccaps_efx_live = {
132 48000*32, 48000*32, emu_rfmt_efx, 0
135 static struct pcmchan_caps emu_reccaps_efx_audigy = {
136 48000*64, 48000*64, emu_rfmt_efx, 0
139 static int emu_rates_live[] = {
143 static int emu_rates_audigy[] = {
147 static uint32_t emu_pfmt[] = {
148 SND_FORMAT(AFMT_U8, 1, 0),
149 SND_FORMAT(AFMT_U8, 2, 0),
150 SND_FORMAT(AFMT_S16_LE, 1, 0),
151 SND_FORMAT(AFMT_S16_LE, 2, 0),
154 static uint32_t emu_pfmt_mono[] = {
155 SND_FORMAT(AFMT_U8, 1, 0),
156 SND_FORMAT(AFMT_S16_LE, 1, 0),
160 static struct pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0};
161 static struct pcmchan_caps emu_playcaps_mono = {4000, 48000, emu_pfmt_mono, 0};
163 static int emu10k1_adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000};
164 /* audigy supports 12kHz. */
165 static int emu10k2_adcspeed[9] = {48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000};
167 static uint32_t emu_pcm_intr(void *pcm, uint32_t stat);
169 static const struct emu_dspmix_props_k1 {
173 } dspmix_k1 [SOUND_MIXER_NRDEVICES] = {
174 /* no mixer device for ac97 */ /* in0 AC97 */
175 [SOUND_MIXER_DIGITAL1] = {1, 1, 1}, /* in1 CD SPDIF */
176 /* not connected */ /* in2 (zoom) */
177 [SOUND_MIXER_DIGITAL2] = {1, 1, 3}, /* in3 toslink */
178 [SOUND_MIXER_LINE2] = {1, 1, 4}, /* in4 Line-In2 */
179 [SOUND_MIXER_DIGITAL3] = {1, 1, 5}, /* in5 on-card SPDIF */
180 [SOUND_MIXER_LINE3] = {1, 1, 6}, /* in6 AUX2 */
181 /* not connected */ /* in7 */
183 static const struct emu_dspmix_props_k2 {
187 } dspmix_k2 [SOUND_MIXER_NRDEVICES] = {
188 [SOUND_MIXER_VOLUME] = {1, 0, (-1)},
189 [SOUND_MIXER_PCM] = {1, 0, (-1)},
191 /* no mixer device */ /* in0 AC97 */
192 [SOUND_MIXER_DIGITAL1] = {1, 1, 1}, /* in1 CD SPDIF */
193 [SOUND_MIXER_DIGITAL2] = {1, 1, 2}, /* in2 COAX SPDIF */
194 /* not connected */ /* in3 */
195 [SOUND_MIXER_LINE2] = {1, 1, 4}, /* in4 Line-In2 */
196 [SOUND_MIXER_DIGITAL3] = {1, 1, 5}, /* in5 on-card SPDIF */
197 [SOUND_MIXER_LINE3] = {1, 1, 6}, /* in6 AUX2 */
198 /* not connected */ /* in7 */
202 emu_dspmixer_init(struct snd_mixer *m)
204 struct emu_pcm_info *sc;
211 sc = mix_getdevinfo(m);
213 if (sc->route == RT_FRONT) {
214 /* create submixer for AC97 codec */
215 if ((sc->ac97_mixerclass != NULL) && (sc->codec != NULL)) {
216 sc->sm = mixer_create(sc->dev, sc->ac97_mixerclass, sc->codec, "ac97");
217 if (sc->sm != NULL) {
218 p = mix_getdevs(sc->sm);
219 r = mix_getrecdevs(sc->sm);
223 sc->ac97_playdevs = p;
224 sc->ac97_recdevs = r;
227 /* This two are always here */
228 p |= (1 << SOUND_MIXER_PCM);
229 p |= (1 << SOUND_MIXER_VOLUME);
231 if (sc->route == RT_FRONT) {
232 if (sc->is_emu10k1) {
233 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
234 if (dspmix_k1[i].present)
236 if (dspmix_k1[i].recdev)
240 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
241 if (dspmix_k2[i].present)
243 if (dspmix_k2[i].recdev)
250 mix_setrecdevs(m, r);
256 emu_dspmixer_uninit(struct snd_mixer *m)
258 struct emu_pcm_info *sc;
261 /* drop submixer for AC97 codec */
262 sc = mix_getdevinfo(m);
264 err = mixer_delete(sc->sm);
272 emu_dspmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
274 struct emu_pcm_info *sc;
276 sc = mix_getdevinfo(m);
279 case SOUND_MIXER_VOLUME:
283 mix_set(sc->sm, dev, left, right);
284 if (sc->mch_disabled) {
285 /* In emu10k1 case PCM volume does not affect
286 sound routed to rear & center/sub (it is connected
287 to AC97 codec). Calculate it manually. */
288 /* This really should belong to emu10kx.c */
289 if (sc->is_emu10k1) {
290 sc->emu10k1_volcache[0][0] = left;
291 left = left * sc->emu10k1_volcache[1][0] / 100;
292 sc->emu10k1_volcache[0][1] = right;
293 right = right * sc->emu10k1_volcache[1][1] / 100;
296 emumix_set_volume(sc->card, M_MASTER_REAR_L, left);
297 emumix_set_volume(sc->card, M_MASTER_REAR_R, right);
298 if (!sc->is_emu10k1) {
299 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2);
300 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2);
306 emumix_set_volume(sc->card, M_MASTER_REAR_L, left);
307 emumix_set_volume(sc->card, M_MASTER_REAR_R, right);
310 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2);
313 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2);
317 case SOUND_MIXER_PCM:
321 mix_set(sc->sm, dev, left, right);
322 if (sc->mch_disabled) {
323 /* See SOUND_MIXER_VOLUME case */
324 if (sc->is_emu10k1) {
325 sc->emu10k1_volcache[1][0] = left;
326 left = left * sc->emu10k1_volcache[0][0] / 100;
327 sc->emu10k1_volcache[1][1] = right;
328 right = right * sc->emu10k1_volcache[0][1] / 100;
330 emumix_set_volume(sc->card, M_MASTER_REAR_L, left);
331 emumix_set_volume(sc->card, M_MASTER_REAR_R, right);
333 if (!sc->is_emu10k1) {
334 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2);
335 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2);
341 emumix_set_volume(sc->card, M_FX2_REAR_L, left);
342 emumix_set_volume(sc->card, M_FX3_REAR_R, right);
345 emumix_set_volume(sc->card, M_FX4_CENTER, (left+right)/2);
348 emumix_set_volume(sc->card, M_FX5_SUBWOOFER, (left+right)/2);
352 case SOUND_MIXER_DIGITAL1: /* CD SPDIF, in1 */
353 emumix_set_volume(sc->card, M_IN1_FRONT_L, left);
354 emumix_set_volume(sc->card, M_IN1_FRONT_R, right);
356 case SOUND_MIXER_DIGITAL2:
357 if (sc->is_emu10k1) {
359 emumix_set_volume(sc->card, M_IN3_FRONT_L, left);
360 emumix_set_volume(sc->card, M_IN3_FRONT_R, right);
362 /* COAX SPDIF, in2 */
363 emumix_set_volume(sc->card, M_IN2_FRONT_L, left);
364 emumix_set_volume(sc->card, M_IN2_FRONT_R, right);
367 case SOUND_MIXER_LINE2: /* Line-In2, in4 */
368 emumix_set_volume(sc->card, M_IN4_FRONT_L, left);
369 emumix_set_volume(sc->card, M_IN4_FRONT_R, right);
371 case SOUND_MIXER_DIGITAL3: /* on-card SPDIF, in5 */
372 emumix_set_volume(sc->card, M_IN5_FRONT_L, left);
373 emumix_set_volume(sc->card, M_IN5_FRONT_R, right);
375 case SOUND_MIXER_LINE3: /* AUX2, in6 */
376 emumix_set_volume(sc->card, M_IN6_FRONT_L, left);
377 emumix_set_volume(sc->card, M_IN6_FRONT_R, right);
380 if (sc->sm != NULL) {
381 /* XXX emumix_set_volume is not required here */
382 emumix_set_volume(sc->card, M_IN0_FRONT_L, 100);
383 emumix_set_volume(sc->card, M_IN0_FRONT_R, 100);
384 mix_set(sc->sm, dev, left, right);
386 device_printf(sc->dev, "mixer error: unknown device %d\n", dev);
392 emu_dspmixer_setrecsrc(struct snd_mixer *m, u_int32_t src)
394 struct emu_pcm_info *sc;
399 sc = mix_getdevinfo(m);
401 for (i=0; i < 8; i++)
405 if ((src & sc->ac97_recdevs) !=0)
406 if (mix_setrecsrc(sc->sm, src & sc->ac97_recdevs) == 0) {
407 recmask |= (src & sc->ac97_recdevs);
408 /* Recording from AC97 codec.
409 Enable AC97 route to rec on DSP */
412 if (sc->is_emu10k1) {
413 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
414 if (dspmix_k1[i].recdev)
415 if ((src & (1 << i)) == ((uint32_t)1 << i)) {
417 /* enable device i */
418 input[dspmix_k1[i].input] = 1;
422 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
423 if (dspmix_k2[i].recdev)
424 if ((src & (1 << i)) == ((uint32_t)1 << i)) {
426 /* enable device i */
427 input[dspmix_k2[i].input] = 1;
431 emumix_set_volume(sc->card, M_IN0_REC_L, input[0] == 1 ? 100 : 0);
432 emumix_set_volume(sc->card, M_IN0_REC_R, input[0] == 1 ? 100 : 0);
434 emumix_set_volume(sc->card, M_IN1_REC_L, input[1] == 1 ? 100 : 0);
435 emumix_set_volume(sc->card, M_IN1_REC_R, input[1] == 1 ? 100 : 0);
437 if (!sc->is_emu10k1) {
438 emumix_set_volume(sc->card, M_IN2_REC_L, input[2] == 1 ? 100 : 0);
439 emumix_set_volume(sc->card, M_IN2_REC_R, input[2] == 1 ? 100 : 0);
442 if (sc->is_emu10k1) {
443 emumix_set_volume(sc->card, M_IN3_REC_L, input[3] == 1 ? 100 : 0);
444 emumix_set_volume(sc->card, M_IN3_REC_R, input[3] == 1 ? 100 : 0);
447 emumix_set_volume(sc->card, M_IN4_REC_L, input[4] == 1 ? 100 : 0);
448 emumix_set_volume(sc->card, M_IN4_REC_R, input[4] == 1 ? 100 : 0);
450 emumix_set_volume(sc->card, M_IN5_REC_L, input[5] == 1 ? 100 : 0);
451 emumix_set_volume(sc->card, M_IN5_REC_R, input[5] == 1 ? 100 : 0);
453 emumix_set_volume(sc->card, M_IN6_REC_L, input[6] == 1 ? 100 : 0);
454 emumix_set_volume(sc->card, M_IN6_REC_R, input[6] == 1 ? 100 : 0);
456 /* XXX check for K1/k2 differences? */
457 if ((src & (1 << SOUND_MIXER_PCM)) == (1 << SOUND_MIXER_PCM)) {
458 emumix_set_volume(sc->card, M_FX0_REC_L, emumix_get_volume(sc->card, M_FX0_FRONT_L));
459 emumix_set_volume(sc->card, M_FX1_REC_R, emumix_get_volume(sc->card, M_FX1_FRONT_R));
461 emumix_set_volume(sc->card, M_FX0_REC_L, 0);
462 emumix_set_volume(sc->card, M_FX1_REC_R, 0);
468 static kobj_method_t emudspmixer_methods[] = {
469 KOBJMETHOD(mixer_init, emu_dspmixer_init),
470 KOBJMETHOD(mixer_uninit, emu_dspmixer_uninit),
471 KOBJMETHOD(mixer_set, emu_dspmixer_set),
472 KOBJMETHOD(mixer_setrecsrc, emu_dspmixer_setrecsrc),
475 MIXER_DECLARE(emudspmixer);
478 emu_efxmixer_init(struct snd_mixer *m)
480 mix_setdevs(m, SOUND_MASK_VOLUME);
481 mix_setrecdevs(m, SOUND_MASK_MONITOR);
486 emu_efxmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
488 if (left + right == 200) return (0);
493 emu_efxmixer_setrecsrc(struct snd_mixer *m __unused, u_int32_t src __unused)
495 return (SOUND_MASK_MONITOR);
498 static kobj_method_t emuefxmixer_methods[] = {
499 KOBJMETHOD(mixer_init, emu_efxmixer_init),
500 KOBJMETHOD(mixer_set, emu_efxmixer_set),
501 KOBJMETHOD(mixer_setrecsrc, emu_efxmixer_setrecsrc),
504 MIXER_DECLARE(emuefxmixer);
507 * AC97 emulation code for Audigy and later cards.
508 * Some parts of AC97 codec are not used by hardware, but can be used
509 * to change some DSP controls via AC97 mixer interface. This includes:
510 * - master volume controls MASTER_FRONT_[R|L]
511 * - pcm volume controls FX[0|1]_FRONT_[R|L]
512 * - rec volume controls MASTER_REC_[R|L]
513 * We do it because we need to put it under user control....
514 * We also keep some parts of AC97 disabled to get better sound quality
517 #define AC97LEFT(x) ((x & 0x7F00)>>8)
518 #define AC97RIGHT(x) (x & 0x007F)
519 #define AC97MUTE(x) ((x & 0x8000)>>15)
520 #define BIT4_TO100(x) (100-(x)*100/(0x0f))
521 #define BIT6_TO100(x) (100-(x)*100/(0x3f))
522 #define BIT4_TO255(x) (255-(x)*255/(0x0f))
523 #define BIT6_TO255(x) (255-(x)*255/(0x3f))
524 #define V100_TOBIT6(x) (0x3f*(100-x)/100)
525 #define V100_TOBIT4(x) (0x0f*(100-x)/100)
526 #define AC97ENCODE(x_muted, x_left, x_right) (((x_muted & 1)<<15) | ((x_left & 0x3f)<<8) | (x_right & 0x3f))
529 emu_ac97_read_emulation(struct emu_pcm_info *sc, int regno)
539 case AC97_MIX_MASTER:
540 emulated = sc->ac97_state[AC97_MIX_MASTER];
544 emulated = sc->ac97_state[AC97_MIX_PCM];
547 case AC97_REG_RECSEL:
552 emulated = sc->ac97_state[AC97_MIX_RGAIN];
557 emu_wr(sc->card, EMU_AC97ADDR, regno, 1);
558 tmp = emu_rd(sc->card, EMU_AC97DATA, 2);
567 emu_ac97_write_emulation(struct emu_pcm_info *sc, int regno, uint32_t data)
571 uint32_t emu_left, emu_right;
576 left = AC97LEFT(data);
577 emu_left = BIT6_TO100(left); /* We show us as 6-bit AC97 mixer */
578 right = AC97RIGHT(data);
579 emu_right = BIT6_TO100(right);
580 is_mute = AC97MUTE(data);
582 emu_left = emu_right = 0;
585 /* TODO: reset emulator on AC97_RESET */
586 case AC97_MIX_MASTER:
587 emumix_set_volume(sc->card, M_MASTER_FRONT_L, emu_left);
588 emumix_set_volume(sc->card, M_MASTER_FRONT_R, emu_right);
589 sc->ac97_state[AC97_MIX_MASTER] = data & (0x8000 | 0x3f3f);
590 data = 0x8000; /* Mute AC97 main out */
592 case AC97_MIX_PCM: /* PCM OUT VOL */
593 emumix_set_volume(sc->card, M_FX0_FRONT_L, emu_left);
594 emumix_set_volume(sc->card, M_FX1_FRONT_R, emu_right);
595 sc->ac97_state[AC97_MIX_PCM] = data & (0x8000 | 0x3f3f);
596 data = 0x8000; /* Mute AC97 PCM out */
598 case AC97_REG_RECSEL:
600 * PCM recording source is set to "stereo mix" (labeled "vol"
601 * in mixer). There is no 'playback' from AC97 codec -
602 * if you want to hear anything from AC97 you have to _record_
603 * it. Keep things simple and record "stereo mix".
607 case AC97_MIX_RGAIN: /* RECORD GAIN */
608 emu_left = BIT4_TO100(left); /* rgain is 4-bit */
609 emu_right = BIT4_TO100(right);
610 emumix_set_volume(sc->card, M_MASTER_REC_L, 100-emu_left);
611 emumix_set_volume(sc->card, M_MASTER_REC_R, 100-emu_right);
613 * Record gain on AC97 should stay zero to get AC97 sound on
614 * AC97_[RL] connectors on EMU10K2 chip. AC97 on Audigy is not
615 * directly connected to any output, only to EMU10K2 chip Use
616 * this control to set AC97 mix volume inside EMU10K2 chip
618 sc->ac97_state[AC97_MIX_RGAIN] = data & (0x8000 | 0x0f0f);
623 emu_wr(sc->card, EMU_AC97ADDR, regno, 1);
624 emu_wr(sc->card, EMU_AC97DATA, data, 2);
629 emu_erdcd(kobj_t obj __unused, void *devinfo, int regno)
631 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
633 return (emu_ac97_read_emulation(sc, regno));
637 emu_ewrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data)
639 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
641 emu_ac97_write_emulation(sc, regno, data);
645 static kobj_method_t emu_eac97_methods[] = {
646 KOBJMETHOD(ac97_read, emu_erdcd),
647 KOBJMETHOD(ac97_write, emu_ewrcd),
650 AC97_DECLARE(emu_eac97);
652 /* real ac97 codec */
654 emu_rdcd(kobj_t obj __unused, void *devinfo, int regno)
657 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
659 KASSERT(sc->card != NULL, ("emu_rdcd: no soundcard"));
660 emu_wr(sc->card, EMU_AC97ADDR, regno, 1);
661 rd = emu_rd(sc->card, EMU_AC97DATA, 2);
666 emu_wrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data)
668 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
670 KASSERT(sc->card != NULL, ("emu_wrcd: no soundcard"));
671 emu_wr(sc->card, EMU_AC97ADDR, regno, 1);
672 emu_wr(sc->card, EMU_AC97DATA, data, 2);
676 static kobj_method_t emu_ac97_methods[] = {
677 KOBJMETHOD(ac97_read, emu_rdcd),
678 KOBJMETHOD(ac97_write, emu_wrcd),
681 AC97_DECLARE(emu_ac97);
685 emu_k1_recval(int speed)
690 while ((val < 7) && (speed < emu10k1_adcspeed[val]))
696 emu_k2_recval(int speed)
701 while ((val < 8) && (speed < emu10k2_adcspeed[val]))
707 emupchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
709 struct emu_pcm_info *sc = devinfo;
710 struct emu_pcm_pchinfo *ch;
713 KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction"));
714 KASSERT(sc->card != NULL, ("empchan_init: no soundcard"));
717 if (sc->pnum >= MAX_CHANNELS)
719 ch = &(sc->pch[sc->pnum++]);
723 ch->blksz = sc->bufsz;
724 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
726 ch->master = emu_valloc(sc->card);
728 * XXX we have to allocate slave even for mono channel until we
729 * fix emu_vfree to handle this case.
731 ch->slave = emu_valloc(sc->card);
732 ch->timer = emu_timer_create(sc->card);
733 r = (emu_vinit(sc->card, ch->master, ch->slave, EMU_PLAY_BUFSZ, ch->buffer)) ? NULL : ch;
738 emupchan_free(kobj_t obj __unused, void *c_devinfo)
740 struct emu_pcm_pchinfo *ch = c_devinfo;
741 struct emu_pcm_info *sc = ch->pcm;
743 emu_timer_clear(sc->card, ch->timer);
744 if (ch->slave != NULL)
745 emu_vfree(sc->card, ch->slave);
746 emu_vfree(sc->card, ch->master);
751 emupchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format)
753 struct emu_pcm_pchinfo *ch = c_devinfo;
760 emupchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
762 struct emu_pcm_pchinfo *ch = c_devinfo;
769 emupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
771 struct emu_pcm_pchinfo *ch = c_devinfo;
772 struct emu_pcm_info *sc = ch->pcm;
774 if (blocksize > ch->pcm->bufsz)
775 blocksize = ch->pcm->bufsz;
776 snd_mtxlock(sc->lock);
777 ch->blksz = blocksize;
778 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
779 snd_mtxunlock(sc->lock);
784 emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
786 struct emu_pcm_pchinfo *ch = c_devinfo;
787 struct emu_pcm_info *sc = ch->pcm;
789 if (!PCMTRIG_COMMON(go))
792 snd_mtxlock(sc->lock); /* XXX can we trigger on parallel threads ? */
793 if (go == PCMTRIG_START) {
794 emu_vsetup(ch->master, ch->fmt, ch->spd);
795 if (AFMT_CHANNEL(ch->fmt) > 1)
796 emu_vroute(sc->card, &(sc->rt), ch->master);
798 emu_vroute(sc->card, &(sc->rt_mono), ch->master);
799 emu_vwrite(sc->card, ch->master);
800 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
801 emu_timer_enable(sc->card, ch->timer, 1);
803 /* PCM interrupt handler will handle PCMTRIG_STOP event */
804 ch->run = (go == PCMTRIG_START) ? 1 : 0;
805 emu_vtrigger(sc->card, ch->master, ch->run);
806 snd_mtxunlock(sc->lock);
811 emupchan_getptr(kobj_t obj __unused, void *c_devinfo)
813 struct emu_pcm_pchinfo *ch = c_devinfo;
814 struct emu_pcm_info *sc = ch->pcm;
817 r = emu_vpos(sc->card, ch->master);
822 static struct pcmchan_caps *
823 emupchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused)
825 struct emu_pcm_pchinfo *ch = c_devinfo;
826 struct emu_pcm_info *sc = ch->pcm;
834 return (&emu_playcaps);
839 return (&emu_playcaps_mono);
845 static kobj_method_t emupchan_methods[] = {
846 KOBJMETHOD(channel_init, emupchan_init),
847 KOBJMETHOD(channel_free, emupchan_free),
848 KOBJMETHOD(channel_setformat, emupchan_setformat),
849 KOBJMETHOD(channel_setspeed, emupchan_setspeed),
850 KOBJMETHOD(channel_setblocksize, emupchan_setblocksize),
851 KOBJMETHOD(channel_trigger, emupchan_trigger),
852 KOBJMETHOD(channel_getptr, emupchan_getptr),
853 KOBJMETHOD(channel_getcaps, emupchan_getcaps),
856 CHANNEL_DECLARE(emupchan);
859 emurchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
861 struct emu_pcm_info *sc = devinfo;
862 struct emu_pcm_rchinfo *ch;
864 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
869 ch->blksz = sc->bufsz / 2; /* We rise interrupt for half-full buffer */
870 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
872 ch->idxreg = sc->is_emu10k1 ? EMU_ADCIDX : EMU_A_ADCIDX;
873 ch->basereg = EMU_ADCBA;
874 ch->sizereg = EMU_ADCBS;
875 ch->setupreg = EMU_ADCCR;
876 ch->irqmask = EMU_INTE_ADCBUFENABLE;
877 ch->iprmask = EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL;
879 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
882 ch->timer = emu_timer_create(sc->card);
883 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
884 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
890 emurchan_free(kobj_t obj __unused, void *c_devinfo)
892 struct emu_pcm_rchinfo *ch = c_devinfo;
893 struct emu_pcm_info *sc = ch->pcm;
895 emu_timer_clear(sc->card, ch->timer);
900 emurchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format)
902 struct emu_pcm_rchinfo *ch = c_devinfo;
909 emurchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
911 struct emu_pcm_rchinfo *ch = c_devinfo;
913 if (ch->pcm->is_emu10k1) {
914 speed = emu10k1_adcspeed[emu_k1_recval(speed)];
916 speed = emu10k2_adcspeed[emu_k2_recval(speed)];
923 emurchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
925 struct emu_pcm_rchinfo *ch = c_devinfo;
926 struct emu_pcm_info *sc = ch->pcm;
928 ch->blksz = blocksize;
930 * If blocksize is less than half of buffer size we will not get
931 * BUFHALFFULL interrupt in time and channel will need to generate
932 * (and use) timer interrupts. Otherwise channel will be marked dead.
934 if (ch->blksz < (ch->pcm->bufsz / 2)) {
935 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
936 emu_timer_enable(sc->card, ch->timer, 1);
938 emu_timer_enable(sc->card, ch->timer, 0);
944 emurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
946 struct emu_pcm_rchinfo *ch = c_devinfo;
947 struct emu_pcm_info *sc = ch->pcm;
950 if (!PCMTRIG_COMMON(go))
955 sz = EMU_RECBS_BUFSIZE_4096;
958 sz = EMU_RECBS_BUFSIZE_8192;
961 sz = EMU_RECBS_BUFSIZE_16384;
964 sz = EMU_RECBS_BUFSIZE_32768;
967 sz = EMU_RECBS_BUFSIZE_65536;
970 sz = EMU_RECBS_BUFSIZE_4096;
973 snd_mtxlock(sc->lock);
977 emu_wrptr(sc->card, 0, ch->sizereg, sz);
978 val = sc->is_emu10k1 ? EMU_ADCCR_LCHANENABLE : EMU_A_ADCCR_LCHANENABLE;
979 if (AFMT_CHANNEL(ch->fmt) > 1)
980 val |= sc->is_emu10k1 ? EMU_ADCCR_RCHANENABLE : EMU_A_ADCCR_RCHANENABLE;
981 val |= sc->is_emu10k1 ? emu_k1_recval(ch->spd) : emu_k2_recval(ch->spd);
982 emu_wrptr(sc->card, 0, ch->setupreg, 0);
983 emu_wrptr(sc->card, 0, ch->setupreg, val);
984 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc);
990 emu_wrptr(sc->card, 0, ch->sizereg, 0);
992 emu_wrptr(sc->card, 0, ch->setupreg, 0);
993 (void)emu_intr_unregister(sc->card, ch->ihandle);
995 case PCMTRIG_EMLDMAWR:
997 case PCMTRIG_EMLDMARD:
1002 snd_mtxunlock(sc->lock);
1008 emurchan_getptr(kobj_t obj __unused, void *c_devinfo)
1010 struct emu_pcm_rchinfo *ch = c_devinfo;
1011 struct emu_pcm_info *sc = ch->pcm;
1014 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff;
1019 static struct pcmchan_caps *
1020 emurchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused)
1022 return (&emu_reccaps_adc);
1025 static kobj_method_t emurchan_methods[] = {
1026 KOBJMETHOD(channel_init, emurchan_init),
1027 KOBJMETHOD(channel_free, emurchan_free),
1028 KOBJMETHOD(channel_setformat, emurchan_setformat),
1029 KOBJMETHOD(channel_setspeed, emurchan_setspeed),
1030 KOBJMETHOD(channel_setblocksize, emurchan_setblocksize),
1031 KOBJMETHOD(channel_trigger, emurchan_trigger),
1032 KOBJMETHOD(channel_getptr, emurchan_getptr),
1033 KOBJMETHOD(channel_getcaps, emurchan_getcaps),
1036 CHANNEL_DECLARE(emurchan);
1039 emufxrchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
1041 struct emu_pcm_info *sc = devinfo;
1042 struct emu_pcm_rchinfo *ch;
1044 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
1046 if (sc == NULL) return (NULL);
1048 ch = &(sc->rch_efx);
1049 ch->fmt = SND_FORMAT(AFMT_S16_LE, 1, 0);
1050 ch->spd = sc->is_emu10k1 ? 48000*32 : 48000 * 64;
1051 ch->idxreg = EMU_FXIDX;
1052 ch->basereg = EMU_FXBA;
1053 ch->sizereg = EMU_FXBS;
1054 ch->irqmask = EMU_INTE_EFXBUFENABLE;
1055 ch->iprmask = EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL;
1059 ch->blksz = sc->bufsz / 2;
1061 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
1064 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
1065 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
1071 emufxrchan_setformat(kobj_t obj __unused, void *c_devinfo __unused, uint32_t format)
1073 if (format == SND_FORMAT(AFMT_S16_LE, 1, 0)) return (0);
1078 emufxrchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
1080 struct emu_pcm_rchinfo *ch = c_devinfo;
1082 /* FIXED RATE CHANNEL */
1087 emufxrchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
1089 struct emu_pcm_rchinfo *ch = c_devinfo;
1091 ch->blksz = blocksize;
1093 * XXX If blocksize is less than half of buffer size we will not get
1094 * interrupt in time and channel will die due to interrupt timeout.
1095 * This should not happen with FX rchan, because it will fill buffer
1096 * very fast (64K buffer is 0.021seconds on Audigy).
1098 if (ch->blksz < (ch->pcm->bufsz / 2))
1099 ch->blksz = ch->pcm->bufsz / 2;
1104 emufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
1106 struct emu_pcm_rchinfo *ch = c_devinfo;
1107 struct emu_pcm_info *sc = ch->pcm;
1110 if (!PCMTRIG_COMMON(go))
1113 switch (sc->bufsz) {
1115 sz = EMU_RECBS_BUFSIZE_4096;
1118 sz = EMU_RECBS_BUFSIZE_8192;
1121 sz = EMU_RECBS_BUFSIZE_16384;
1124 sz = EMU_RECBS_BUFSIZE_32768;
1127 sz = EMU_RECBS_BUFSIZE_65536;
1130 sz = EMU_RECBS_BUFSIZE_4096;
1133 snd_mtxlock(sc->lock);
1137 emu_wrptr(sc->card, 0, ch->sizereg, sz);
1138 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc);
1140 * SB Live! is limited to 32 mono channels. Audigy
1141 * has 64 mono channels. Channels are enabled
1142 * by setting a bit in EMU_A_FXWC[1|2] registers.
1144 /* XXX there is no way to demultiplex this streams for now */
1145 if (sc->is_emu10k1) {
1146 emu_wrptr(sc->card, 0, EMU_FXWC, 0xffffffff);
1148 emu_wrptr(sc->card, 0, EMU_A_FXWC1, 0xffffffff);
1149 emu_wrptr(sc->card, 0, EMU_A_FXWC2, 0xffffffff);
1156 if (sc->is_emu10k1) {
1157 emu_wrptr(sc->card, 0, EMU_FXWC, 0x0);
1159 emu_wrptr(sc->card, 0, EMU_A_FXWC1, 0x0);
1160 emu_wrptr(sc->card, 0, EMU_A_FXWC2, 0x0);
1162 emu_wrptr(sc->card, 0, ch->sizereg, 0);
1163 (void)emu_intr_unregister(sc->card, ch->ihandle);
1165 case PCMTRIG_EMLDMAWR:
1167 case PCMTRIG_EMLDMARD:
1172 snd_mtxunlock(sc->lock);
1178 emufxrchan_getptr(kobj_t obj __unused, void *c_devinfo)
1180 struct emu_pcm_rchinfo *ch = c_devinfo;
1181 struct emu_pcm_info *sc = ch->pcm;
1184 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff;
1189 static struct pcmchan_caps *
1190 emufxrchan_getcaps(kobj_t obj __unused, void *c_devinfo)
1192 struct emu_pcm_rchinfo *ch = c_devinfo;
1193 struct emu_pcm_info *sc = ch->pcm;
1196 return (&emu_reccaps_efx_live);
1197 return (&emu_reccaps_efx_audigy);
1202 emufxrchan_getrates(kobj_t obj __unused, void *c_devinfo, int **rates)
1204 struct emu_pcm_rchinfo *ch = c_devinfo;
1205 struct emu_pcm_info *sc = ch->pcm;
1208 *rates = emu_rates_live;
1210 *rates = emu_rates_audigy;
1215 static kobj_method_t emufxrchan_methods[] = {
1216 KOBJMETHOD(channel_init, emufxrchan_init),
1217 KOBJMETHOD(channel_setformat, emufxrchan_setformat),
1218 KOBJMETHOD(channel_setspeed, emufxrchan_setspeed),
1219 KOBJMETHOD(channel_setblocksize, emufxrchan_setblocksize),
1220 KOBJMETHOD(channel_trigger, emufxrchan_trigger),
1221 KOBJMETHOD(channel_getptr, emufxrchan_getptr),
1222 KOBJMETHOD(channel_getcaps, emufxrchan_getcaps),
1223 KOBJMETHOD(channel_getrates, emufxrchan_getrates),
1226 CHANNEL_DECLARE(emufxrchan);
1230 emu_pcm_intr(void *pcm, uint32_t stat)
1232 struct emu_pcm_info *sc = (struct emu_pcm_info *)pcm;
1238 snd_mtxlock(sc->lock);
1240 if (stat & EMU_IPR_INTERVALTIMER) {
1241 ack |= EMU_IPR_INTERVALTIMER;
1242 for (i = 0; i < MAX_CHANNELS; i++)
1243 if (sc->pch[i].channel) {
1244 if (sc->pch[i].run == 1) {
1245 snd_mtxunlock(sc->lock);
1246 chn_intr(sc->pch[i].channel);
1247 snd_mtxlock(sc->lock);
1249 emu_timer_enable(sc->card, sc->pch[i].timer, 0);
1251 /* ADC may install timer to get low-latency interrupts */
1252 if ((sc->rch_adc.channel) && (sc->rch_adc.run)) {
1253 snd_mtxunlock(sc->lock);
1254 chn_intr(sc->rch_adc.channel);
1255 snd_mtxlock(sc->lock);
1258 * EFX does not use timer, because it will fill
1259 * buffer at least 32x times faster than ADC.
1264 if (stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL)) {
1265 ack |= stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL);
1266 if (sc->rch_adc.channel) {
1267 snd_mtxunlock(sc->lock);
1268 chn_intr(sc->rch_adc.channel);
1269 snd_mtxlock(sc->lock);
1273 if (stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL)) {
1274 ack |= stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL);
1275 if (sc->rch_efx.channel) {
1276 snd_mtxunlock(sc->lock);
1277 chn_intr(sc->rch_efx.channel);
1278 snd_mtxlock(sc->lock);
1281 snd_mtxunlock(sc->lock);
1287 emu_pcm_init(struct emu_pcm_info *sc)
1289 sc->bufsz = pcm_getbuffersize(sc->dev, EMUPAGESIZE, EMU_REC_BUFSZ, EMU_MAX_BUFSZ);
1294 emu_pcm_uninit(struct emu_pcm_info *sc __unused)
1300 emu_pcm_probe(device_t dev)
1302 uintptr_t func, route, r;
1306 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_FUNC, &func);
1308 if (func != SCF_PCM)
1312 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route);
1330 rt = "multichannel recording";
1334 ksnprintf(buffer, 255, "EMU10Kx DSP %s PCM interface", rt);
1335 device_set_desc_copy(dev, buffer);
1340 emu_pcm_attach(device_t dev)
1342 struct emu_pcm_info *sc;
1344 char status[SND_STATUSLEN];
1346 uintptr_t route, r, ivar;
1348 sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
1349 sc->card = (struct emu_sc_info *)(device_get_softc(device_get_parent(dev)));
1350 if (sc->card == NULL) {
1351 device_printf(dev, "cannot get bridge conf\n");
1352 kfree(sc, M_DEVBUF);
1356 sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10kx pcm softc");
1359 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ISEMU10K1, &ivar);
1360 sc->is_emu10k1 = ivar ? 1 : 0;
1362 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_MCH_DISABLED, &ivar);
1363 sc->mch_disabled = ivar ? 1 : 0;
1367 for (i = 0; i < 8; i++) {
1368 sc->rt.routing_left[i] = i;
1369 sc->rt.amounts_left[i] = 0x00;
1370 sc->rt.routing_right[i] = i;
1371 sc->rt.amounts_right[i] = 0x00;
1374 for (i = 0; i < 8; i++) {
1375 sc->rt_mono.routing_left[i] = i;
1376 sc->rt_mono.amounts_left[i] = 0x00;
1377 sc->rt_mono.routing_right[i] = i;
1378 sc->rt_mono.amounts_right[i] = 0x00;
1381 sc->emu10k1_volcache[0][0] = 75;
1382 sc->emu10k1_volcache[1][0] = 75;
1383 sc->emu10k1_volcache[0][1] = 75;
1384 sc->emu10k1_volcache[1][1] = 75;
1385 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route);
1389 sc->rt.amounts_left[0] = 0xff;
1390 sc->rt.amounts_right[1] = 0xff;
1391 sc->rt_mono.amounts_left[0] = 0xff;
1392 sc->rt_mono.amounts_left[1] = 0xff;
1394 sc->codec = AC97_CREATE(dev, sc, emu_ac97);
1396 sc->codec = AC97_CREATE(dev, sc, emu_eac97);
1397 sc->ac97_mixerclass = NULL;
1398 if (sc->codec != NULL)
1399 sc->ac97_mixerclass = ac97_getmixerclass();
1400 if (mixer_init(dev, &emudspmixer_class, sc)) {
1401 device_printf(dev, "failed to initialize DSP mixer\n");
1406 sc->rt.amounts_left[2] = 0xff;
1407 sc->rt.amounts_right[3] = 0xff;
1408 sc->rt_mono.amounts_left[2] = 0xff;
1409 sc->rt_mono.amounts_left[3] = 0xff;
1410 if (mixer_init(dev, &emudspmixer_class, sc)) {
1411 device_printf(dev, "failed to initialize mixer\n");
1416 sc->rt.amounts_left[4] = 0xff;
1417 sc->rt_mono.amounts_left[4] = 0xff;
1418 if (mixer_init(dev, &emudspmixer_class, sc)) {
1419 device_printf(dev, "failed to initialize mixer\n");
1424 sc->rt.amounts_left[5] = 0xff;
1425 sc->rt_mono.amounts_left[5] = 0xff;
1426 if (mixer_init(dev, &emudspmixer_class, sc)) {
1427 device_printf(dev, "failed to initialize mixer\n");
1432 sc->rt.amounts_left[6] = 0xff;
1433 sc->rt.amounts_right[7] = 0xff;
1434 sc->rt_mono.amounts_left[6] = 0xff;
1435 sc->rt_mono.amounts_left[7] = 0xff;
1436 if (mixer_init(dev, &emudspmixer_class, sc)) {
1437 device_printf(dev, "failed to initialize mixer\n");
1442 if (mixer_init(dev, &emuefxmixer_class, sc)) {
1443 device_printf(dev, "failed to initialize EFX mixer\n");
1448 device_printf(dev, "invalid default route\n");
1452 inte = EMU_INTE_INTERTIMERENB;
1453 ipr = EMU_IPR_INTERVALTIMER; /* Used by playback & ADC */
1454 sc->ihandle = emu_intr_register(sc->card, inte, ipr, &emu_pcm_intr, sc);
1456 if (emu_pcm_init(sc) == -1) {
1457 device_printf(dev, "unable to initialize PCM part of the card\n");
1462 * We don't register interrupt handler with snd_setup_intr
1463 * in pcm device. Mark pcm device as MPSAFE manually.
1465 pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE);
1467 /* XXX we should better get number of available channels from parent */
1468 if (pcm_register(dev, sc, (route == RT_FRONT) ? MAX_CHANNELS : 1, (route == RT_FRONT) ? 1 : 0)) {
1469 device_printf(dev, "can't register PCM channels!\n");
1473 if (route != RT_MCHRECORD)
1474 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1475 if (route == RT_FRONT) {
1476 for (i = 1; i < MAX_CHANNELS; i++)
1477 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1478 pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc);
1480 if (route == RT_MCHRECORD)
1481 pcm_addchan(dev, PCMDIR_REC, &emufxrchan_class, sc);
1483 ksnprintf(status, SND_STATUSLEN, "on %s",
1484 device_get_nameunit(device_get_parent(dev)));
1485 pcm_setstatus(dev, status);
1491 ac97_destroy(sc->codec);
1493 snd_mtxfree(sc->lock);
1494 kfree(sc, M_DEVBUF);
1499 emu_pcm_detach(device_t dev)
1502 struct emu_pcm_info *sc;
1504 sc = pcm_getdevinfo(dev);
1506 r = pcm_unregister(dev);
1513 snd_mtxfree(sc->lock);
1514 kfree(sc, M_DEVBUF);
1519 static device_method_t emu_pcm_methods[] = {
1520 DEVMETHOD(device_probe, emu_pcm_probe),
1521 DEVMETHOD(device_attach, emu_pcm_attach),
1522 DEVMETHOD(device_detach, emu_pcm_detach),
1527 static driver_t emu_pcm_driver = {
1535 DRIVER_MODULE(snd_emu10kx_pcm, emu10kx, emu_pcm_driver, pcm_devclass, 0, 0);
1536 MODULE_DEPEND(snd_emu10kx_pcm, snd_emu10kx, SND_EMU10KX_MINVER, SND_EMU10KX_PREFVER, SND_EMU10KX_MAXVER);
1537 MODULE_DEPEND(snd_emu10kx_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
1538 MODULE_VERSION(snd_emu10kx_pcm, SND_EMU10KX_PREFVER);