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