2 * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
3 * Copyright (c) 2003-2006 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
30 #include <sys/param.h>
31 #include <sys/types.h>
33 #include <machine/bus.h>
35 #include <sys/systm.h>
37 #include <sys/queue.h>
38 #include <sys/systm.h>
40 #include <sys/mutex.h>
42 #include <dev/sound/chip.h>
43 #include <dev/sound/pcm/sound.h>
44 #include <dev/sound/pcm/ac97.h>
48 #include "opt_emu10kx.h"
49 #include <dev/sound/pci/emu10kx.h>
50 #include "emu10k1-alsa%diked.h"
52 struct emu_pcm_pchinfo {
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;
65 struct emu_pcm_rchinfo {
77 struct snd_dbuf *buffer;
78 struct pcm_channel *channel;
79 struct emu_pcm_info *pcm;
82 /* XXX Hardware playback channels */
83 #define MAX_CHANNELS 4
86 #error Too many hardware channels defined. 13 is the maximum
91 device_t dev; /* device information */
92 struct snddev_info *devinfo; /* pcm 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;
99 struct emu_route rt_mono;
101 int ihandle; /* interrupt handler */
104 struct ac97_info *codec;
105 uint32_t ac97_state[0x7F];
109 static uint32_t emu_rfmt_adc[] = {
111 AFMT_STEREO | AFMT_S16_LE,
114 static struct pcmchan_caps emu_reccaps_adc = {
115 8000, 48000, emu_rfmt_adc, 0
118 static uint32_t emu_rfmt_efx[] = {
123 static struct pcmchan_caps emu_reccaps_efx_live = {
124 48000*32, 48000*32, emu_rfmt_efx, 0
127 static struct pcmchan_caps emu_reccaps_efx_audigy = {
128 48000*64, 48000*64, emu_rfmt_efx, 0
131 static uint32_t emu_pfmt[] = {
133 AFMT_STEREO | AFMT_U8,
135 AFMT_STEREO | AFMT_S16_LE,
138 static uint32_t emu_pfmt_mono[] = {
144 static struct pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0};
145 static struct pcmchan_caps emu_playcaps_mono = {4000, 48000, emu_pfmt_mono, 0};
147 static int emu10k1_adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000};
148 /* audigy supports 12kHz. */
149 static int emu10k2_adcspeed[9] = {48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000};
151 static uint32_t emu_pcm_intr(void *pcm, uint32_t stat);
153 static const struct emu_dspmix_props {
155 } dspmix [SOUND_MIXER_NRDEVICES] = {
156 [SOUND_MIXER_VOLUME] = {1},
157 [SOUND_MIXER_PCM] = {1},
161 emu_dspmixer_init(struct snd_mixer *m)
167 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
168 if (dspmix[i].present)
173 mix_setrecdevs(m, 0);
178 emu_dspmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
180 struct emu_pcm_info *sc;
182 sc = mix_getdevinfo(m);
185 case SOUND_MIXER_VOLUME:
188 emumix_set_volume(sc->card, M_MASTER_REAR_L, left);
189 emumix_set_volume(sc->card, M_MASTER_REAR_R, right);
192 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2);
195 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2);
199 case SOUND_MIXER_PCM:
202 emumix_set_volume(sc->card, M_FX2_REAR_L, left);
203 emumix_set_volume(sc->card, M_FX3_REAR_R, right);
206 emumix_set_volume(sc->card, M_FX4_CENTER, (left+right)/2);
209 emumix_set_volume(sc->card, M_FX5_SUBWOOFER, (left+right)/2);
214 device_printf(sc->dev, "mixer error: unknown device %d\n", dev);
220 emu_dspmixer_setrecsrc(struct snd_mixer *m __unused, u_int32_t src __unused)
225 static kobj_method_t emudspmixer_methods[] = {
226 KOBJMETHOD(mixer_init, emu_dspmixer_init),
227 KOBJMETHOD(mixer_set, emu_dspmixer_set),
228 KOBJMETHOD(mixer_setrecsrc, emu_dspmixer_setrecsrc),
231 MIXER_DECLARE(emudspmixer);
234 * AC97 emulation code for Audigy and later cards.
235 * Some parts of AC97 codec are not used by hardware, but can be used
236 * to change some DSP controls via AC97 mixer interface. This includes:
237 * - master volume controls MASTER_FRONT_[R|L]
238 * - pcm volume controls FX[0|1]_FRONT_[R|L]
239 * - rec volume controls MASTER_REC_[R|L]
240 * We do it because we need to put it under user control....
241 * We also keep some parts of AC97 disabled to get better sound quality
244 #define AC97LEFT(x) ((x & 0x7F00)>>8)
245 #define AC97RIGHT(x) (x & 0x007F)
246 #define AC97MUTE(x) ((x & 0x8000)>>15)
247 #define BIT4_TO100(x) (100-(x)*100/(0x0f))
248 #define BIT6_TO100(x) (100-(x)*100/(0x3f))
249 #define BIT4_TO255(x) (255-(x)*255/(0x0f))
250 #define BIT6_TO255(x) (255-(x)*255/(0x3f))
251 #define V100_TOBIT6(x) (0x3f*(100-x)/100)
252 #define V100_TOBIT4(x) (0x0f*(100-x)/100)
253 #define AC97ENCODE(x_muted,x_left,x_right) (((x_muted&1)<<15) | ((x_left&0x3f)<<8) | (x_right&0x3f))
256 emu_ac97_read_emulation(struct emu_pcm_info *sc, int regno)
266 case AC97_MIX_MASTER:
267 emulated = sc->ac97_state[AC97_MIX_MASTER];
271 emulated = sc->ac97_state[AC97_MIX_PCM];
274 case AC97_REG_RECSEL:
279 emulated = sc->ac97_state[AC97_MIX_RGAIN];
284 emu_wr(sc->card, AC97ADDRESS, regno, 1);
285 tmp = emu_rd(sc->card, AC97DATA, 2);
294 emu_ac97_write_emulation(struct emu_pcm_info *sc, int regno, uint32_t data)
298 uint32_t emu_left, emu_right;
303 left = AC97LEFT(data);
304 emu_left = BIT6_TO100(left); /* We show us as 6-bit AC97 mixer */
305 right = AC97RIGHT(data);
306 emu_right = BIT6_TO100(right);
307 is_mute = AC97MUTE(data);
309 emu_left = emu_right = 0;
312 /* TODO: reset emulator on AC97_RESET */
313 case AC97_MIX_MASTER:
314 emumix_set_volume(sc->card, M_MASTER_FRONT_L, emu_left);
315 emumix_set_volume(sc->card, M_MASTER_FRONT_R, emu_right);
316 sc->ac97_state[AC97_MIX_MASTER] = data & (0x8000 | 0x3f3f);
317 data = 0x8000; /* Mute AC97 main out */
319 case AC97_MIX_PCM: /* PCM OUT VOL */
320 emumix_set_volume(sc->card, M_FX0_FRONT_L, emu_left);
321 emumix_set_volume(sc->card, M_FX1_FRONT_R, emu_right);
322 sc->ac97_state[AC97_MIX_PCM] = data & (0x8000 | 0x3f3f);
323 data = 0x8000; /* Mute AC97 PCM out */
325 case AC97_REG_RECSEL:
327 * PCM recording source is set to "stereo mix" (labeled "vol"
328 * in mixer) XXX !I can't remember why!
332 case AC97_MIX_RGAIN: /* RECORD GAIN */
333 emu_left = BIT4_TO100(left); /* rgain is 4-bit */
334 emu_right = BIT4_TO100(right);
335 emumix_set_volume(sc->card, M_MASTER_REC_L, 100-emu_left);
336 emumix_set_volume(sc->card, M_MASTER_REC_R, 100-emu_right);
338 * Record gain on AC97 should stay zero to get AC97 sound on
339 * AC97_[RL] connectors on EMU10K2 chip. AC97 on Audigy is not
340 * directly connected to any output, only to EMU10K2 chip Use
341 * this control to set AC97 mix volume inside EMU10K2 chip
343 sc->ac97_state[AC97_MIX_RGAIN] = data & (0x8000 | 0x0f0f);
348 emu_wr(sc->card, AC97ADDRESS, regno, 1);
349 emu_wr(sc->card, AC97DATA, data, 2);
354 emu_erdcd(kobj_t obj __unused, void *devinfo, int regno)
356 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
358 return (emu_ac97_read_emulation(sc, regno));
362 emu_ewrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data)
364 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
366 emu_ac97_write_emulation(sc, regno, data);
370 static kobj_method_t emu_eac97_methods[] = {
371 KOBJMETHOD(ac97_read, emu_erdcd),
372 KOBJMETHOD(ac97_write, emu_ewrcd),
375 AC97_DECLARE(emu_eac97);
377 /* real ac97 codec */
379 emu_rdcd(kobj_t obj __unused, void *devinfo, int regno)
382 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
384 KASSERT(sc->card != NULL, ("emu_rdcd: no soundcard"));
385 emu_wr(sc->card, AC97ADDRESS, regno, 1);
386 rd = emu_rd(sc->card, AC97DATA, 2);
391 emu_wrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data)
393 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
395 KASSERT(sc->card != NULL, ("emu_wrcd: no soundcard"));
396 emu_wr(sc->card, AC97ADDRESS, regno, 1);
397 emu_wr(sc->card, AC97DATA, data, 2);
401 static kobj_method_t emu_ac97_methods[] = {
402 KOBJMETHOD(ac97_read, emu_rdcd),
403 KOBJMETHOD(ac97_write, emu_wrcd),
406 AC97_DECLARE(emu_ac97);
410 emu_k1_recval(int speed)
415 while ((val < 7) && (speed < emu10k1_adcspeed[val]))
417 if (val == 6) val=5; /* XXX 8kHz does not work */
422 emu_k2_recval(int speed)
427 while ((val < 8) && (speed < emu10k2_adcspeed[val]))
429 if (val == 7) val=6; /* XXX 8kHz does not work */
434 emupchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
436 struct emu_pcm_info *sc = devinfo;
437 struct emu_pcm_pchinfo *ch;
440 KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction"));
441 KASSERT(sc->card != NULL, ("empchan_init: no soundcard"));
444 if (sc->pnum >= MAX_CHANNELS)
446 ch = &(sc->pch[sc->pnum++]);
450 ch->blksz = sc->bufsz;
453 ch->master = emu_valloc(sc->card);
455 * XXX we have to allocate slave even for mono channel until we
456 * fix emu_vfree to handle this case.
458 ch->slave = emu_valloc(sc->card);
459 ch->timer = emu_timer_create(sc->card);
460 r = (emu_vinit(sc->card, ch->master, ch->slave, EMU_PLAY_BUFSZ, ch->buffer)) ? NULL : ch;
465 emupchan_free(kobj_t obj __unused, void *c_devinfo)
467 struct emu_pcm_pchinfo *ch = c_devinfo;
468 struct emu_pcm_info *sc = ch->pcm;
470 emu_timer_clear(sc->card, ch->timer);
471 if (ch->slave != NULL)
472 emu_vfree(sc->card, ch->slave);
473 emu_vfree(sc->card, ch->master);
478 emupchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format)
480 struct emu_pcm_pchinfo *ch = c_devinfo;
487 emupchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
489 struct emu_pcm_pchinfo *ch = c_devinfo;
496 emupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
498 struct emu_pcm_pchinfo *ch = c_devinfo;
499 struct emu_pcm_info *sc = ch->pcm;
501 if (blocksize > ch->pcm->bufsz)
502 blocksize = ch->pcm->bufsz;
503 snd_mtxlock(sc->lock);
504 ch->blksz = blocksize;
505 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getbps(ch->buffer));
506 snd_mtxunlock(sc->lock);
511 emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
513 struct emu_pcm_pchinfo *ch = c_devinfo;
514 struct emu_pcm_info *sc = ch->pcm;
516 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
518 snd_mtxlock(sc->lock); /* XXX can we trigger on parallel threads ? */
519 if (go == PCMTRIG_START) {
520 emu_vsetup(ch->master, ch->fmt, ch->spd);
521 if ((ch->fmt & AFMT_STEREO) == AFMT_STEREO)
522 emu_vroute(sc->card, &(sc->rt), ch->master);
524 emu_vroute(sc->card, &(sc->rt_mono), ch->master);
525 emu_vwrite(sc->card, ch->master);
526 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getbps(ch->buffer));
527 emu_timer_enable(sc->card, ch->timer, 1);
529 /* PCM interrupt handler will handle PCMTRIG_STOP event */
530 ch->run = (go == PCMTRIG_START) ? 1 : 0;
531 emu_vtrigger(sc->card, ch->master, ch->run);
532 snd_mtxunlock(sc->lock);
537 emupchan_getptr(kobj_t obj __unused, void *c_devinfo)
539 struct emu_pcm_pchinfo *ch = c_devinfo;
540 struct emu_pcm_info *sc = ch->pcm;
543 r = emu_vpos(sc->card, ch->master);
548 static struct pcmchan_caps *
549 emupchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused)
551 struct emu_pcm_pchinfo *ch = c_devinfo;
552 struct emu_pcm_info *sc = ch->pcm;
560 return (&emu_playcaps);
565 return (&emu_playcaps_mono);
571 static kobj_method_t emupchan_methods[] = {
572 KOBJMETHOD(channel_init, emupchan_init),
573 KOBJMETHOD(channel_free, emupchan_free),
574 KOBJMETHOD(channel_setformat, emupchan_setformat),
575 KOBJMETHOD(channel_setspeed, emupchan_setspeed),
576 KOBJMETHOD(channel_setblocksize, emupchan_setblocksize),
577 KOBJMETHOD(channel_trigger, emupchan_trigger),
578 KOBJMETHOD(channel_getptr, emupchan_getptr),
579 KOBJMETHOD(channel_getcaps, emupchan_getcaps),
582 CHANNEL_DECLARE(emupchan);
585 emurchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
587 struct emu_pcm_info *sc = devinfo;
588 struct emu_pcm_rchinfo *ch;
590 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
595 ch->blksz = sc->bufsz / 2; /* We rise interrupt for half-full buffer */
598 ch->idxreg = sc->is_emu10k1 ? ADCIDX : A_ADCIDX;
601 ch->setupreg = ADCCR;
602 ch->irqmask = INTE_ADCBUFENABLE;
603 ch->iprmask = IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL;
605 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
608 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
609 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
615 emurchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format)
617 struct emu_pcm_rchinfo *ch = c_devinfo;
624 emurchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
626 struct emu_pcm_rchinfo *ch = c_devinfo;
628 if (ch->pcm->is_emu10k1) {
629 speed = emu10k1_adcspeed[emu_k1_recval(speed)];
631 speed = emu10k2_adcspeed[emu_k2_recval(speed)];
638 emurchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
640 struct emu_pcm_rchinfo *ch = c_devinfo;
642 ch->blksz = blocksize;
643 /* If blocksize is less than half of buffer size we will not get
644 interrupt in time and channel will die due to interrupt timeout */
645 if(ch->blksz < (ch->pcm->bufsz / 2))
646 ch->blksz = ch->pcm->bufsz / 2;
651 emurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
653 struct emu_pcm_rchinfo *ch = c_devinfo;
654 struct emu_pcm_info *sc = ch->pcm;
659 sz = ADCBS_BUFSIZE_4096;
662 sz = ADCBS_BUFSIZE_8192;
665 sz = ADCBS_BUFSIZE_16384;
668 sz = ADCBS_BUFSIZE_32768;
671 sz = ADCBS_BUFSIZE_65536;
674 sz = ADCBS_BUFSIZE_4096;
677 snd_mtxlock(sc->lock);
681 emu_wrptr(sc->card, 0, ch->sizereg, sz);
682 val = sc->is_emu10k1 ? ADCCR_LCHANENABLE : A_ADCCR_LCHANENABLE;
683 if (ch->fmt & AFMT_STEREO)
684 val |= sc->is_emu10k1 ? ADCCR_RCHANENABLE : A_ADCCR_RCHANENABLE;
685 val |= sc->is_emu10k1 ? emu_k1_recval(ch->spd) : emu_k2_recval(ch->spd);
686 emu_wrptr(sc->card, 0, ch->setupreg, 0);
687 emu_wrptr(sc->card, 0, ch->setupreg, val);
688 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc);
694 emu_wrptr(sc->card, 0, ch->sizereg, 0);
696 emu_wrptr(sc->card, 0, ch->setupreg, 0);
697 (void)emu_intr_unregister(sc->card, ch->ihandle);
699 case PCMTRIG_EMLDMAWR:
701 case PCMTRIG_EMLDMARD:
706 snd_mtxunlock(sc->lock);
712 emurchan_getptr(kobj_t obj __unused, void *c_devinfo)
714 struct emu_pcm_rchinfo *ch = c_devinfo;
715 struct emu_pcm_info *sc = ch->pcm;
718 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff;
723 static struct pcmchan_caps *
724 emurchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused)
726 return (&emu_reccaps_adc);
729 static kobj_method_t emurchan_methods[] = {
730 KOBJMETHOD(channel_init, emurchan_init),
731 KOBJMETHOD(channel_setformat, emurchan_setformat),
732 KOBJMETHOD(channel_setspeed, emurchan_setspeed),
733 KOBJMETHOD(channel_setblocksize, emurchan_setblocksize),
734 KOBJMETHOD(channel_trigger, emurchan_trigger),
735 KOBJMETHOD(channel_getptr, emurchan_getptr),
736 KOBJMETHOD(channel_getcaps, emurchan_getcaps),
739 CHANNEL_DECLARE(emurchan);
742 emufxrchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
744 struct emu_pcm_info *sc = devinfo;
745 struct emu_pcm_rchinfo *ch;
747 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
749 if (sc == NULL) return (NULL);
752 ch->fmt = AFMT_S16_LE;
753 ch->spd = sc->is_emu10k1 ? 48000*32 : 48000 * 64;
757 ch->irqmask = INTE_EFXBUFENABLE;
758 ch->iprmask = IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL;
762 ch->blksz = sc->bufsz;
764 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
767 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
768 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
774 emufxrchan_setformat(kobj_t obj __unused, void *c_devinfo __unused, uint32_t format)
776 if (format == AFMT_S16_LE) return (0);
781 emufxrchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
783 struct emu_pcm_rchinfo *ch = c_devinfo;
785 /* FIXED RATE CHANNEL */
790 emufxrchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
792 struct emu_pcm_rchinfo *ch = c_devinfo;
794 ch->blksz = blocksize;
795 /* If blocksize is less than half of buffer size we will not get
796 interrupt in time and channel will die due to interrupt timeout */
797 if(ch->blksz < (ch->pcm->bufsz / 2))
798 ch->blksz = ch->pcm->bufsz / 2;
803 emufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
805 struct emu_pcm_rchinfo *ch = c_devinfo;
806 struct emu_pcm_info *sc = ch->pcm;
811 sz = ADCBS_BUFSIZE_4096;
814 sz = ADCBS_BUFSIZE_8192;
817 sz = ADCBS_BUFSIZE_16384;
820 sz = ADCBS_BUFSIZE_32768;
823 sz = ADCBS_BUFSIZE_65536;
826 sz = ADCBS_BUFSIZE_4096;
829 snd_mtxlock(sc->lock);
833 emu_wrptr(sc->card, 0, ch->sizereg, sz);
834 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc);
836 SB Live! is limited to 32 mono channels. Audigy
837 has 64 mono channels, each of them is selected from
838 one of two A_FXWC[1|2] registers.
840 /* XXX there is no way to demultiplex this streams for now */
842 emu_wrptr(sc->card, 0, FXWC, 0xffffffff);
844 emu_wrptr(sc->card, 0, A_FXWC1, 0xffffffff);
845 emu_wrptr(sc->card, 0, A_FXWC2, 0xffffffff);
853 emu_wrptr(sc->card, 0, FXWC, 0x0);
855 emu_wrptr(sc->card, 0, A_FXWC1, 0x0);
856 emu_wrptr(sc->card, 0, A_FXWC2, 0x0);
858 emu_wrptr(sc->card, 0, ch->sizereg, 0);
859 (void)emu_intr_unregister(sc->card, ch->ihandle);
861 case PCMTRIG_EMLDMAWR:
863 case PCMTRIG_EMLDMARD:
868 snd_mtxunlock(sc->lock);
874 emufxrchan_getptr(kobj_t obj __unused, void *c_devinfo)
876 struct emu_pcm_rchinfo *ch = c_devinfo;
877 struct emu_pcm_info *sc = ch->pcm;
880 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff;
885 static struct pcmchan_caps *
886 emufxrchan_getcaps(kobj_t obj __unused, void *c_devinfo)
888 struct emu_pcm_rchinfo *ch = c_devinfo;
889 struct emu_pcm_info *sc = ch->pcm;
892 return (&emu_reccaps_efx_live);
893 return (&emu_reccaps_efx_audigy);
897 static kobj_method_t emufxrchan_methods[] = {
898 KOBJMETHOD(channel_init, emufxrchan_init),
899 KOBJMETHOD(channel_setformat, emufxrchan_setformat),
900 KOBJMETHOD(channel_setspeed, emufxrchan_setspeed),
901 KOBJMETHOD(channel_setblocksize, emufxrchan_setblocksize),
902 KOBJMETHOD(channel_trigger, emufxrchan_trigger),
903 KOBJMETHOD(channel_getptr, emufxrchan_getptr),
904 KOBJMETHOD(channel_getcaps, emufxrchan_getcaps),
907 CHANNEL_DECLARE(emufxrchan);
911 emu_pcm_intr(void *pcm, uint32_t stat)
913 struct emu_pcm_info *sc = (struct emu_pcm_info *)pcm;
919 if (stat & IPR_INTERVALTIMER) {
920 ack |= IPR_INTERVALTIMER;
921 for (i = 0; i < MAX_CHANNELS; i++)
922 if (sc->pch[i].channel) {
923 if (sc->pch[i].run == 1)
924 chn_intr(sc->pch[i].channel);
926 emu_timer_enable(sc->card, sc->pch[i].timer, 0);
931 if (stat & (IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL)) {
932 ack |= stat & (IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL);
933 if (sc->rch_adc.channel)
934 chn_intr(sc->rch_adc.channel);
937 if (stat & (IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL)) {
938 ack |= stat & (IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL);
939 if (sc->rch_efx.channel)
940 chn_intr(sc->rch_efx.channel);
946 emu_pcm_init(struct emu_pcm_info *sc)
948 sc->bufsz = pcm_getbuffersize(sc->dev, EMUPAGESIZE, EMU_REC_BUFSZ, EMU_MAX_BUFSZ);
953 emu_pcm_uninit(struct emu_pcm_info *sc __unused)
959 emu_pcm_probe(device_t dev)
961 uintptr_t func, route, r;
965 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_FUNC, &func);
971 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route);
989 rt = "multichannel recording";
993 snprintf(buffer, 255, "EMU10Kx DSP %s PCM interface", rt);
994 device_set_desc_copy(dev, buffer);
999 emu_pcm_attach(device_t dev)
1001 struct emu_pcm_info *sc;
1003 char status[SND_STATUSLEN];
1005 uintptr_t route, r, is_emu10k1;
1007 if ((sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
1008 device_printf(dev, "cannot allocate softc\n");
1011 bzero(sc, sizeof(*sc));
1013 sc->card = (struct emu_sc_info *)(device_get_softc(device_get_parent(dev)));
1014 if (sc->card == NULL) {
1015 device_printf(dev, "cannot get bridge conf\n");
1019 sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10kx softc");
1022 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ISEMU10K1, &is_emu10k1);
1023 sc->is_emu10k1 = is_emu10k1 ? 1 : 0;
1027 for (i = 0; i < 8; i++) {
1028 sc->rt.routing_left[i] = i;
1029 sc->rt.amounts_left[i] = 0x00;
1030 sc->rt.routing_right[i] = i;
1031 sc->rt.amounts_right[i] = 0x00;
1034 for (i = 0; i < 8; i++) {
1035 sc->rt_mono.routing_left[i] = i;
1036 sc->rt_mono.amounts_left[i] = 0x00;
1037 sc->rt_mono.routing_right[i] = i;
1038 sc->rt_mono.amounts_right[i] = 0x00;
1041 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route);
1045 sc->rt.amounts_left[0] = 0xff;
1046 sc->rt.amounts_right[1] = 0xff;
1047 sc->rt_mono.amounts_left[0] = 0xff;
1048 sc->rt_mono.amounts_left[1] = 0xff;
1050 sc->codec = AC97_CREATE(dev, sc, emu_ac97);
1052 sc->codec = AC97_CREATE(dev, sc, emu_eac97);
1053 if (sc->codec == NULL) {
1054 if (mixer_init(dev, &emudspmixer_class, sc)) {
1055 device_printf(dev, "failed to initialize DSP mixer\n");
1059 if (mixer_init(dev, ac97_getmixerclass(), sc->codec) == -1) {
1060 device_printf(dev, "can't initialize AC97 mixer!\n");
1065 sc->rt.amounts_left[2] = 0xff;
1066 sc->rt.amounts_right[3] = 0xff;
1067 sc->rt_mono.amounts_left[2] = 0xff;
1068 sc->rt_mono.amounts_left[3] = 0xff;
1069 if (mixer_init(dev, &emudspmixer_class, sc)) {
1070 device_printf(dev, "failed to initialize mixer\n");
1075 sc->rt.amounts_left[4] = 0xff;
1076 sc->rt_mono.amounts_left[4] = 0xff;
1077 if (mixer_init(dev, &emudspmixer_class, sc)) {
1078 device_printf(dev, "failed to initialize mixer\n");
1083 sc->rt.amounts_left[5] = 0xff;
1084 sc->rt_mono.amounts_left[5] = 0xff;
1085 if (mixer_init(dev, &emudspmixer_class, sc)) {
1086 device_printf(dev, "failed to initialize mixer\n");
1091 sc->rt.amounts_left[6] = 0xff;
1092 sc->rt.amounts_right[7] = 0xff;
1093 sc->rt_mono.amounts_left[6] = 0xff;
1094 sc->rt_mono.amounts_left[7] = 0xff;
1095 if (mixer_init(dev, &emudspmixer_class, sc)) {
1096 device_printf(dev, "failed to initialize mixer\n");
1101 /* XXX add mixer here */
1104 device_printf(dev, "invalid default route\n");
1108 inte = INTE_INTERVALTIMERENB;
1109 ipr = IPR_INTERVALTIMER; /* Used by playback */
1110 sc->ihandle = emu_intr_register(sc->card, inte, ipr, &emu_pcm_intr, sc);
1112 if (emu_pcm_init(sc) == -1) {
1113 device_printf(dev, "unable to initialize PCM part of the card\n");
1117 /* XXX we should better get number of available channels from parent */
1118 if (pcm_register(dev, sc, (route == RT_FRONT) ? MAX_CHANNELS : 1, (route == RT_FRONT) ? 1 : 0)) {
1119 device_printf(dev, "can't register PCM channels!\n");
1123 if (route != RT_MCHRECORD)
1124 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1125 if (route == RT_FRONT) {
1126 for (i = 1; i < MAX_CHANNELS; i++)
1127 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1128 pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc);
1130 if (route == RT_MCHRECORD)
1131 pcm_addchan(dev, PCMDIR_REC, &emufxrchan_class, sc);
1133 snprintf(status, SND_STATUSLEN, "on %s", device_get_nameunit(device_get_parent(dev)));
1134 pcm_setstatus(dev, status);
1140 ac97_destroy(sc->codec);
1142 snd_mtxfree(sc->lock);
1148 emu_pcm_detach(device_t dev)
1151 struct emu_pcm_info *sc;
1153 sc = pcm_getdevinfo(dev);
1155 r = pcm_unregister(dev);
1162 snd_mtxfree(sc->lock);
1168 static device_method_t emu_pcm_methods[] = {
1169 DEVMETHOD(device_probe, emu_pcm_probe),
1170 DEVMETHOD(device_attach, emu_pcm_attach),
1171 DEVMETHOD(device_detach, emu_pcm_detach),
1176 static driver_t emu_pcm_driver = {
1184 DRIVER_MODULE(snd_emu10kx_pcm, emu10kx, emu_pcm_driver, pcm_devclass, 0, 0);
1185 MODULE_DEPEND(snd_emu10kx_pcm, snd_emu10kx, SND_EMU10KX_MINVER, SND_EMU10KX_PREFVER, SND_EMU10KX_MAXVER);
1186 MODULE_DEPEND(snd_emu10kx_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
1187 MODULE_VERSION(snd_emu10kx_pcm, SND_EMU10KX_PREFVER);