sys/dev/sound/pci/emu10kx-pcm.c

   1 /*-
   2  * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
   3  * Copyright (c) 2003-2006 Yuriy Tsibizov <yuriy.tsibizov@gfk.ru>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29
  30 #include <sys/param.h>
  31 #include <sys/types.h>
  32 #include <sys/bus.h>
  33 #include <machine/bus.h>
  34 #include <sys/rman.h>
  35 #include <sys/systm.h>
  36 #include <sys/sbuf.h>
  37 #include <sys/queue.h>
  38 #include <sys/systm.h>
  39 #include <sys/lock.h>
  40 #include <sys/mutex.h>
  41
  42 #include <dev/sound/chip.h>
  43 #include <dev/sound/pcm/sound.h>
  44 #include <dev/sound/pcm/ac97.h>
  45
  46 #include "mixer_if.h"
  47
  48 #include "opt_emu10kx.h"
  49 #include <dev/sound/pci/emu10kx.h>
  50 #include "emu10k1-alsa%diked.h"
  51
  52 struct emu_pcm_pchinfo {
  53         int             spd;
  54         int             fmt;
  55         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         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 };
  81
  82 /* XXX Hardware playback channels */
  83 #define MAX_CHANNELS    4
  84
  85 #if MAX_CHANNELS > 13
  86 #error  Too many hardware channels defined. 13 is the maximum
  87 #endif
  88
  89 struct emu_pcm_info {
  90         struct mtx              *lock;
  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;
  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 };
 107
 108
 109 static uint32_t emu_rfmt_adc[] = {
 110         AFMT_S16_LE,
 111         AFMT_STEREO | AFMT_S16_LE,
 112         0
 113 };
 114 static struct pcmchan_caps emu_reccaps_adc = {
 115         8000, 48000, emu_rfmt_adc, 0
 116 };
 117
 118 static uint32_t emu_rfmt_efx[] = {
 119         AFMT_S16_LE,
 120         0
 121 };
 122
 123 static struct pcmchan_caps emu_reccaps_efx_live = {
 124         48000*32, 48000*32, emu_rfmt_efx, 0
 125 };
 126
 127 static struct pcmchan_caps emu_reccaps_efx_audigy = {
 128         48000*64, 48000*64, emu_rfmt_efx, 0
 129 };
 130
 131 static uint32_t emu_pfmt[] = {
 132         AFMT_U8,
 133         AFMT_STEREO | AFMT_U8,
 134         AFMT_S16_LE,
 135         AFMT_STEREO | AFMT_S16_LE,
 136         0
 137 };
 138 static uint32_t emu_pfmt_mono[] = {
 139         AFMT_U8,
 140         AFMT_S16_LE,
 141         0
 142 };
 143
 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};
 146
 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};
 150
 151 static uint32_t emu_pcm_intr(void *pcm, uint32_t stat);
 152
 153 static const struct emu_dspmix_props {
 154         u_int8_t        present;
 155 } dspmix [SOUND_MIXER_NRDEVICES] = {
 156         [SOUND_MIXER_VOLUME] =  {1},
 157         [SOUND_MIXER_PCM] =     {1},
 158 };
 159
 160 static int
 161 emu_dspmixer_init(struct snd_mixer *m)
 162 {
 163         int i;
 164         int v;
 165
 166         v = 0;
 167         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 168                 if (dspmix[i].present)
 169                         v |= 1 << i;
 170         }
 171         mix_setdevs(m, v);
 172
 173         mix_setrecdevs(m, 0);
 174         return (0);
 175 }
 176
 177 static int
 178 emu_dspmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
 179 {
 180         struct emu_pcm_info *sc;
 181
 182         sc = mix_getdevinfo(m);
 183
 184         switch (dev) {
 185         case SOUND_MIXER_VOLUME:
 186                 switch (sc->route) {
 187                 case RT_REAR:
 188                         emumix_set_volume(sc->card, M_MASTER_REAR_L, left);
 189                         emumix_set_volume(sc->card, M_MASTER_REAR_R, right);
 190                         break;
 191                 case RT_CENTER:
 192                         emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2);
 193                         break;
 194                 case RT_SUB:
 195                         emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2);
 196                         break;
 197                 }
 198                 break;
 199         case SOUND_MIXER_PCM:
 200                 switch (sc->route) {
 201                 case RT_REAR:
 202                         emumix_set_volume(sc->card, M_FX2_REAR_L, left);
 203                         emumix_set_volume(sc->card, M_FX3_REAR_R, right);
 204                         break;
 205                 case RT_CENTER:
 206                         emumix_set_volume(sc->card, M_FX4_CENTER, (left+right)/2);
 207                         break;
 208                 case RT_SUB:
 209                         emumix_set_volume(sc->card, M_FX5_SUBWOOFER, (left+right)/2);
 210                         break;
 211                 }
 212                 break;
 213         default:
 214                 device_printf(sc->dev, "mixer error: unknown device %d\n", dev);
 215         }
 216         return  (0);
 217 }
 218
 219 static int
 220 emu_dspmixer_setrecsrc(struct snd_mixer *m __unused, u_int32_t src __unused)
 221 {
 222         return (0);
 223 }
 224
 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),
 229         { 0, 0 }
 230 };
 231 MIXER_DECLARE(emudspmixer);
 232
 233 /*
 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
 242  */
 243
 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))
 254
 255 static int
 256 emu_ac97_read_emulation(struct emu_pcm_info *sc, int regno)
 257 {
 258         int use_ac97;
 259         int emulated;
 260         int tmp;
 261
 262         use_ac97 = 1;
 263         emulated = 0;
 264
 265         switch (regno) {
 266         case AC97_MIX_MASTER:
 267                 emulated = sc->ac97_state[AC97_MIX_MASTER];
 268                 use_ac97 = 0;
 269                 break;
 270         case AC97_MIX_PCM:
 271                 emulated = sc->ac97_state[AC97_MIX_PCM];
 272                 use_ac97 = 0;
 273                 break;
 274         case AC97_REG_RECSEL:
 275                 emulated = 0x0505;
 276                 use_ac97 = 0;
 277                 break;
 278         case AC97_MIX_RGAIN:
 279                 emulated = sc->ac97_state[AC97_MIX_RGAIN];
 280                 use_ac97 = 0;
 281                 break;
 282         }
 283
 284         emu_wr(sc->card, AC97ADDRESS, regno, 1);
 285         tmp = emu_rd(sc->card, AC97DATA, 2);
 286
 287         if (use_ac97)
 288                 emulated = tmp;
 289
 290         return (emulated);
 291 }
 292
 293 static void
 294 emu_ac97_write_emulation(struct emu_pcm_info *sc, int regno, uint32_t data)
 295 {
 296         int write_ac97;
 297         int left, right;
 298         uint32_t emu_left, emu_right;
 299         int is_mute;
 300
 301         write_ac97 = 1;
 302
 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);
 308         if (is_mute)
 309                 emu_left = emu_right = 0;
 310
 311         switch (regno) {
 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 */
 318                 break;
 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 */
 324                 break;
 325         case AC97_REG_RECSEL:
 326                 /*
 327                  * PCM recording source is set to "stereo mix" (labeled "vol"
 328                  * in mixer) XXX !I can't remember why!
 329                  */
 330                 data = 0x0505;
 331                 break;
 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);
 337                 /*
 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
 342                  */
 343                 sc->ac97_state[AC97_MIX_RGAIN] = data & (0x8000 | 0x0f0f);
 344                 data = 0x0000;
 345                 break;
 346         }
 347         if (write_ac97) {
 348                 emu_wr(sc->card, AC97ADDRESS, regno, 1);
 349                 emu_wr(sc->card, AC97DATA, data, 2);
 350         }
 351 }
 352
 353 static int
 354 emu_erdcd(kobj_t obj __unused, void *devinfo, int regno)
 355 {
 356         struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
 357
 358         return (emu_ac97_read_emulation(sc, regno));
 359 }
 360
 361 static int
 362 emu_ewrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data)
 363 {
 364         struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
 365
 366         emu_ac97_write_emulation(sc, regno, data);
 367         return (0);
 368 }
 369
 370 static kobj_method_t emu_eac97_methods[] = {
 371         KOBJMETHOD(ac97_read, emu_erdcd),
 372         KOBJMETHOD(ac97_write, emu_ewrcd),
 373         {0, 0}
 374 };
 375 AC97_DECLARE(emu_eac97);
 376
 377 /* real ac97 codec */
 378 static int
 379 emu_rdcd(kobj_t obj __unused, void *devinfo, int regno)
 380 {
 381         int rd;
 382         struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
 383
 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);
 387         return (rd);
 388 }
 389
 390 static int
 391 emu_wrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data)
 392 {
 393         struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo;
 394
 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);
 398         return (0);
 399 }
 400
 401 static kobj_method_t emu_ac97_methods[] = {
 402         KOBJMETHOD(ac97_read, emu_rdcd),
 403         KOBJMETHOD(ac97_write, emu_wrcd),
 404         {0, 0}
 405 };
 406 AC97_DECLARE(emu_ac97);
 407
 408
 409 static int
 410 emu_k1_recval(int speed)
 411 {
 412         int val;
 413
 414         val = 0;
 415         while ((val < 7) && (speed < emu10k1_adcspeed[val]))
 416                 val++;
 417         if (val == 6) val=5; /* XXX 8kHz does not work */
 418         return (val);
 419 }
 420
 421 static int
 422 emu_k2_recval(int speed)
 423 {
 424         int val;
 425
 426         val = 0;
 427         while ((val < 8) && (speed < emu10k2_adcspeed[val]))
 428                 val++;
 429         if (val == 7) val=6; /* XXX 8kHz does not work */
 430         return (val);
 431 }
 432
 433 static void *
 434 emupchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
 435 {
 436         struct emu_pcm_info *sc = devinfo;
 437         struct emu_pcm_pchinfo *ch;
 438         void *r;
 439
 440         KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction"));
 441         KASSERT(sc->card != NULL, ("empchan_init: no soundcard"));
 442
 443
 444         if (sc->pnum >= MAX_CHANNELS)
 445                 return (NULL);
 446         ch = &(sc->pch[sc->pnum++]);
 447         ch->buffer = b;
 448         ch->pcm = sc;
 449         ch->channel = c;
 450         ch->blksz = sc->bufsz;
 451         ch->fmt = AFMT_U8;
 452         ch->spd = 8000;
 453         ch->master = emu_valloc(sc->card);
 454         /*
 455          * XXX we have to allocate slave even for mono channel until we
 456          * fix emu_vfree to handle this case.
 457          */
 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;
 461         return (r);
 462 }
 463
 464 static int
 465 emupchan_free(kobj_t obj __unused, void *c_devinfo)
 466 {
 467         struct emu_pcm_pchinfo *ch = c_devinfo;
 468         struct emu_pcm_info *sc = ch->pcm;
 469
 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);
 474         return (0);
 475 }
 476
 477 static int
 478 emupchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format)
 479 {
 480         struct emu_pcm_pchinfo *ch = c_devinfo;
 481
 482         ch->fmt = format;
 483         return (0);
 484 }
 485
 486 static int
 487 emupchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
 488 {
 489         struct emu_pcm_pchinfo *ch = c_devinfo;
 490
 491         ch->spd = speed;
 492         return (ch->spd);
 493 }
 494
 495 static int
 496 emupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
 497 {
 498         struct emu_pcm_pchinfo *ch = c_devinfo;
 499         struct emu_pcm_info *sc = ch->pcm;
 500
 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);
 507         return (blocksize);
 508 }
 509
 510 static int
 511 emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 512 {
 513         struct emu_pcm_pchinfo *ch = c_devinfo;
 514         struct emu_pcm_info *sc = ch->pcm;
 515
 516         if (!PCMTRIG_COMMON(go))
 517                 return (0);
 518
 519         snd_mtxlock(sc->lock); /* XXX can we trigger on parallel threads ? */
 520         if (go == PCMTRIG_START) {
 521                 emu_vsetup(ch->master, ch->fmt, ch->spd);
 522                 if ((ch->fmt & AFMT_STEREO) == AFMT_STEREO)
 523                         emu_vroute(sc->card, &(sc->rt), ch->master);
 524                 else
 525                         emu_vroute(sc->card, &(sc->rt_mono), ch->master);
 526                 emu_vwrite(sc->card, ch->master);
 527                 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getbps(ch->buffer));
 528                 emu_timer_enable(sc->card, ch->timer, 1);
 529         }
 530         /* PCM interrupt handler will handle PCMTRIG_STOP event */
 531         ch->run = (go == PCMTRIG_START) ? 1 : 0;
 532         emu_vtrigger(sc->card, ch->master, ch->run);
 533         snd_mtxunlock(sc->lock);
 534         return (0);
 535 }
 536
 537 static int
 538 emupchan_getptr(kobj_t obj __unused, void *c_devinfo)
 539 {
 540         struct emu_pcm_pchinfo *ch = c_devinfo;
 541         struct emu_pcm_info *sc = ch->pcm;
 542         int r;
 543
 544         r = emu_vpos(sc->card, ch->master);
 545
 546         return (r);
 547 }
 548
 549 static struct pcmchan_caps *
 550 emupchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused)
 551 {
 552         struct emu_pcm_pchinfo *ch = c_devinfo;
 553         struct emu_pcm_info *sc = ch->pcm;
 554
 555         switch (sc->route) {
 556         case RT_FRONT:
 557                 /* FALLTHROUGH */
 558         case RT_REAR:
 559                 /* FALLTHROUGH */
 560         case RT_SIDE:
 561                 return (&emu_playcaps);
 562                 break;
 563         case RT_CENTER:
 564                 /* FALLTHROUGH */
 565         case RT_SUB:
 566                 return (&emu_playcaps_mono);
 567                 break;
 568         }
 569         return (NULL);
 570 }
 571
 572 static kobj_method_t emupchan_methods[] = {
 573         KOBJMETHOD(channel_init, emupchan_init),
 574         KOBJMETHOD(channel_free, emupchan_free),
 575         KOBJMETHOD(channel_setformat, emupchan_setformat),
 576         KOBJMETHOD(channel_setspeed, emupchan_setspeed),
 577         KOBJMETHOD(channel_setblocksize, emupchan_setblocksize),
 578         KOBJMETHOD(channel_trigger, emupchan_trigger),
 579         KOBJMETHOD(channel_getptr, emupchan_getptr),
 580         KOBJMETHOD(channel_getcaps, emupchan_getcaps),
 581         {0, 0}
 582 };
 583 CHANNEL_DECLARE(emupchan);
 584
 585 static void *
 586 emurchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
 587 {
 588         struct emu_pcm_info *sc = devinfo;
 589         struct emu_pcm_rchinfo *ch;
 590
 591         KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
 592         ch = &sc->rch_adc;
 593         ch->buffer = b;
 594         ch->pcm = sc;
 595         ch->channel = c;
 596         ch->blksz = sc->bufsz / 2; /* We rise interrupt for half-full buffer */
 597         ch->fmt = AFMT_U8;
 598         ch->spd = 8000;
 599         ch->idxreg = sc->is_emu10k1 ? ADCIDX : A_ADCIDX;
 600         ch->basereg = ADCBA;
 601         ch->sizereg = ADCBS;
 602         ch->setupreg = ADCCR;
 603         ch->irqmask = INTE_ADCBUFENABLE;
 604         ch->iprmask = IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL;
 605
 606         if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
 607                 return (NULL);
 608         else {
 609                 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
 610                 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
 611                 return (ch);
 612         }
 613 }
 614
 615 static int
 616 emurchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format)
 617 {
 618         struct emu_pcm_rchinfo *ch = c_devinfo;
 619
 620         ch->fmt = format;
 621         return (0);
 622 }
 623
 624 static int
 625 emurchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
 626 {
 627         struct emu_pcm_rchinfo *ch = c_devinfo;
 628
 629         if (ch->pcm->is_emu10k1) {
 630                 speed = emu10k1_adcspeed[emu_k1_recval(speed)];
 631         } else {
 632                 speed = emu10k2_adcspeed[emu_k2_recval(speed)];
 633         }
 634         ch->spd = speed;
 635         return (ch->spd);
 636 }
 637
 638 static int
 639 emurchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
 640 {
 641         struct emu_pcm_rchinfo *ch = c_devinfo;
 642
 643         ch->blksz = blocksize;
 644         /* If blocksize is less than half of buffer size we will not get
 645         interrupt in time and channel will die due to interrupt timeout */
 646         if(ch->blksz < (ch->pcm->bufsz / 2))
 647                 ch->blksz = ch->pcm->bufsz / 2;
 648         return (ch->blksz);
 649 }
 650
 651 static int
 652 emurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 653 {
 654         struct emu_pcm_rchinfo *ch = c_devinfo;
 655         struct emu_pcm_info *sc = ch->pcm;
 656         uint32_t val, sz;
 657
 658         if (!PCMTRIG_COMMON(go))
 659                 return (0);
 660
 661         switch (sc->bufsz) {
 662         case 4096:
 663                 sz = ADCBS_BUFSIZE_4096;
 664                 break;
 665         case 8192:
 666                 sz = ADCBS_BUFSIZE_8192;
 667                 break;
 668         case 16384:
 669                 sz = ADCBS_BUFSIZE_16384;
 670                 break;
 671         case 32768:
 672                 sz = ADCBS_BUFSIZE_32768;
 673                 break;
 674         case 65536:
 675                 sz = ADCBS_BUFSIZE_65536;
 676                 break;
 677         default:
 678                 sz = ADCBS_BUFSIZE_4096;
 679         }
 680
 681         snd_mtxlock(sc->lock);
 682         switch (go) {
 683         case PCMTRIG_START:
 684                 ch->run = 1;
 685                 emu_wrptr(sc->card, 0, ch->sizereg, sz);
 686                 val = sc->is_emu10k1 ? ADCCR_LCHANENABLE : A_ADCCR_LCHANENABLE;
 687                 if (ch->fmt & AFMT_STEREO)
 688                         val |= sc->is_emu10k1 ? ADCCR_RCHANENABLE : A_ADCCR_RCHANENABLE;
 689                 val |= sc->is_emu10k1 ? emu_k1_recval(ch->spd) : emu_k2_recval(ch->spd);
 690                 emu_wrptr(sc->card, 0, ch->setupreg, 0);
 691                 emu_wrptr(sc->card, 0, ch->setupreg, val);
 692                 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc);
 693                 break;
 694         case PCMTRIG_STOP:
 695                 /* FALLTHROUGH */
 696         case PCMTRIG_ABORT:
 697                 ch->run = 0;
 698                 emu_wrptr(sc->card, 0, ch->sizereg, 0);
 699                 if (ch->setupreg)
 700                         emu_wrptr(sc->card, 0, ch->setupreg, 0);
 701                 (void)emu_intr_unregister(sc->card, ch->ihandle);
 702                 break;
 703         case PCMTRIG_EMLDMAWR:
 704                 /* FALLTHROUGH */
 705         case PCMTRIG_EMLDMARD:
 706                 /* FALLTHROUGH */
 707         default:
 708                 break;
 709         }
 710         snd_mtxunlock(sc->lock);
 711
 712         return (0);
 713 }
 714
 715 static int
 716 emurchan_getptr(kobj_t obj __unused, void *c_devinfo)
 717 {
 718         struct emu_pcm_rchinfo *ch = c_devinfo;
 719         struct emu_pcm_info *sc = ch->pcm;
 720         int r;
 721
 722         r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff;
 723
 724         return (r);
 725 }
 726
 727 static struct pcmchan_caps *
 728 emurchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused)
 729 {
 730         return (&emu_reccaps_adc);
 731 }
 732
 733 static kobj_method_t emurchan_methods[] = {
 734         KOBJMETHOD(channel_init, emurchan_init),
 735         KOBJMETHOD(channel_setformat, emurchan_setformat),
 736         KOBJMETHOD(channel_setspeed, emurchan_setspeed),
 737         KOBJMETHOD(channel_setblocksize, emurchan_setblocksize),
 738         KOBJMETHOD(channel_trigger, emurchan_trigger),
 739         KOBJMETHOD(channel_getptr, emurchan_getptr),
 740         KOBJMETHOD(channel_getcaps, emurchan_getcaps),
 741         {0, 0}
 742 };
 743 CHANNEL_DECLARE(emurchan);
 744
 745 static void *
 746 emufxrchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused)
 747 {
 748         struct emu_pcm_info *sc = devinfo;
 749         struct emu_pcm_rchinfo *ch;
 750
 751         KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
 752
 753         if (sc == NULL) return (NULL);
 754
 755         ch = &(sc->rch_efx);
 756         ch->fmt = AFMT_S16_LE;
 757         ch->spd = sc->is_emu10k1 ? 48000*32 : 48000 * 64;
 758         ch->idxreg = FXIDX;
 759         ch->basereg = FXBA;
 760         ch->sizereg = FXBS;
 761         ch->irqmask = INTE_EFXBUFENABLE;
 762         ch->iprmask = IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL;
 763         ch->buffer = b;
 764         ch->pcm = sc;
 765         ch->channel = c;
 766         ch->blksz = sc->bufsz;
 767
 768         if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
 769                 return (NULL);
 770         else {
 771                 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
 772                 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
 773                 return (ch);
 774         }
 775 }
 776
 777 static int
 778 emufxrchan_setformat(kobj_t obj __unused, void *c_devinfo __unused, uint32_t format)
 779 {
 780         if (format == AFMT_S16_LE) return (0);
 781         return (-1);
 782 }
 783
 784 static int
 785 emufxrchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed)
 786 {
 787         struct emu_pcm_rchinfo *ch = c_devinfo;
 788
 789         /* FIXED RATE CHANNEL */
 790         return (ch->spd);
 791 }
 792
 793 static int
 794 emufxrchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
 795 {
 796         struct emu_pcm_rchinfo *ch = c_devinfo;
 797
 798         ch->blksz = blocksize;
 799         /* If blocksize is less than half of buffer size we will not get
 800         interrupt in time and channel will die due to interrupt timeout */
 801         if(ch->blksz < (ch->pcm->bufsz / 2))
 802                 ch->blksz = ch->pcm->bufsz / 2;
 803         return (ch->blksz);
 804 }
 805
 806 static int
 807 emufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 808 {
 809         struct emu_pcm_rchinfo *ch = c_devinfo;
 810         struct emu_pcm_info *sc = ch->pcm;
 811         uint32_t sz;
 812
 813         if (!PCMTRIG_COMMON(go))
 814                 return (0);
 815
 816         switch (sc->bufsz) {
 817         case 4096:
 818                 sz = ADCBS_BUFSIZE_4096;
 819                 break;
 820         case 8192:
 821                 sz = ADCBS_BUFSIZE_8192;
 822                 break;
 823         case 16384:
 824                 sz = ADCBS_BUFSIZE_16384;
 825                 break;
 826         case 32768:
 827                 sz = ADCBS_BUFSIZE_32768;
 828                 break;
 829         case 65536:
 830                 sz = ADCBS_BUFSIZE_65536;
 831                 break;
 832         default:
 833                 sz = ADCBS_BUFSIZE_4096;
 834         }
 835
 836         snd_mtxlock(sc->lock);
 837         switch (go) {
 838         case PCMTRIG_START:
 839                 ch->run = 1;
 840                 emu_wrptr(sc->card, 0, ch->sizereg, sz);
 841                 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc);
 842                 /*
 843                  SB Live! is limited to 32 mono channels. Audigy
 844                  has 64 mono channels, each of them is selected from
 845                  one of two A_FXWC[1|2] registers.
 846                  */
 847                 /* XXX there is no way to demultiplex this streams for now */
 848                 if(sc->is_emu10k1) {
 849                         emu_wrptr(sc->card, 0, FXWC, 0xffffffff);
 850                 } else {
 851                         emu_wrptr(sc->card, 0, A_FXWC1, 0xffffffff);
 852                         emu_wrptr(sc->card, 0, A_FXWC2, 0xffffffff);
 853                 }
 854                 break;
 855         case PCMTRIG_STOP:
 856                 /* FALLTHROUGH */
 857         case PCMTRIG_ABORT:
 858                 ch->run = 0;
 859                 if(sc->is_emu10k1) {
 860                         emu_wrptr(sc->card, 0, FXWC, 0x0);
 861                 } else {
 862                         emu_wrptr(sc->card, 0, A_FXWC1, 0x0);
 863                         emu_wrptr(sc->card, 0, A_FXWC2, 0x0);
 864                 }
 865                 emu_wrptr(sc->card, 0, ch->sizereg, 0);
 866                 (void)emu_intr_unregister(sc->card, ch->ihandle);
 867                 break;
 868         case PCMTRIG_EMLDMAWR:
 869                 /* FALLTHROUGH */
 870         case PCMTRIG_EMLDMARD:
 871                 /* FALLTHROUGH */
 872         default:
 873                 break;
 874         }
 875         snd_mtxunlock(sc->lock);
 876
 877         return (0);
 878 }
 879
 880 static int
 881 emufxrchan_getptr(kobj_t obj __unused, void *c_devinfo)
 882 {
 883         struct emu_pcm_rchinfo *ch = c_devinfo;
 884         struct emu_pcm_info *sc = ch->pcm;
 885         int r;
 886
 887         r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff;
 888
 889         return (r);
 890 }
 891
 892 static struct pcmchan_caps *
 893 emufxrchan_getcaps(kobj_t obj __unused, void *c_devinfo)
 894 {
 895         struct emu_pcm_rchinfo *ch = c_devinfo;
 896         struct emu_pcm_info *sc = ch->pcm;
 897
 898         if(sc->is_emu10k1)
 899                 return (&emu_reccaps_efx_live);
 900         return (&emu_reccaps_efx_audigy);
 901
 902 }
 903
 904 static kobj_method_t emufxrchan_methods[] = {
 905         KOBJMETHOD(channel_init, emufxrchan_init),
 906         KOBJMETHOD(channel_setformat, emufxrchan_setformat),
 907         KOBJMETHOD(channel_setspeed, emufxrchan_setspeed),
 908         KOBJMETHOD(channel_setblocksize, emufxrchan_setblocksize),
 909         KOBJMETHOD(channel_trigger, emufxrchan_trigger),
 910         KOBJMETHOD(channel_getptr, emufxrchan_getptr),
 911         KOBJMETHOD(channel_getcaps, emufxrchan_getcaps),
 912         {0, 0}
 913 };
 914 CHANNEL_DECLARE(emufxrchan);
 915
 916
 917 static uint32_t
 918 emu_pcm_intr(void *pcm, uint32_t stat)
 919 {
 920         struct emu_pcm_info *sc = (struct emu_pcm_info *)pcm;
 921         uint32_t ack;
 922         int i;
 923
 924         ack = 0;
 925
 926         if (stat & IPR_INTERVALTIMER) {
 927                 ack |= IPR_INTERVALTIMER;
 928                 for (i = 0; i < MAX_CHANNELS; i++)
 929                         if (sc->pch[i].channel) {
 930                                 if (sc->pch[i].run == 1)
 931                                         chn_intr(sc->pch[i].channel);
 932                                 else
 933                                         emu_timer_enable(sc->card, sc->pch[i].timer, 0);
 934                         }
 935         }
 936
 937
 938         if (stat & (IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL)) {
 939                 ack |= stat & (IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL);
 940                 if (sc->rch_adc.channel)
 941                         chn_intr(sc->rch_adc.channel);
 942         }
 943
 944         if (stat & (IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL)) {
 945                 ack |= stat & (IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL);
 946                 if (sc->rch_efx.channel)
 947                         chn_intr(sc->rch_efx.channel);
 948         }
 949         return (ack);
 950 }
 951
 952 static int
 953 emu_pcm_init(struct emu_pcm_info *sc)
 954 {
 955         sc->bufsz = pcm_getbuffersize(sc->dev, EMUPAGESIZE, EMU_REC_BUFSZ, EMU_MAX_BUFSZ);
 956         return (0);
 957 }
 958
 959 static int
 960 emu_pcm_uninit(struct emu_pcm_info *sc __unused)
 961 {
 962         return (0);
 963 }
 964
 965 static int
 966 emu_pcm_probe(device_t dev)
 967 {
 968         uintptr_t func, route, r;
 969         const char *rt;
 970         char buffer[255];
 971
 972         r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_FUNC, &func);
 973
 974         if (func != SCF_PCM)
 975                 return (ENXIO);
 976
 977         rt = "UNKNOWN";
 978         r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route);
 979         switch (route) {
 980         case RT_FRONT:
 981                 rt = "front";
 982                 break;
 983         case RT_REAR:
 984                 rt = "rear";
 985                 break;
 986         case RT_CENTER:
 987                 rt = "center";
 988                 break;
 989         case RT_SUB:
 990                 rt = "subwoofer";
 991                 break;
 992         case RT_SIDE:
 993                 rt = "side";
 994                 break;
 995         case RT_MCHRECORD:
 996                 rt = "multichannel recording";
 997                 break;
 998         }
 999
1000         snprintf(buffer, 255, "EMU10Kx DSP %s PCM interface", rt);
1001         device_set_desc_copy(dev, buffer);
1002         return (0);
1003 }
1004
1005 static int
1006 emu_pcm_attach(device_t dev)
1007 {
1008         struct emu_pcm_info *sc;
1009         unsigned int i;
1010         char status[SND_STATUSLEN];
1011         uint32_t inte, ipr;
1012         uintptr_t route, r, is_emu10k1;
1013
1014         sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
1015         sc->card = (struct emu_sc_info *)(device_get_softc(device_get_parent(dev)));
1016         if (sc->card == NULL) {
1017                 device_printf(dev, "cannot get bridge conf\n");
1018                 free(sc, M_DEVBUF);
1019                 return (ENXIO);
1020         }
1021
1022         sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10kx softc");
1023         sc->dev = dev;
1024
1025         r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ISEMU10K1, &is_emu10k1);
1026         sc->is_emu10k1 = is_emu10k1 ? 1 : 0;
1027
1028         sc->codec = NULL;
1029
1030         for (i = 0; i < 8; i++) {
1031                 sc->rt.routing_left[i] = i;
1032                 sc->rt.amounts_left[i] = 0x00;
1033                 sc->rt.routing_right[i] = i;
1034                 sc->rt.amounts_right[i] = 0x00;
1035         }
1036
1037         for (i = 0; i < 8; i++) {
1038                 sc->rt_mono.routing_left[i] = i;
1039                 sc->rt_mono.amounts_left[i] = 0x00;
1040                 sc->rt_mono.routing_right[i] = i;
1041                 sc->rt_mono.amounts_right[i] = 0x00;
1042         }
1043
1044         r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route);
1045         sc->route = route;
1046         switch (route) {
1047         case RT_FRONT:
1048                 sc->rt.amounts_left[0] = 0xff;
1049                 sc->rt.amounts_right[1] = 0xff;
1050                 sc->rt_mono.amounts_left[0] = 0xff;
1051                 sc->rt_mono.amounts_left[1] = 0xff;
1052                 if (sc->is_emu10k1)
1053                         sc->codec = AC97_CREATE(dev, sc, emu_ac97);
1054                 else
1055                         sc->codec = AC97_CREATE(dev, sc, emu_eac97);
1056                 if (sc->codec == NULL) {
1057                         if (mixer_init(dev, &emudspmixer_class, sc)) {
1058                                 device_printf(dev, "failed to initialize DSP mixer\n");
1059                                 goto bad;
1060                         }
1061                 } else
1062                         if (mixer_init(dev, ac97_getmixerclass(), sc->codec) == -1) {
1063                                 device_printf(dev, "can't initialize AC97 mixer!\n");
1064                                 goto bad;
1065                         }
1066                 break;
1067         case RT_REAR:
1068                 sc->rt.amounts_left[2] = 0xff;
1069                 sc->rt.amounts_right[3] = 0xff;
1070                 sc->rt_mono.amounts_left[2] = 0xff;
1071                 sc->rt_mono.amounts_left[3] = 0xff;
1072                 if (mixer_init(dev, &emudspmixer_class, sc)) {
1073                         device_printf(dev, "failed to initialize mixer\n");
1074                         goto bad;
1075                 }
1076                 break;
1077         case RT_CENTER:
1078                 sc->rt.amounts_left[4] = 0xff;
1079                 sc->rt_mono.amounts_left[4] = 0xff;
1080                 if (mixer_init(dev, &emudspmixer_class, sc)) {
1081                         device_printf(dev, "failed to initialize mixer\n");
1082                         goto bad;
1083                 }
1084                 break;
1085         case RT_SUB:
1086                 sc->rt.amounts_left[5] = 0xff;
1087                 sc->rt_mono.amounts_left[5] = 0xff;
1088                 if (mixer_init(dev, &emudspmixer_class, sc)) {
1089                         device_printf(dev, "failed to initialize mixer\n");
1090                         goto bad;
1091                 }
1092                 break;
1093         case RT_SIDE:
1094                 sc->rt.amounts_left[6] = 0xff;
1095                 sc->rt.amounts_right[7] = 0xff;
1096                 sc->rt_mono.amounts_left[6] = 0xff;
1097                 sc->rt_mono.amounts_left[7] = 0xff;
1098                 if (mixer_init(dev, &emudspmixer_class, sc)) {
1099                         device_printf(dev, "failed to initialize mixer\n");
1100                         goto bad;
1101                 }
1102                 break;
1103         case RT_MCHRECORD:
1104                         /* XXX add mixer here */
1105                 break;
1106         default:
1107                 device_printf(dev, "invalid default route\n");
1108                 goto bad;
1109         }
1110
1111         inte = INTE_INTERVALTIMERENB;
1112         ipr = IPR_INTERVALTIMER; /* Used by playback */
1113         sc->ihandle = emu_intr_register(sc->card, inte, ipr, &emu_pcm_intr, sc);
1114
1115         if (emu_pcm_init(sc) == -1) {
1116                 device_printf(dev, "unable to initialize PCM part of the card\n");
1117                 goto bad;
1118         }
1119
1120         /* XXX we should better get number of available channels from parent */
1121         if (pcm_register(dev, sc, (route == RT_FRONT) ? MAX_CHANNELS : 1, (route == RT_FRONT) ? 1 : 0)) {
1122                 device_printf(dev, "can't register PCM channels!\n");
1123                 goto bad;
1124         }
1125         sc->pnum = 0;
1126         if (route != RT_MCHRECORD)
1127                 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1128         if (route == RT_FRONT) {
1129                 for (i = 1; i < MAX_CHANNELS; i++)
1130                         pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1131                 pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc);
1132         }
1133         if (route == RT_MCHRECORD)
1134                 pcm_addchan(dev, PCMDIR_REC, &emufxrchan_class, sc);
1135
1136         snprintf(status, SND_STATUSLEN, "on %s", device_get_nameunit(device_get_parent(dev)));
1137         pcm_setstatus(dev, status);
1138
1139         return (0);
1140
1141 bad:
1142         if (sc->codec)
1143                 ac97_destroy(sc->codec);
1144         if (sc->lock)
1145                 snd_mtxfree(sc->lock);
1146         free(sc, M_DEVBUF);
1147         return (ENXIO);
1148 }
1149
1150 static int
1151 emu_pcm_detach(device_t dev)
1152 {
1153         int r;
1154         struct emu_pcm_info *sc;
1155
1156         sc = pcm_getdevinfo(dev);
1157
1158         r = pcm_unregister(dev);
1159
1160         if (r)  return (r);
1161
1162         emu_pcm_uninit(sc);
1163
1164         if (sc->lock)
1165                 snd_mtxfree(sc->lock);
1166         free(sc, M_DEVBUF);
1167
1168         return (0);
1169 }
1170
1171 static device_method_t emu_pcm_methods[] = {
1172         DEVMETHOD(device_probe, emu_pcm_probe),
1173         DEVMETHOD(device_attach, emu_pcm_attach),
1174         DEVMETHOD(device_detach, emu_pcm_detach),
1175
1176         {0, 0}
1177 };
1178
1179 static driver_t emu_pcm_driver = {
1180         "pcm",
1181         emu_pcm_methods,
1182         PCM_SOFTC_SIZE,
1183         NULL,
1184         0,
1185         NULL
1186 };
1187 DRIVER_MODULE(snd_emu10kx_pcm, emu10kx, emu_pcm_driver, pcm_devclass, 0, 0);
1188 MODULE_DEPEND(snd_emu10kx_pcm, snd_emu10kx, SND_EMU10KX_MINVER, SND_EMU10KX_PREFVER, SND_EMU10KX_MAXVER);
1189 MODULE_DEPEND(snd_emu10kx_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
1190 MODULE_VERSION(snd_emu10kx_pcm, SND_EMU10KX_PREFVER);