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

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