sys/dev/sound/pci/emu10k1.c

   1 /*
   2  * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/sound/pci/emu10k1.c,v 1.6.2.9 2002/04/22 15:49:32 cg Exp $
  27  * $DragonFly: src/sys/dev/sound/pci/emu10k1.c,v 1.5 2004/01/06 16:31:55 asmodai Exp $
  28  */
  29
  30 #include <dev/sound/pcm/sound.h>
  31 #include <dev/sound/pcm/ac97.h>
  32 #include "gnu/emu10k1.h"
  33
  34 #include <bus/pci/pcireg.h>
  35 #include <bus/pci/pcivar.h>
  36 #include <sys/queue.h>
  37
  38 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pci/emu10k1.c,v 1.5 2004/01/06 16:31:55 asmodai Exp $");
  39
  40 /* -------------------------------------------------------------------- */
  41
  42 #define EMU10K1_PCI_ID          0x00021102
  43 #define EMU10K2_PCI_ID          0x00041102
  44 #define EMU10K1X_PCI_ID         0x00061102
  45 #define EMU_DEFAULT_BUFSZ       4096
  46 #define EMU_MAX_CHANS           8
  47 #undef EMUDEBUG
  48
  49 struct emu_memblk {
  50         SLIST_ENTRY(emu_memblk) link;
  51         void *buf;
  52         u_int32_t pte_start, pte_size;
  53 };
  54
  55 struct emu_mem {
  56         u_int8_t bmap[MAXPAGES / 8];
  57         u_int32_t *ptb_pages;
  58         void *silent_page;
  59         SLIST_HEAD(, emu_memblk) blocks;
  60 };
  61
  62 struct emu_voice {
  63         int vnum;
  64         int b16:1, stereo:1, busy:1, running:1, ismaster:1;
  65         int speed;
  66         int start, end, vol;
  67         int fxrt1;      /* FX routing */
  68         int fxrt2;      /* FX routing (only for audigy) */
  69         u_int32_t buf;
  70         struct emu_voice *slave;
  71         struct pcm_channel *channel;
  72 };
  73
  74 struct sc_info;
  75
  76 /* channel registers */
  77 struct sc_pchinfo {
  78         int spd, fmt, blksz, run;
  79         struct emu_voice *master, *slave;
  80         struct snd_dbuf *buffer;
  81         struct pcm_channel *channel;
  82         struct sc_info *parent;
  83 };
  84
  85 struct sc_rchinfo {
  86         int spd, fmt, run, blksz, num;
  87         u_int32_t idxreg, basereg, sizereg, setupreg, irqmask;
  88         struct snd_dbuf *buffer;
  89         struct pcm_channel *channel;
  90         struct sc_info *parent;
  91 };
  92
  93 /* device private data */
  94 struct sc_info {
  95         device_t        dev;
  96         u_int32_t       type, rev;
  97         u_int32_t       tos_link:1, APS:1, audigy:1, audigy2:1;
  98         u_int32_t       addrmask;       /* wider if audigy */
  99
 100         bus_space_tag_t st;
 101         bus_space_handle_t sh;
 102         bus_dma_tag_t parent_dmat;
 103
 104         struct resource *reg, *irq;
 105         void            *ih;
 106         void            *lock;
 107
 108         unsigned int bufsz;
 109         int timer, timerinterval;
 110         int pnum, rnum;
 111         int nchans;
 112         struct emu_mem mem;
 113         struct emu_voice voice[64];
 114         struct sc_pchinfo pch[EMU_MAX_CHANS];
 115         struct sc_rchinfo rch[3];
 116 };
 117
 118 /* -------------------------------------------------------------------- */
 119
 120 /*
 121  * prototypes
 122  */
 123
 124 /* stuff */
 125 static int emu_init(struct sc_info *);
 126 static void emu_intr(void *);
 127 static void *emu_malloc(struct sc_info *sc, u_int32_t sz);
 128 static void *emu_memalloc(struct sc_info *sc, u_int32_t sz);
 129 static int emu_memfree(struct sc_info *sc, void *buf);
 130 static int emu_memstart(struct sc_info *sc, void *buf);
 131 #ifdef EMUDEBUG
 132 static void emu_vdump(struct sc_info *sc, struct emu_voice *v);
 133 #endif
 134
 135 /* talk to the card */
 136 static u_int32_t emu_rd(struct sc_info *, int, int);
 137 static void emu_wr(struct sc_info *, int, u_int32_t, int);
 138
 139 /* -------------------------------------------------------------------- */
 140
 141 static u_int32_t emu_rfmt_ac97[] = {
 142         AFMT_S16_LE,
 143         AFMT_STEREO | AFMT_S16_LE,
 144         0
 145 };
 146
 147 static u_int32_t emu_rfmt_mic[] = {
 148         AFMT_U8,
 149         0
 150 };
 151
 152 static u_int32_t emu_rfmt_efx[] = {
 153         AFMT_STEREO | AFMT_S16_LE,
 154         0
 155 };
 156
 157 static struct pcmchan_caps emu_reccaps[3] = {
 158         {8000, 48000, emu_rfmt_ac97, 0},
 159         {8000, 8000, emu_rfmt_mic, 0},
 160         {48000, 48000, emu_rfmt_efx, 0},
 161 };
 162
 163 static u_int32_t emu_pfmt[] = {
 164         AFMT_U8,
 165         AFMT_STEREO | AFMT_U8,
 166         AFMT_S16_LE,
 167         AFMT_STEREO | AFMT_S16_LE,
 168         0
 169 };
 170
 171 static struct pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0};
 172
 173 static int adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000};
 174 /* audigy supports 12kHz. */
 175 static int audigy_adcspeed[9] = {48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000};
 176
 177 /* -------------------------------------------------------------------- */
 178 /* Hardware */
 179 static u_int32_t
 180 emu_rd(struct sc_info *sc, int regno, int size)
 181 {
 182         switch (size) {
 183         case 1:
 184                 return bus_space_read_1(sc->st, sc->sh, regno);
 185         case 2:
 186                 return bus_space_read_2(sc->st, sc->sh, regno);
 187         case 4:
 188                 return bus_space_read_4(sc->st, sc->sh, regno);
 189         default:
 190                 return 0xffffffff;
 191         }
 192 }
 193
 194 static void
 195 emu_wr(struct sc_info *sc, int regno, u_int32_t data, int size)
 196 {
 197         switch (size) {
 198         case 1:
 199                 bus_space_write_1(sc->st, sc->sh, regno, data);
 200                 break;
 201         case 2:
 202                 bus_space_write_2(sc->st, sc->sh, regno, data);
 203                 break;
 204         case 4:
 205                 bus_space_write_4(sc->st, sc->sh, regno, data);
 206                 break;
 207         }
 208 }
 209
 210 static u_int32_t
 211 emu_rdptr(struct sc_info *sc, int chn, int reg)
 212 {
 213         u_int32_t ptr, val, mask, size, offset;
 214
 215         ptr = ((reg << 16) & sc->addrmask) | (chn & PTR_CHANNELNUM_MASK);
 216         emu_wr(sc, PTR, ptr, 4);
 217         val = emu_rd(sc, DATA, 4);
 218         if (reg & 0xff000000) {
 219                 size = (reg >> 24) & 0x3f;
 220                 offset = (reg >> 16) & 0x1f;
 221                 mask = ((1 << size) - 1) << offset;
 222                 val &= mask;
 223                 val >>= offset;
 224         }
 225         return val;
 226 }
 227
 228 static void
 229 emu_wrptr(struct sc_info *sc, int chn, int reg, u_int32_t data)
 230 {
 231         u_int32_t ptr, mask, size, offset;
 232
 233         ptr = ((reg << 16) & sc->addrmask) | (chn & PTR_CHANNELNUM_MASK);
 234         emu_wr(sc, PTR, ptr, 4);
 235         if (reg & 0xff000000) {
 236                 size = (reg >> 24) & 0x3f;
 237                 offset = (reg >> 16) & 0x1f;
 238                 mask = ((1 << size) - 1) << offset;
 239                 data <<= offset;
 240                 data &= mask;
 241                 data |= emu_rd(sc, DATA, 4) & ~mask;
 242         }
 243         emu_wr(sc, DATA, data, 4);
 244 }
 245
 246 static void
 247 emu_wrefx(struct sc_info *sc, unsigned int pc, unsigned int data)
 248 {
 249         pc += sc->audigy ? AUDIGY_CODEBASE : MICROCODEBASE;
 250         emu_wrptr(sc, 0, pc, data);
 251 }
 252
 253 /* -------------------------------------------------------------------- */
 254 /* ac97 codec */
 255 /* no locking needed */
 256
 257 static int
 258 emu_rdcd(kobj_t obj, void *devinfo, int regno)
 259 {
 260         struct sc_info *sc = (struct sc_info *)devinfo;
 261
 262         emu_wr(sc, AC97ADDRESS, regno, 1);
 263         return emu_rd(sc, AC97DATA, 2);
 264 }
 265
 266 static int
 267 emu_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 268 {
 269         struct sc_info *sc = (struct sc_info *)devinfo;
 270
 271         emu_wr(sc, AC97ADDRESS, regno, 1);
 272         emu_wr(sc, AC97DATA, data, 2);
 273         return 0;
 274 }
 275
 276 static kobj_method_t emu_ac97_methods[] = {
 277         KOBJMETHOD(ac97_read,           emu_rdcd),
 278         KOBJMETHOD(ac97_write,          emu_wrcd),
 279         { 0, 0 }
 280 };
 281 AC97_DECLARE(emu_ac97);
 282
 283 /* -------------------------------------------------------------------- */
 284 /* stuff */
 285 static int
 286 emu_settimer(struct sc_info *sc)
 287 {
 288         struct sc_pchinfo *pch;
 289         struct sc_rchinfo *rch;
 290         int i, tmp, rate;
 291
 292         rate = 0;
 293         for (i = 0; i < sc->nchans; i++) {
 294                 pch = &sc->pch[i];
 295                 if (pch->buffer) {
 296                         tmp = (pch->spd * sndbuf_getbps(pch->buffer)) / pch->blksz;
 297                         if (tmp > rate)
 298                                 rate = tmp;
 299                 }
 300         }
 301
 302         for (i = 0; i < 3; i++) {
 303                 rch = &sc->rch[i];
 304                 if (rch->buffer) {
 305                         tmp = (rch->spd * sndbuf_getbps(rch->buffer)) / rch->blksz;
 306                         if (tmp > rate)
 307                                 rate = tmp;
 308                 }
 309         }
 310         RANGE(rate, 48, 9600);
 311         sc->timerinterval = 48000 / rate;
 312         emu_wr(sc, TIMER, sc->timerinterval & 0x03ff, 2);
 313
 314         return sc->timerinterval;
 315 }
 316
 317 static int
 318 emu_enatimer(struct sc_info *sc, int go)
 319 {
 320         u_int32_t x;
 321         if (go) {
 322                 if (sc->timer++ == 0) {
 323                         x = emu_rd(sc, INTE, 4);
 324                         x |= INTE_INTERVALTIMERENB;
 325                         emu_wr(sc, INTE, x, 4);
 326                 }
 327         } else {
 328                 sc->timer = 0;
 329                 x = emu_rd(sc, INTE, 4);
 330                 x &= ~INTE_INTERVALTIMERENB;
 331                 emu_wr(sc, INTE, x, 4);
 332         }
 333         return 0;
 334 }
 335
 336 static void
 337 emu_enastop(struct sc_info *sc, char channel, int enable)
 338 {
 339         int reg = (channel & 0x20)? SOLEH : SOLEL;
 340         channel &= 0x1f;
 341         reg |= 1 << 24;
 342         reg |= channel << 16;
 343         emu_wrptr(sc, 0, reg, enable);
 344 }
 345
 346 static int
 347 emu_recval(int speed) {
 348         int val;
 349
 350         val = 0;
 351         while (val < 7 && speed < adcspeed[val])
 352                 val++;
 353         return val;
 354 }
 355
 356 static int
 357 audigy_recval(int speed) {
 358         int val;
 359
 360         val = 0;
 361         while (val < 8 && speed < audigy_adcspeed[val])
 362                 val++;
 363         return val;
 364 }
 365
 366 static u_int32_t
 367 emu_rate_to_pitch(u_int32_t rate)
 368 {
 369         static u_int32_t logMagTable[128] = {
 370                 0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3, 0x13aa2,
 371                 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a, 0x2655d, 0x28ed5,
 372                 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb, 0x381b6, 0x3a93d, 0x3d081,
 373                 0x3f782, 0x41e42, 0x444c1, 0x46b01, 0x49101, 0x4b6c4, 0x4dc49, 0x50191,
 374                 0x5269e, 0x54b6f, 0x57006, 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7,
 375                 0x646ee, 0x66a00, 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829,
 376                 0x759d4, 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
 377                 0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20, 0x93d26,
 378                 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec, 0xa11d8, 0xa2f9d,
 379                 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241, 0xadf26, 0xafbe7, 0xb1885,
 380                 0xb3500, 0xb5157, 0xb6d8c, 0xb899f, 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899,
 381                 0xc1404, 0xc2f50, 0xc4a7b, 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c,
 382                 0xceaec, 0xd053f, 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3,
 383                 0xdba4a, 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
 384                 0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a, 0xf2c83,
 385                 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57, 0xfd1a7, 0xfe8df
 386         };
 387         static char logSlopeTable[128] = {
 388                 0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
 389                 0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
 390                 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
 391                 0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
 392                 0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
 393                 0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
 394                 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
 395                 0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
 396                 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
 397                 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
 398                 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
 399                 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
 400                 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
 401                 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
 402                 0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
 403                 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
 404         };
 405         int i;
 406
 407         if (rate == 0)
 408                 return 0;       /* Bail out if no leading "1" */
 409         rate *= 11185;  /* Scale 48000 to 0x20002380 */
 410         for (i = 31; i > 0; i--) {
 411                 if (rate & 0x80000000) {        /* Detect leading "1" */
 412                         return (((u_int32_t) (i - 15) << 20) +
 413                                logMagTable[0x7f & (rate >> 24)] +
 414                                       (0x7f & (rate >> 17)) *
 415                              logSlopeTable[0x7f & (rate >> 24)]);
 416                 }
 417                 rate <<= 1;
 418         }
 419
 420         return 0;               /* Should never reach this point */
 421 }
 422
 423 static u_int32_t
 424 emu_rate_to_linearpitch(u_int32_t rate)
 425 {
 426         rate = (rate << 8) / 375;
 427         return (rate >> 1) + (rate & 1);
 428 }
 429
 430 static struct emu_voice *
 431 emu_valloc(struct sc_info *sc)
 432 {
 433         struct emu_voice *v;
 434         int i;
 435
 436         v = NULL;
 437         for (i = 0; i < 64 && sc->voice[i].busy; i++);
 438         if (i < 64) {
 439                 v = &sc->voice[i];
 440                 v->busy = 1;
 441         }
 442         return v;
 443 }
 444
 445 static int
 446 emu_vinit(struct sc_info *sc, struct emu_voice *m, struct emu_voice *s,
 447           u_int32_t sz, struct snd_dbuf *b)
 448 {
 449         void *buf;
 450
 451         buf = emu_memalloc(sc, sz);
 452         if (buf == NULL)
 453                 return -1;
 454         if (b != NULL)
 455                 sndbuf_setup(b, buf, sz);
 456         m->start = emu_memstart(sc, buf) * EMUPAGESIZE;
 457         m->end = m->start + sz;
 458         m->channel = NULL;
 459         m->speed = 0;
 460         m->b16 = 0;
 461         m->stereo = 0;
 462         m->running = 0;
 463         m->ismaster = 1;
 464         m->vol = 0xff;
 465         m->buf = vtophys(buf);
 466         m->slave = s;
 467         if (sc->audigy) {
 468                 m->fxrt1 = A_FXBUS_PCM_LEFT | A_FXBUS_PCM_RIGHT << 8 |
 469                         A_FXBUS_PCM_LEFT_REAR << 16 |
 470                         A_FXBUS_PCM_RIGHT_REAR << 24;
 471                 m->fxrt2 = A_FXBUS_PCM_CENTER | A_FXBUS_PCM_LFE << 8 |
 472                         A_FXBUS_MIDI_CHORUS << 16 |
 473                         A_FXBUS_MIDI_REVERB << 24;
 474         } else {
 475                 m->fxrt1 = FXBUS_PCM_LEFT | FXBUS_PCM_RIGHT << 4 |
 476                         FXBUS_MIDI_CHORUS << 8 |
 477                         FXBUS_MIDI_REVERB << 12;
 478                 m->fxrt2 = 0;
 479         }
 480
 481         if (s != NULL) {
 482                 s->start = m->start;
 483                 s->end = m->end;
 484                 s->channel = NULL;
 485                 s->speed = 0;
 486                 s->b16 = 0;
 487                 s->stereo = 0;
 488                 s->running = 0;
 489                 s->ismaster = 0;
 490                 s->vol = m->vol;
 491                 s->buf = m->buf;
 492                 s->fxrt1 = m->fxrt1;
 493                 s->fxrt2 = m->fxrt2;
 494                 s->slave = NULL;
 495         }
 496         return 0;
 497 }
 498
 499 static void
 500 emu_vsetup(struct sc_pchinfo *ch)
 501 {
 502         struct emu_voice *v = ch->master;
 503
 504         if (ch->fmt) {
 505                 v->b16 = (ch->fmt & AFMT_16BIT)? 1 : 0;
 506                 v->stereo = (ch->fmt & AFMT_STEREO)? 1 : 0;
 507                 if (v->slave != NULL) {
 508                         v->slave->b16 = v->b16;
 509                         v->slave->stereo = v->stereo;
 510                 }
 511         }
 512         if (ch->spd) {
 513                 v->speed = ch->spd;
 514                 if (v->slave != NULL)
 515                         v->slave->speed = v->speed;
 516         }
 517 }
 518
 519 static void
 520 emu_vwrite(struct sc_info *sc, struct emu_voice *v)
 521 {
 522         int s;
 523         int l, r, x, y;
 524         u_int32_t sa, ea, start, val, silent_page;
 525
 526         s = (v->stereo? 1 : 0) + (v->b16? 1 : 0);
 527
 528         sa = v->start >> s;
 529         ea = v->end >> s;
 530
 531         l = r = x = y = v->vol;
 532         if (v->stereo) {
 533                 l = v->ismaster? l : 0;
 534                 r = v->ismaster? 0 : r;
 535         }
 536
 537         emu_wrptr(sc, v->vnum, CPF, v->stereo? CPF_STEREO_MASK : 0);
 538         val = v->stereo? 28 : 30;
 539         val *= v->b16? 1 : 2;
 540         start = sa + val;
 541
 542         if (sc->audigy) {
 543                 emu_wrptr(sc, v->vnum, A_FXRT1, v->fxrt1);
 544                 emu_wrptr(sc, v->vnum, A_FXRT2, v->fxrt2);
 545                 emu_wrptr(sc, v->vnum, A_SENDAMOUNTS, 0);
 546         }
 547         else
 548                 emu_wrptr(sc, v->vnum, FXRT, v->fxrt1 << 16);
 549
 550         emu_wrptr(sc, v->vnum, PTRX, (x << 8) | r);
 551         emu_wrptr(sc, v->vnum, DSL, ea | (y << 24));
 552         emu_wrptr(sc, v->vnum, PSST, sa | (l << 24));
 553         emu_wrptr(sc, v->vnum, CCCA, start | (v->b16? 0 : CCCA_8BITSELECT));
 554
 555         emu_wrptr(sc, v->vnum, Z1, 0);
 556         emu_wrptr(sc, v->vnum, Z2, 0);
 557
 558         silent_page = ((u_int32_t)vtophys(sc->mem.silent_page) << 1) | MAP_PTI_MASK;
 559         emu_wrptr(sc, v->vnum, MAPA, silent_page);
 560         emu_wrptr(sc, v->vnum, MAPB, silent_page);
 561
 562         emu_wrptr(sc, v->vnum, CVCF, CVCF_CURRENTFILTER_MASK);
 563         emu_wrptr(sc, v->vnum, VTFT, VTFT_FILTERTARGET_MASK);
 564         emu_wrptr(sc, v->vnum, ATKHLDM, 0);
 565         emu_wrptr(sc, v->vnum, DCYSUSM, DCYSUSM_DECAYTIME_MASK);
 566         emu_wrptr(sc, v->vnum, LFOVAL1, 0x8000);
 567         emu_wrptr(sc, v->vnum, LFOVAL2, 0x8000);
 568         emu_wrptr(sc, v->vnum, FMMOD, 0);
 569         emu_wrptr(sc, v->vnum, TREMFRQ, 0);
 570         emu_wrptr(sc, v->vnum, FM2FRQ2, 0);
 571         emu_wrptr(sc, v->vnum, ENVVAL, 0x8000);
 572
 573         emu_wrptr(sc, v->vnum, ATKHLDV, ATKHLDV_HOLDTIME_MASK | ATKHLDV_ATTACKTIME_MASK);
 574         emu_wrptr(sc, v->vnum, ENVVOL, 0x8000);
 575
 576         emu_wrptr(sc, v->vnum, PEFE_FILTERAMOUNT, 0x7f);
 577         emu_wrptr(sc, v->vnum, PEFE_PITCHAMOUNT, 0);
 578
 579         if (v->slave != NULL)
 580                 emu_vwrite(sc, v->slave);
 581 }
 582
 583 static void
 584 emu_vtrigger(struct sc_info *sc, struct emu_voice *v, int go)
 585 {
 586         u_int32_t pitch_target, initial_pitch;
 587         u_int32_t cra, cs, ccis;
 588         u_int32_t sample, i;
 589
 590         if (go) {
 591                 cra = 64;
 592                 cs = v->stereo? 4 : 2;
 593                 ccis = v->stereo? 28 : 30;
 594                 ccis *= v->b16? 1 : 2;
 595                 sample = v->b16? 0x00000000 : 0x80808080;
 596
 597                 for (i = 0; i < cs; i++)
 598                         emu_wrptr(sc, v->vnum, CD0 + i, sample);
 599                 emu_wrptr(sc, v->vnum, CCR_CACHEINVALIDSIZE, 0);
 600                 emu_wrptr(sc, v->vnum, CCR_READADDRESS, cra);
 601                 emu_wrptr(sc, v->vnum, CCR_CACHEINVALIDSIZE, ccis);
 602
 603                 emu_wrptr(sc, v->vnum, IFATN, 0xff00);
 604                 emu_wrptr(sc, v->vnum, VTFT, 0xffffffff);
 605                 emu_wrptr(sc, v->vnum, CVCF, 0xffffffff);
 606                 emu_wrptr(sc, v->vnum, DCYSUSV, 0x00007f7f);
 607                 emu_enastop(sc, v->vnum, 0);
 608
 609                 pitch_target = emu_rate_to_linearpitch(v->speed);
 610                 initial_pitch = emu_rate_to_pitch(v->speed) >> 8;
 611                 emu_wrptr(sc, v->vnum, PTRX_PITCHTARGET, pitch_target);
 612                 emu_wrptr(sc, v->vnum, CPF_CURRENTPITCH, pitch_target);
 613                 emu_wrptr(sc, v->vnum, IP, initial_pitch);
 614         } else {
 615                 emu_wrptr(sc, v->vnum, PTRX_PITCHTARGET, 0);
 616                 emu_wrptr(sc, v->vnum, CPF_CURRENTPITCH, 0);
 617                 emu_wrptr(sc, v->vnum, IFATN, 0xffff);
 618                 emu_wrptr(sc, v->vnum, VTFT, 0x0000ffff);
 619                 emu_wrptr(sc, v->vnum, CVCF, 0x0000ffff);
 620                 emu_wrptr(sc, v->vnum, IP, 0);
 621                 emu_enastop(sc, v->vnum, 1);
 622         }
 623         if (v->slave != NULL)
 624                 emu_vtrigger(sc, v->slave, go);
 625 }
 626
 627 static int
 628 emu_vpos(struct sc_info *sc, struct emu_voice *v)
 629 {
 630         int s, ptr;
 631
 632         s = (v->b16? 1 : 0) + (v->stereo? 1 : 0);
 633         ptr = (emu_rdptr(sc, v->vnum, CCCA_CURRADDR) - (v->start >> s)) << s;
 634         return ptr & ~0x0000001f;
 635 }
 636
 637 #ifdef EMUDEBUG
 638 static void
 639 emu_vdump(struct sc_info *sc, struct emu_voice *v)
 640 {
 641         char *regname[] = { "cpf", "ptrx", "cvcf", "vtft", "z2", "z1", "psst", "dsl",
 642                             "ccca", "ccr", "clp", "fxrt", "mapa", "mapb", NULL, NULL,
 643                             "envvol", "atkhldv", "dcysusv", "lfoval1",
 644                             "envval", "atkhldm", "dcysusm", "lfoval2",
 645                             "ip", "ifatn", "pefe", "fmmod", "tremfrq", "fmfrq2",
 646                             "tempenv" };
 647         char *regname2[] = { "mudata1", "mustat1", "mudata2", "mustat2",
 648                              "fxwc1", "fxwc2", "spdrate", NULL, NULL,
 649                              NULL, NULL, NULL, "fxrt2", "sndamnt", "fxrt1",
 650                              NULL, NULL };
 651         int i, x;
 652
 653         printf("voice number %d\n", v->vnum);
 654         for (i = 0, x = 0; i <= 0x1e; i++) {
 655                 if (regname[i] == NULL)
 656                         continue;
 657                 printf("%s\t[%08x]", regname[i], emu_rdptr(sc, v->vnum, i));
 658                 printf("%s", (x == 2)? "\n" : "\t");
 659                 x++;
 660                 if (x > 2)
 661                         x = 0;
 662         }
 663
 664         /* Print out audigy extra registers */
 665         if (sc->audigy) {
 666                 for (i = 0; i <= 0xe; i++) {
 667                         if (regname2[i] == NULL)
 668                                 continue;
 669                         printf("%s\t[%08x]", regname2[i], emu_rdptr(sc, v->vnum, i + 0x70));
 670                         printf("%s", (x == 2)? "\n" : "\t");
 671                         x++;
 672                         if (x > 2)
 673                                 x = 0;
 674                 }
 675         }
 676
 677         printf("\n\n");
 678 }
 679 #endif
 680
 681 /* channel interface */
 682 static void *
 683 emupchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
 684 {
 685         struct sc_info *sc = devinfo;
 686         struct sc_pchinfo *ch;
 687         void *r;
 688
 689         KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction"));
 690         ch = &sc->pch[sc->pnum++];
 691         ch->buffer = b;
 692         ch->parent = sc;
 693         ch->channel = c;
 694         ch->blksz = sc->bufsz / 2;
 695         ch->fmt = AFMT_U8;
 696         ch->spd = 8000;
 697         snd_mtxlock(sc->lock);
 698         ch->master = emu_valloc(sc);
 699         ch->slave = emu_valloc(sc);
 700         r = (emu_vinit(sc, ch->master, ch->slave, sc->bufsz, ch->buffer))? NULL : ch;
 701         snd_mtxunlock(sc->lock);
 702
 703         return r;
 704 }
 705
 706 static int
 707 emupchan_free(kobj_t obj, void *data)
 708 {
 709         struct sc_pchinfo *ch = data;
 710         struct sc_info *sc = ch->parent;
 711         int r;
 712
 713         snd_mtxlock(sc->lock);
 714         r = emu_memfree(sc, sndbuf_getbuf(ch->buffer));
 715         snd_mtxunlock(sc->lock);
 716
 717         return r;
 718 }
 719
 720 static int
 721 emupchan_setformat(kobj_t obj, void *data, u_int32_t format)
 722 {
 723         struct sc_pchinfo *ch = data;
 724
 725         ch->fmt = format;
 726         return 0;
 727 }
 728
 729 static int
 730 emupchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 731 {
 732         struct sc_pchinfo *ch = data;
 733
 734         ch->spd = speed;
 735         return ch->spd;
 736 }
 737
 738 static int
 739 emupchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 740 {
 741         struct sc_pchinfo *ch = data;
 742         struct sc_info *sc = ch->parent;
 743         int irqrate, blksz;
 744
 745         ch->blksz = blocksize;
 746         snd_mtxlock(sc->lock);
 747         emu_settimer(sc);
 748         irqrate = 48000 / sc->timerinterval;
 749         snd_mtxunlock(sc->lock);
 750         blksz = (ch->spd * sndbuf_getbps(ch->buffer)) / irqrate;
 751         return blocksize;
 752 }
 753
 754 static int
 755 emupchan_trigger(kobj_t obj, void *data, int go)
 756 {
 757         struct sc_pchinfo *ch = data;
 758         struct sc_info *sc = ch->parent;
 759
 760         if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
 761                 return 0;
 762
 763         snd_mtxlock(sc->lock);
 764         if (go == PCMTRIG_START) {
 765                 emu_vsetup(ch);
 766                 emu_vwrite(sc, ch->master);
 767                 emu_settimer(sc);
 768                 emu_enatimer(sc, 1);
 769 #ifdef EMUDEBUG
 770                 printf("start [%d bit, %s, %d hz]\n",
 771                         ch->master->b16? 16 : 8,
 772                         ch->master->stereo? "stereo" : "mono",
 773                         ch->master->speed);
 774                 emu_vdump(sc, ch->master);
 775                 emu_vdump(sc, ch->slave);
 776 #endif
 777         }
 778         ch->run = (go == PCMTRIG_START)? 1 : 0;
 779         emu_vtrigger(sc, ch->master, ch->run);
 780         snd_mtxunlock(sc->lock);
 781         return 0;
 782 }
 783
 784 static int
 785 emupchan_getptr(kobj_t obj, void *data)
 786 {
 787         struct sc_pchinfo *ch = data;
 788         struct sc_info *sc = ch->parent;
 789         int r;
 790
 791         snd_mtxlock(sc->lock);
 792         r = emu_vpos(sc, ch->master);
 793         snd_mtxunlock(sc->lock);
 794
 795         return r;
 796 }
 797
 798 static struct pcmchan_caps *
 799 emupchan_getcaps(kobj_t obj, void *data)
 800 {
 801         return &emu_playcaps;
 802 }
 803
 804 static kobj_method_t emupchan_methods[] = {
 805         KOBJMETHOD(channel_init,                emupchan_init),
 806         KOBJMETHOD(channel_free,                emupchan_free),
 807         KOBJMETHOD(channel_setformat,           emupchan_setformat),
 808         KOBJMETHOD(channel_setspeed,            emupchan_setspeed),
 809         KOBJMETHOD(channel_setblocksize,        emupchan_setblocksize),
 810         KOBJMETHOD(channel_trigger,             emupchan_trigger),
 811         KOBJMETHOD(channel_getptr,              emupchan_getptr),
 812         KOBJMETHOD(channel_getcaps,             emupchan_getcaps),
 813         { 0, 0 }
 814 };
 815 CHANNEL_DECLARE(emupchan);
 816
 817 /* channel interface */
 818 static void *
 819 emurchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
 820 {
 821         struct sc_info *sc = devinfo;
 822         struct sc_rchinfo *ch;
 823
 824         KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction"));
 825         ch = &sc->rch[sc->rnum];
 826         ch->buffer = b;
 827         ch->parent = sc;
 828         ch->channel = c;
 829         ch->blksz = sc->bufsz / 2;
 830         ch->fmt = AFMT_U8;
 831         ch->spd = 8000;
 832         ch->num = sc->rnum;
 833         switch(sc->rnum) {
 834         case 0:
 835                 ch->idxreg = sc->audigy ? A_ADCIDX : ADCIDX;
 836                 ch->basereg = ADCBA;
 837                 ch->sizereg = ADCBS;
 838                 ch->setupreg = ADCCR;
 839                 ch->irqmask = INTE_ADCBUFENABLE;
 840                 break;
 841
 842         case 1:
 843                 ch->idxreg = FXIDX;
 844                 ch->basereg = FXBA;
 845                 ch->sizereg = FXBS;
 846                 ch->setupreg = FXWC;
 847                 ch->irqmask = INTE_EFXBUFENABLE;
 848                 break;
 849
 850         case 2:
 851                 ch->idxreg = MICIDX;
 852                 ch->basereg = MICBA;
 853                 ch->sizereg = MICBS;
 854                 ch->setupreg = 0;
 855                 ch->irqmask = INTE_MICBUFENABLE;
 856                 break;
 857         }
 858         sc->rnum++;
 859         if (sndbuf_alloc(ch->buffer, sc->parent_dmat, sc->bufsz) == -1)
 860                 return NULL;
 861         else {
 862                 snd_mtxlock(sc->lock);
 863                 emu_wrptr(sc, 0, ch->basereg, vtophys(sndbuf_getbuf(ch->buffer)));
 864                 emu_wrptr(sc, 0, ch->sizereg, 0); /* off */
 865                 snd_mtxunlock(sc->lock);
 866                 return ch;
 867         }
 868 }
 869
 870 static int
 871 emurchan_setformat(kobj_t obj, void *data, u_int32_t format)
 872 {
 873         struct sc_rchinfo *ch = data;
 874
 875         ch->fmt = format;
 876         return 0;
 877 }
 878
 879 static int
 880 emurchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 881 {
 882         struct sc_rchinfo *ch = data;
 883
 884         if (ch->num == 0) {
 885                 if (ch->parent->audigy)
 886                         speed = audigy_adcspeed[audigy_recval(speed)];
 887                 else
 888                         speed = adcspeed[emu_recval(speed)];
 889         }
 890         if (ch->num == 1)
 891                 speed = 48000;
 892         if (ch->num == 2)
 893                 speed = 8000;
 894         ch->spd = speed;
 895         return ch->spd;
 896 }
 897
 898 static int
 899 emurchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 900 {
 901         struct sc_rchinfo *ch = data;
 902         struct sc_info *sc = ch->parent;
 903         int irqrate, blksz;
 904
 905         ch->blksz = blocksize;
 906         snd_mtxlock(sc->lock);
 907         emu_settimer(sc);
 908         irqrate = 48000 / sc->timerinterval;
 909         snd_mtxunlock(sc->lock);
 910         blksz = (ch->spd * sndbuf_getbps(ch->buffer)) / irqrate;
 911         return blocksize;
 912 }
 913
 914 /* semantic note: must start at beginning of buffer */
 915 static int
 916 emurchan_trigger(kobj_t obj, void *data, int go)
 917 {
 918         struct sc_rchinfo *ch = data;
 919         struct sc_info *sc = ch->parent;
 920         u_int32_t val, sz;
 921
 922         switch(sc->bufsz) {
 923         case 4096:
 924                 sz = ADCBS_BUFSIZE_4096;
 925                 break;
 926
 927         case 8192:
 928                 sz = ADCBS_BUFSIZE_8192;
 929                 break;
 930
 931         case 16384:
 932                 sz = ADCBS_BUFSIZE_16384;
 933                 break;
 934
 935         case 32768:
 936                 sz = ADCBS_BUFSIZE_32768;
 937                 break;
 938
 939         case 65536:
 940                 sz = ADCBS_BUFSIZE_65536;
 941                 break;
 942
 943         default:
 944                 sz = ADCBS_BUFSIZE_4096;
 945         }
 946
 947         snd_mtxlock(sc->lock);
 948         switch(go) {
 949         case PCMTRIG_START:
 950                 ch->run = 1;
 951                 emu_wrptr(sc, 0, ch->sizereg, sz);
 952                 if (ch->num == 0) {
 953                         if (sc->audigy) {
 954                                 val = A_ADCCR_LCHANENABLE;
 955                                 if (ch->fmt & AFMT_STEREO)
 956                                         val |= A_ADCCR_RCHANENABLE;
 957                                 val |= audigy_recval(ch->spd);
 958                         } else {
 959                                 val = ADCCR_LCHANENABLE;
 960                                 if (ch->fmt & AFMT_STEREO)
 961                                         val |= ADCCR_RCHANENABLE;
 962                                 val |= emu_recval(ch->spd);
 963                         }
 964
 965                         emu_wrptr(sc, 0, ch->setupreg, 0);
 966                         emu_wrptr(sc, 0, ch->setupreg, val);
 967                 }
 968                 val = emu_rd(sc, INTE, 4);
 969                 val |= ch->irqmask;
 970                 emu_wr(sc, INTE, val, 4);
 971                 break;
 972
 973         case PCMTRIG_STOP:
 974         case PCMTRIG_ABORT:
 975                 ch->run = 0;
 976                 emu_wrptr(sc, 0, ch->sizereg, 0);
 977                 if (ch->setupreg)
 978                         emu_wrptr(sc, 0, ch->setupreg, 0);
 979                 val = emu_rd(sc, INTE, 4);
 980                 val &= ~ch->irqmask;
 981                 emu_wr(sc, INTE, val, 4);
 982                 break;
 983
 984         case PCMTRIG_EMLDMAWR:
 985         case PCMTRIG_EMLDMARD:
 986         default:
 987                 break;
 988         }
 989         snd_mtxunlock(sc->lock);
 990
 991         return 0;
 992 }
 993
 994 static int
 995 emurchan_getptr(kobj_t obj, void *data)
 996 {
 997         struct sc_rchinfo *ch = data;
 998         struct sc_info *sc = ch->parent;
 999         int r;
1000
1001         snd_mtxlock(sc->lock);
1002         r = emu_rdptr(sc, 0, ch->idxreg) & 0x0000ffff;
1003         snd_mtxunlock(sc->lock);
1004
1005         return r;
1006 }
1007
1008 static struct pcmchan_caps *
1009 emurchan_getcaps(kobj_t obj, void *data)
1010 {
1011         struct sc_rchinfo *ch = data;
1012
1013         return &emu_reccaps[ch->num];
1014 }
1015
1016 static kobj_method_t emurchan_methods[] = {
1017         KOBJMETHOD(channel_init,                emurchan_init),
1018         KOBJMETHOD(channel_setformat,           emurchan_setformat),
1019         KOBJMETHOD(channel_setspeed,            emurchan_setspeed),
1020         KOBJMETHOD(channel_setblocksize,        emurchan_setblocksize),
1021         KOBJMETHOD(channel_trigger,             emurchan_trigger),
1022         KOBJMETHOD(channel_getptr,              emurchan_getptr),
1023         KOBJMETHOD(channel_getcaps,             emurchan_getcaps),
1024         { 0, 0 }
1025 };
1026 CHANNEL_DECLARE(emurchan);
1027
1028 /* -------------------------------------------------------------------- */
1029 /* The interrupt handler */
1030 static void
1031 emu_intr(void *p)
1032 {
1033         struct sc_info *sc = (struct sc_info *)p;
1034         u_int32_t stat, ack, i, x;
1035
1036         while (1) {
1037                 stat = emu_rd(sc, IPR, 4);
1038                 if (stat == 0)
1039                         break;
1040                 ack = 0;
1041
1042                 /* process irq */
1043                 if (stat & IPR_INTERVALTIMER) {
1044                         ack |= IPR_INTERVALTIMER;
1045                         x = 0;
1046                         for (i = 0; i < sc->nchans; i++) {
1047                                 if (sc->pch[i].run) {
1048                                         x = 1;
1049                                         chn_intr(sc->pch[i].channel);
1050                                 }
1051                         }
1052                         if (x == 0)
1053                                 emu_enatimer(sc, 0);
1054                 }
1055
1056
1057                 if (stat & (IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL)) {
1058                         ack |= stat & (IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL);
1059                         if (sc->rch[0].channel)
1060                                 chn_intr(sc->rch[0].channel);
1061                 }
1062                 if (stat & (IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL)) {
1063                         ack |= stat & (IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL);
1064                         if (sc->rch[1].channel)
1065                                 chn_intr(sc->rch[1].channel);
1066                 }
1067                 if (stat & (IPR_MICBUFFULL | IPR_MICBUFHALFFULL)) {
1068                         ack |= stat & (IPR_MICBUFFULL | IPR_MICBUFHALFFULL);
1069                         if (sc->rch[2].channel)
1070                                 chn_intr(sc->rch[2].channel);
1071                 }
1072                 if (stat & IPR_PCIERROR) {
1073                         ack |= IPR_PCIERROR;
1074                         device_printf(sc->dev, "pci error\n");
1075                         /* we still get an nmi with ecc ram even if we ack this */
1076                 }
1077                 if (stat & IPR_SAMPLERATETRACKER) {
1078                         ack |= IPR_SAMPLERATETRACKER;
1079                         /* device_printf(sc->dev, "sample rate tracker lock status change\n"); */
1080                 }
1081
1082                 if (stat & ~ack)
1083                         device_printf(sc->dev, "dodgy irq: %x (harmless)\n", stat & ~ack);
1084
1085                 emu_wr(sc, IPR, stat, 4);
1086         }
1087 }
1088
1089 /* -------------------------------------------------------------------- */
1090
1091 static void
1092 emu_setmap(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1093 {
1094         void **phys = arg;
1095
1096         *phys = error? 0 : (void *)segs->ds_addr;
1097
1098         if (bootverbose) {
1099                 printf("emu: setmap (%lx, %lx), nseg=%d, error=%d\n",
1100                        (unsigned long)segs->ds_addr, (unsigned long)segs->ds_len,
1101                        nseg, error);
1102         }
1103 }
1104
1105 static void *
1106 emu_malloc(struct sc_info *sc, u_int32_t sz)
1107 {
1108         void *buf, *phys = 0;
1109         bus_dmamap_t map;
1110
1111         if (bus_dmamem_alloc(sc->parent_dmat, &buf, BUS_DMA_NOWAIT, &map))
1112                 return NULL;
1113         if (bus_dmamap_load(sc->parent_dmat, map, buf, sz, emu_setmap, &phys, 0)
1114             || !phys)
1115                 return NULL;
1116         return buf;
1117 }
1118
1119 static void
1120 emu_free(struct sc_info *sc, void *buf)
1121 {
1122         bus_dmamem_free(sc->parent_dmat, buf, NULL);
1123 }
1124
1125 static void *
1126 emu_memalloc(struct sc_info *sc, u_int32_t sz)
1127 {
1128         u_int32_t blksz, start, idx, ofs, tmp, found;
1129         struct emu_mem *mem = &sc->mem;
1130         struct emu_memblk *blk;
1131         void *buf;
1132
1133         blksz = sz / EMUPAGESIZE;
1134         if (sz > (blksz * EMUPAGESIZE))
1135                 blksz++;
1136         /* find a free block in the bitmap */
1137         found = 0;
1138         start = 1;
1139         while (!found && start + blksz < MAXPAGES) {
1140                 found = 1;
1141                 for (idx = start; idx < start + blksz; idx++)
1142                         if (mem->bmap[idx >> 3] & (1 << (idx & 7)))
1143                                 found = 0;
1144                 if (!found)
1145                         start++;
1146         }
1147         if (!found)
1148                 return NULL;
1149         blk = malloc(sizeof(*blk), M_DEVBUF, M_NOWAIT);
1150         if (blk == NULL)
1151                 return NULL;
1152         buf = emu_malloc(sc, sz);
1153         if (buf == NULL) {
1154                 free(blk, M_DEVBUF);
1155                 return NULL;
1156         }
1157         blk->buf = buf;
1158         blk->pte_start = start;
1159         blk->pte_size = blksz;
1160         /* printf("buf %p, pte_start %d, pte_size %d\n", blk->buf, blk->pte_start, blk->pte_size); */
1161         ofs = 0;
1162         for (idx = start; idx < start + blksz; idx++) {
1163                 mem->bmap[idx >> 3] |= 1 << (idx & 7);
1164                 tmp = (u_int32_t)vtophys((u_int8_t *)buf + ofs);
1165                 /* printf("pte[%d] -> %x phys, %x virt\n", idx, tmp, ((u_int32_t)buf) + ofs); */
1166                 mem->ptb_pages[idx] = (tmp << 1) | idx;
1167                 ofs += EMUPAGESIZE;
1168         }
1169         SLIST_INSERT_HEAD(&mem->blocks, blk, link);
1170         return buf;
1171 }
1172
1173 static int
1174 emu_memfree(struct sc_info *sc, void *buf)
1175 {
1176         u_int32_t idx, tmp;
1177         struct emu_mem *mem = &sc->mem;
1178         struct emu_memblk *blk, *i;
1179
1180         blk = NULL;
1181         SLIST_FOREACH(i, &mem->blocks, link) {
1182                 if (i->buf == buf)
1183                         blk = i;
1184         }
1185         if (blk == NULL)
1186                 return EINVAL;
1187         SLIST_REMOVE(&mem->blocks, blk, emu_memblk, link);
1188         emu_free(sc, buf);
1189         tmp = (u_int32_t)vtophys(sc->mem.silent_page) << 1;
1190         for (idx = blk->pte_start; idx < blk->pte_start + blk->pte_size; idx++) {
1191                 mem->bmap[idx >> 3] &= ~(1 << (idx & 7));
1192                 mem->ptb_pages[idx] = tmp | idx;
1193         }
1194         free(blk, M_DEVBUF);
1195         return 0;
1196 }
1197
1198 static int
1199 emu_memstart(struct sc_info *sc, void *buf)
1200 {
1201         struct emu_mem *mem = &sc->mem;
1202         struct emu_memblk *blk, *i;
1203
1204         blk = NULL;
1205         SLIST_FOREACH(i, &mem->blocks, link) {
1206                 if (i->buf == buf)
1207                         blk = i;
1208         }
1209         if (blk == NULL)
1210                 return -EINVAL;
1211         return blk->pte_start;
1212 }
1213
1214 static void
1215 emu_addefxop(struct sc_info *sc, int op, int z, int w, int x, int y, u_int32_t *pc)
1216 {
1217         emu_wrefx(sc, (*pc) * 2, (x << 10) | y);
1218         emu_wrefx(sc, (*pc) * 2 + 1, (op << 20) | (z << 10) | w);
1219         (*pc)++;
1220 }
1221
1222 static void
1223 audigy_addefxop(struct sc_info *sc, int op, int z, int w, int x, int y, u_int32_t *pc)
1224 {
1225         emu_wrefx(sc, (*pc) * 2, (x << 12) | y);
1226         emu_wrefx(sc, (*pc) * 2 + 1, (op << 24) | (z << 12) | w);
1227         (*pc)++;
1228 }
1229
1230 static void
1231 audigy_initefx(struct sc_info *sc)
1232 {
1233         int i;
1234         u_int32_t pc = 0;
1235
1236         /* skip 0, 0, -1, 0 - NOPs */
1237         for (i = 0; i < 512; i++)
1238                 audigy_addefxop(sc, 0x0f, 0x0c0, 0x0c0, 0x0cf, 0x0c0, &pc);
1239
1240         for (i = 0; i < 512; i++)
1241                 emu_wrptr(sc, 0, A_FXGPREGBASE + i, 0x0);
1242
1243         pc = 16;
1244
1245         /* stop fx processor */
1246         emu_wrptr(sc, 0, A_DBG, A_DBG_SINGLE_STEP);
1247
1248         /* Audigy 2 (EMU10K2) DSP Registers:
1249            FX Bus
1250                 0x000-0x00f : 16 registers (???)
1251            Input
1252                 0x040/0x041 : AC97 Codec (l/r)
1253                 0x042/0x043 : ADC, S/PDIF (l/r)
1254                 0x044/0x045 : Optical S/PDIF in (l/r)
1255                 0x046/0x047 : ???
1256                 0x048/0x049 : Line/Mic 2 (l/r)
1257                 0x04a/0x04b : RCA S/PDIF (l/r)
1258                 0x04c/0x04d : Aux 2 (l/r)
1259            Output
1260                 0x060/0x061 : Digital Front (l/r)
1261                 0x062/0x063 : Digital Center/LFE
1262                 0x064/0x065 : AudigyDrive Heaphone (l/r)
1263                 0x066/0x067 : Digital Rear (l/r)
1264                 0x068/0x069 : Analog Front (l/r)
1265                 0x06a/0x06b : Analog Center/LFE
1266                 0x06c/0x06d : ???
1267                 0x06e/0x06f : Analog Rear (l/r)
1268                 0x070/0x071 : AC97 Output (l/r)
1269                 0x072/0x073 : ???
1270                 0x074/0x075 : ???
1271                 0x076/0x077 : ADC Recording Buffer (l/r)
1272            Constants
1273                 0x0c0 - 0x0c4 = 0 - 4
1274                 0x0c5 = 0x8, 0x0c6 = 0x10, 0x0c7 = 0x20
1275                 0x0c8 = 0x100, 0x0c9 = 0x10000, 0x0ca = 0x80000
1276                 0x0cb = 0x10000000, 0x0cc = 0x20000000, 0x0cd = 0x40000000
1277                 0x0ce = 0x80000000, 0x0cf = 0x7fffffff, 0x0d0 = 0xffffffff
1278                 0x0d1 = 0xfffffffe, 0x0d2 = 0xc0000000, 0x0d3 = 0x41fbbcdc
1279                 0x0d4 = 0x5a7ef9db, 0x0d5 = 0x00100000, 0x0dc = 0x00000001 (???)
1280            Temporary Values
1281                 0x0d6 : Accumulator (???)
1282                 0x0d7 : Condition Register
1283                 0x0d8 : Noise source
1284                 0x0d9 : Noise source
1285            Tank Memory Data Registers
1286                 0x200 - 0x2ff
1287            Tank Memory Address Registers
1288                 0x300 - 0x3ff
1289            General Purpose Registers
1290                 0x400 - 0x5ff
1291          */
1292
1293         /* AC97Output[l/r] = FXBus PCM[l/r] */
1294         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AC97_L), A_C_00000000,
1295                         A_C_00000000, A_FXBUS(A_FXBUS_PCM_LEFT), &pc);
1296         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AC97_R), A_C_00000000,
1297                         A_C_00000000, A_FXBUS(A_FXBUS_PCM_RIGHT), &pc);
1298
1299         /* GPR[0/1] = RCA S/PDIF[l/r] -- Master volume */
1300         audigy_addefxop(sc, iACC3, A_GPR(0), A_C_00000000,
1301                         A_C_00000000, A_EXTIN(A_EXTIN_RCA_SPDIF_L), &pc);
1302         audigy_addefxop(sc, iACC3, A_GPR(1), A_C_00000000,
1303                         A_C_00000000, A_EXTIN(A_EXTIN_RCA_SPDIF_R), &pc);
1304
1305         /* GPR[2] = GPR[0] (Left) / 2 + GPR[1] (Right) / 2 -- Central volume */
1306         audigy_addefxop(sc, iINTERP, A_GPR(2), A_GPR(1),
1307                         A_C_40000000, A_GPR(0), &pc);
1308
1309         /* Headphones[l/r] = GPR[0/1] */
1310         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_HEADPHONE_L),
1311                         A_C_00000000, A_C_00000000, A_GPR(0), &pc);
1312         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_HEADPHONE_R),
1313                         A_C_00000000, A_C_00000000, A_GPR(1), &pc);
1314
1315         /* Analog Front[l/r] = GPR[0/1] */
1316         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AFRONT_L), A_C_00000000,
1317                         A_C_00000000, A_GPR(0), &pc);
1318         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AFRONT_R), A_C_00000000,
1319                         A_C_00000000, A_GPR(1), &pc);
1320
1321         /* Digital Front[l/r] = GPR[0/1] */
1322         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L), A_C_00000000,
1323                         A_C_00000000, A_GPR(0), &pc);
1324         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_FRONT_R), A_C_00000000,
1325                         A_C_00000000, A_GPR(1), &pc);
1326
1327         /* Center and Subwoofer configuration */
1328         /* Analog Center = GPR[0] + GPR[2] */
1329         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_ACENTER), A_C_00000000,
1330                         A_GPR(0), A_GPR(2), &pc);
1331         /* Analog Sub = GPR[1] + GPR[2] */
1332         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_ALFE), A_C_00000000,
1333                         A_GPR(1), A_GPR(2), &pc);
1334
1335         /* Digital Center = GPR[0] + GPR[2] */
1336         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_CENTER), A_C_00000000,
1337                         A_GPR(0), A_GPR(2), &pc);
1338         /* Digital Sub = GPR[1] + GPR[2] */
1339         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_LFE), A_C_00000000,
1340                         A_GPR(1), A_GPR(2), &pc);
1341
1342 #if 0
1343         /* Analog Rear[l/r] = (GPR[0/1] * RearVolume[l/r]) >> 31 */
1344         /*   RearVolume = GPR[0x10/0x11] (Will this ever be implemented?) */
1345         audigy_addefxop(sc, iMAC0, A_EXTOUT(A_EXTOUT_AREAR_L), A_C_00000000,
1346                         A_GPR(16), A_GPR(0), &pc);
1347         audigy_addefxop(sc, iMAC0, A_EXTOUT(A_EXTOUT_AREAR_R), A_C_00000000,
1348                         A_GPR(17), A_GPR(1), &pc);
1349
1350         /* Digital Rear[l/r] = (GPR[0/1] * RearVolume[l/r]) >> 31 */
1351         /*   RearVolume = GPR[0x10/0x11] (Will this ever be implemented?) */
1352         audigy_addefxop(sc, iMAC0, A_EXTOUT(A_EXTOUT_REAR_L), A_C_00000000,
1353                         A_GPR(16), A_GPR(0), &pc);
1354         audigy_addefxop(sc, iMAC0, A_EXTOUT(A_EXTOUT_REAR_R), A_C_00000000,
1355                         A_GPR(17), A_GPR(1), &pc);
1356 #else
1357         /* XXX This is just a copy to the channel, since we do not have
1358          *     a patch manager, it is useful for have another output enabled.
1359          */
1360
1361         /* Analog Rear[l/r] = GPR[0/1] */
1362         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AREAR_L), A_C_00000000,
1363                         A_C_00000000, A_GPR(0), &pc);
1364         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_AREAR_R), A_C_00000000,
1365                         A_C_00000000, A_GPR(1), &pc);
1366
1367         /* Digital Rear[l/r] = GPR[0/1] */
1368         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_REAR_L), A_C_00000000,
1369                         A_C_00000000, A_GPR(0), &pc);
1370         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_REAR_R), A_C_00000000,
1371                         A_C_00000000, A_GPR(1), &pc);
1372 #endif
1373
1374         /* ADC Recording buffer[l/r] = AC97Input[l/r] */
1375         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_ADC_CAP_L), A_C_00000000,
1376                         A_C_00000000, A_EXTIN(A_EXTIN_AC97_L), &pc);
1377         audigy_addefxop(sc, iACC3, A_EXTOUT(A_EXTOUT_ADC_CAP_R), A_C_00000000,
1378                         A_C_00000000, A_EXTIN(A_EXTIN_AC97_R), &pc);
1379
1380         /* resume normal operations */
1381         emu_wrptr(sc, 0, A_DBG, 0);
1382 }
1383
1384 static void
1385 emu_initefx(struct sc_info *sc)
1386 {
1387         int i;
1388         u_int32_t pc = 16;
1389
1390         /* acc3 0,0,0,0 - NOPs */
1391         for (i = 0; i < 512; i++) {
1392                 emu_wrefx(sc, i * 2, 0x10040);
1393                 emu_wrefx(sc, i * 2 + 1, 0x610040);
1394         }
1395
1396         for (i = 0; i < 256; i++)
1397                 emu_wrptr(sc, 0, FXGPREGBASE + i, 0);
1398
1399         /* FX-8010 DSP Registers:
1400            FX Bus
1401              0x000-0x00f : 16 registers
1402            Input
1403              0x010/0x011 : AC97 Codec (l/r)
1404              0x012/0x013 : ADC, S/PDIF (l/r)
1405              0x014/0x015 : Mic(left), Zoom (l/r)
1406              0x016/0x017 : TOS link in (l/r)
1407              0x018/0x019 : Line/Mic 1 (l/r)
1408              0x01a/0x01b : COAX S/PDIF (l/r)
1409              0x01c/0x01d : Line/Mic 2 (l/r)
1410            Output
1411              0x020/0x021 : AC97 Output (l/r)
1412              0x022/0x023 : TOS link out (l/r)
1413              0x024/0x025 : Center/LFE
1414              0x026/0x027 : LiveDrive Headphone (l/r)
1415              0x028/0x029 : Rear Channel (l/r)
1416              0x02a/0x02b : ADC Recording Buffer (l/r)
1417              0x02c       : Mic Recording Buffer
1418              0x031/0x032 : Analog Center/LFE
1419            Constants
1420              0x040 - 0x044 = 0 - 4
1421              0x045 = 0x8, 0x046 = 0x10, 0x047 = 0x20
1422              0x048 = 0x100, 0x049 = 0x10000, 0x04a = 0x80000
1423              0x04b = 0x10000000, 0x04c = 0x20000000, 0x04d = 0x40000000
1424              0x04e = 0x80000000, 0x04f = 0x7fffffff, 0x050 = 0xffffffff
1425              0x051 = 0xfffffffe, 0x052 = 0xc0000000, 0x053 = 0x41fbbcdc
1426              0x054 = 0x5a7ef9db, 0x055 = 0x00100000
1427            Temporary Values
1428              0x056 : Accumulator
1429              0x057 : Condition Register
1430              0x058 : Noise source
1431              0x059 : Noise source
1432              0x05a : IRQ Register
1433              0x05b : TRAM Delay Base Address Count
1434            General Purpose Registers
1435              0x100 - 0x1ff
1436            Tank Memory Data Registers
1437              0x200 - 0x2ff
1438            Tank Memory Address Registers
1439              0x300 - 0x3ff
1440          */
1441
1442         /* Routing - this will be configurable in later version */
1443
1444         /* GPR[0/1] = FX * 4 + SPDIF-in */
1445         emu_addefxop(sc, iMACINT0, GPR(0), EXTIN(EXTIN_SPDIF_CD_L),
1446                         FXBUS(FXBUS_PCM_LEFT), C_00000004, &pc);
1447         emu_addefxop(sc, iMACINT0, GPR(1), EXTIN(EXTIN_SPDIF_CD_R),
1448                         FXBUS(FXBUS_PCM_RIGHT), C_00000004, &pc);
1449
1450         /* GPR[0/1] += APS-input */
1451         emu_addefxop(sc, iACC3, GPR(0), GPR(0), C_00000000,
1452                         sc->APS ? EXTIN(EXTIN_TOSLINK_L) : C_00000000, &pc);
1453         emu_addefxop(sc, iACC3, GPR(1), GPR(1), C_00000000,
1454                         sc->APS ? EXTIN(EXTIN_TOSLINK_R) : C_00000000, &pc);
1455
1456         /* FrontOut (AC97) = GPR[0/1] */
1457         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_AC97_L), C_00000000,
1458                         C_00000000, GPR(0), &pc);
1459         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_AC97_R), C_00000000,
1460                         C_00000001, GPR(1), &pc);
1461
1462         /* GPR[2] = GPR[0] (Left) / 2 + GPR[1] (Right) / 2 -- Central volume */
1463         emu_addefxop(sc, iINTERP, GPR(2), GPR(1), C_40000000, GPR(0), &pc);
1464
1465 #if 0
1466         /* RearOut = (GPR[0/1] * RearVolume) >> 31 */
1467         /*   RearVolume = GPR[0x10/0x11] */
1468         emu_addefxop(sc, iMAC0, EXTOUT(EXTOUT_REAR_L), C_00000000,
1469                         GPR(16), GPR(0), &pc);
1470         emu_addefxop(sc, iMAC0, EXTOUT(EXTOUT_REAR_R), C_00000000,
1471                         GPR(17), GPR(1), &pc);
1472 #else
1473         /* XXX This is just a copy to the channel, since we do not have
1474          *     a patch manager, it is useful for have another output enabled.
1475          */
1476
1477         /* Rear[l/r] = GPR[0/1] */
1478         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_REAR_L), C_00000000,
1479                         C_00000000, GPR(0), &pc);
1480         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_REAR_R), C_00000000,
1481                         C_00000000, GPR(1), &pc);
1482 #endif
1483
1484         /* TOS out[l/r] = GPR[0/1] */
1485         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_TOSLINK_L), C_00000000,
1486                         C_00000000, GPR(0), &pc);
1487         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_TOSLINK_R), C_00000000,
1488                         C_00000000, GPR(1), &pc);
1489
1490         /* Center and Subwoofer configuration */
1491         /* Analog Center = GPR[0] + GPR[2] */
1492         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_ACENTER), C_00000000,
1493                         GPR(0), GPR(2), &pc);
1494         /* Analog Sub = GPR[1] + GPR[2] */
1495         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_ALFE), C_00000000,
1496                         GPR(1), GPR(2), &pc);
1497         /* Digital Center = GPR[0] + GPR[2] */
1498         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_CENTER), C_00000000,
1499                         GPR(0), GPR(2), &pc);
1500         /* Digital Sub = GPR[1] + GPR[2] */
1501         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_LFE), C_00000000,
1502                         GPR(1), GPR(2), &pc);
1503
1504         /* Headphones[l/r] = GPR[0/1] */
1505         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_HEADPHONE_L), C_00000000,
1506                         C_00000000, GPR(0), &pc);
1507         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_HEADPHONE_R), C_00000000,
1508                         C_00000000, GPR(1), &pc);
1509
1510         /* ADC Recording buffer[l/r] = AC97Input[l/r] */
1511         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_ADC_CAP_L), C_00000000,
1512                         C_00000000, EXTIN(EXTIN_AC97_L), &pc);
1513         emu_addefxop(sc, iACC3, EXTOUT(EXTOUT_ADC_CAP_R), C_00000000,
1514                         C_00000000, EXTIN(EXTIN_AC97_R), &pc);
1515
1516         /* resume normal operations */
1517         emu_wrptr(sc, 0, DBG, 0);
1518 }
1519
1520 /* Probe and attach the card */
1521 static int
1522 emu_init(struct sc_info *sc)
1523 {
1524         u_int32_t spcs, ch, tmp, i;
1525
1526         /* enable additional AC97 slots */
1527         emu_wrptr(sc, 0, AC97SLOT, AC97SLOT_CNTR | AC97SLOT_LFE);
1528
1529         /* disable audio and lock cache */
1530         emu_wr(sc, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE | HCFG_MUTEBUTTONENABLE, 4);
1531
1532         /* reset recording buffers */
1533         emu_wrptr(sc, 0, MICBS, ADCBS_BUFSIZE_NONE);
1534         emu_wrptr(sc, 0, MICBA, 0);
1535         emu_wrptr(sc, 0, FXBS, ADCBS_BUFSIZE_NONE);
1536         emu_wrptr(sc, 0, FXBA, 0);
1537         emu_wrptr(sc, 0, ADCBS, ADCBS_BUFSIZE_NONE);
1538         emu_wrptr(sc, 0, ADCBA, 0);
1539
1540         /* disable channel interrupt */
1541         emu_wr(sc, INTE, INTE_INTERVALTIMERENB | INTE_SAMPLERATETRACKER | INTE_PCIERRORENABLE, 4);
1542         emu_wrptr(sc, 0, CLIEL, 0);
1543         emu_wrptr(sc, 0, CLIEH, 0);
1544         emu_wrptr(sc, 0, SOLEL, 0);
1545         emu_wrptr(sc, 0, SOLEH, 0);
1546
1547         /* wonder what these do... */
1548         if (sc->audigy) {
1549                 emu_wrptr(sc, 0, SPBYPASS, 0xf00);
1550                 emu_wrptr(sc, 0, AC97SLOT, 0x3);
1551         }
1552
1553         /* init envelope engine */
1554         for (ch = 0; ch < NUM_G; ch++) {
1555                 emu_wrptr(sc, ch, DCYSUSV, ENV_OFF);
1556                 emu_wrptr(sc, ch, IP, 0);
1557                 emu_wrptr(sc, ch, VTFT, 0xffff);
1558                 emu_wrptr(sc, ch, CVCF, 0xffff);
1559                 emu_wrptr(sc, ch, PTRX, 0);
1560                 emu_wrptr(sc, ch, CPF, 0);
1561                 emu_wrptr(sc, ch, CCR, 0);
1562
1563                 emu_wrptr(sc, ch, PSST, 0);
1564                 emu_wrptr(sc, ch, DSL, 0x10);
1565                 emu_wrptr(sc, ch, CCCA, 0);
1566                 emu_wrptr(sc, ch, Z1, 0);
1567                 emu_wrptr(sc, ch, Z2, 0);
1568                 emu_wrptr(sc, ch, FXRT, 0xd01c0000);
1569
1570                 emu_wrptr(sc, ch, ATKHLDM, 0);
1571                 emu_wrptr(sc, ch, DCYSUSM, 0);
1572                 emu_wrptr(sc, ch, IFATN, 0xffff);
1573                 emu_wrptr(sc, ch, PEFE, 0);
1574                 emu_wrptr(sc, ch, FMMOD, 0);
1575                 emu_wrptr(sc, ch, TREMFRQ, 24); /* 1 Hz */
1576                 emu_wrptr(sc, ch, FM2FRQ2, 24); /* 1 Hz */
1577                 emu_wrptr(sc, ch, TEMPENV, 0);
1578
1579                 /*** these are last so OFF prevents writing ***/
1580                 emu_wrptr(sc, ch, LFOVAL2, 0);
1581                 emu_wrptr(sc, ch, LFOVAL1, 0);
1582                 emu_wrptr(sc, ch, ATKHLDV, 0);
1583                 emu_wrptr(sc, ch, ENVVOL, 0);
1584                 emu_wrptr(sc, ch, ENVVAL, 0);
1585
1586                 if (sc->audigy) {
1587                         /* audigy cards need this to initialize correctly */
1588                         emu_wrptr(sc, ch, 0x4c, 0);
1589                         emu_wrptr(sc, ch, 0x4d, 0);
1590                         emu_wrptr(sc, ch, 0x4e, 0);
1591                         emu_wrptr(sc, ch, 0x4f, 0);
1592                         /* set default routing */
1593                         emu_wrptr(sc, ch, A_FXRT1, 0x03020100);
1594                         emu_wrptr(sc, ch, A_FXRT2, 0x3f3f3f3f);
1595                         emu_wrptr(sc, ch, A_SENDAMOUNTS, 0);
1596                 }
1597
1598                 sc->voice[ch].vnum = ch;
1599                 sc->voice[ch].slave = NULL;
1600                 sc->voice[ch].busy = 0;
1601                 sc->voice[ch].ismaster = 0;
1602                 sc->voice[ch].running = 0;
1603                 sc->voice[ch].b16 = 0;
1604                 sc->voice[ch].stereo = 0;
1605                 sc->voice[ch].speed = 0;
1606                 sc->voice[ch].start = 0;
1607                 sc->voice[ch].end = 0;
1608                 sc->voice[ch].channel = NULL;
1609        }
1610        sc->pnum = sc->rnum = 0;
1611
1612         /*
1613          *  Init to 0x02109204 :
1614          *  Clock accuracy    = 0     (1000ppm)
1615          *  Sample Rate       = 2     (48kHz)
1616          *  Audio Channel     = 1     (Left of 2)
1617          *  Source Number     = 0     (Unspecified)
1618          *  Generation Status = 1     (Original for Cat Code 12)
1619          *  Cat Code          = 12    (Digital Signal Mixer)
1620          *  Mode              = 0     (Mode 0)
1621          *  Emphasis          = 0     (None)
1622          *  CP                = 1     (Copyright unasserted)
1623          *  AN                = 0     (Audio data)
1624          *  P                 = 0     (Consumer)
1625          */
1626         spcs = SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1627                SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1628                SPCS_GENERATIONSTATUS | 0x00001200 | 0x00000000 |
1629                SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT;
1630         emu_wrptr(sc, 0, SPCS0, spcs);
1631         emu_wrptr(sc, 0, SPCS1, spcs);
1632         emu_wrptr(sc, 0, SPCS2, spcs);
1633
1634         if (!sc->audigy)
1635                 emu_initefx(sc);
1636         else if (sc->audigy2) { /* Audigy 2 */
1637                 /* from ALSA initialization code: */
1638
1639                 /* Hack for Alice3 to work independent of haP16V driver */
1640                 u_int32_t tmp;
1641
1642                 /* Setup SRCMulti_I2S SamplingRate */
1643                 tmp = emu_rdptr(sc, 0, A_SPDIF_SAMPLERATE) & 0xfffff1ff;
1644                 emu_wrptr(sc, 0, A_SPDIF_SAMPLERATE, tmp | 0x400);
1645
1646                 /* Setup SRCSel (Enable SPDIF, I2S SRCMulti) */
1647                 emu_wr(sc, 0x20, 0x00600000, 4);
1648                 emu_wr(sc, 0x24, 0x00000014, 4);
1649
1650                 /* Setup SRCMulti Input Audio Enable */
1651                 emu_wr(sc, 0x20, 0x006e0000, 4);
1652                 emu_wr(sc, 0x24, 0xff00ff00, 4);
1653         }
1654
1655         SLIST_INIT(&sc->mem.blocks);
1656         sc->mem.ptb_pages = emu_malloc(sc, MAXPAGES * sizeof(u_int32_t));
1657         if (sc->mem.ptb_pages == NULL)
1658                 return -1;
1659
1660         sc->mem.silent_page = emu_malloc(sc, EMUPAGESIZE);
1661         if (sc->mem.silent_page == NULL) {
1662                 emu_free(sc, sc->mem.ptb_pages);
1663                 return -1;
1664         }
1665         /* Clear page with silence & setup all pointers to this page */
1666         bzero(sc->mem.silent_page, EMUPAGESIZE);
1667         tmp = (u_int32_t)vtophys(sc->mem.silent_page) << 1;
1668         for (i = 0; i < MAXPAGES; i++)
1669                 sc->mem.ptb_pages[i] = tmp | i;
1670
1671         emu_wrptr(sc, 0, PTB, vtophys(sc->mem.ptb_pages));
1672         emu_wrptr(sc, 0, TCB, 0);       /* taken from original driver */
1673         emu_wrptr(sc, 0, TCBS, 0);      /* taken from original driver */
1674
1675         for (ch = 0; ch < NUM_G; ch++) {
1676                 emu_wrptr(sc, ch, MAPA, tmp | MAP_PTI_MASK);
1677                 emu_wrptr(sc, ch, MAPB, tmp | MAP_PTI_MASK);
1678         }
1679
1680         /* emu_memalloc(sc, EMUPAGESIZE); */
1681         /*
1682          *  Hokay, now enable the AUD bit
1683          *
1684          *  Audigy
1685          *   Enable Audio = 0 (enabled after fx processor initialization)
1686          *   Mute Disable Audio = 0
1687          *   Joystick = 1
1688          *
1689          *  Audigy 2
1690          *   Enable Audio = 1
1691          *   Mute Disable Audio = 0
1692          *   Joystick = 1
1693          *   GP S/PDIF AC3 Enable = 1
1694          *   CD S/PDIF AC3 Enable = 1
1695          *
1696          *  EMU10K1
1697          *   Enable Audio = 1
1698          *   Mute Disable Audio = 0
1699          *   Lock Tank Memory = 1
1700          *   Lock Sound Memory = 0
1701          *   Auto Mute = 1
1702          */
1703         if (sc->audigy) {
1704                 tmp = HCFG_AUTOMUTE | HCFG_JOYENABLE;
1705                 if (sc->audigy2) /* Audigy 2 */
1706                         tmp = HCFG_AUDIOENABLE | HCFG_AC3ENABLE_CDSPDIF |
1707                                 HCFG_AC3ENABLE_GPSPDIF;
1708                 emu_wr(sc, HCFG, tmp, 4);
1709
1710                 audigy_initefx(sc);
1711
1712                 /* from ALSA initialization code: */
1713
1714                 /* enable audio and disable both audio/digital outputs */
1715                 emu_wr(sc, HCFG, emu_rd(sc, HCFG, 4) | HCFG_AUDIOENABLE, 4);
1716                 emu_wr(sc, A_IOCFG, emu_rd(sc, A_IOCFG, 4) & ~A_IOCFG_GPOUT_AD, 4);
1717                 if (sc->audigy2) { /* Audigy 2 */
1718                         /* Unmute Analog.  Set GPO6 to 1 for Apollo.
1719                          * This has to be done after init Alice3 I2SOut beyond 48kHz.
1720                          * So, sequence is important.
1721                          */
1722                         emu_wr(sc, A_IOCFG, emu_rd(sc, A_IOCFG, 4) | A_IOCFG_GPOUT_A, 4);
1723                 }
1724         } else {
1725                 /* EMU10K1 initialization code */
1726                 tmp = HCFG_AUDIOENABLE | HCFG_AUTOMUTE | HCFG_LOCKTANKCACHE;
1727                 if (sc->rev >= 6)
1728                         tmp |= HCFG_JOYENABLE;
1729
1730                 emu_wr(sc, HCFG, tmp, 4);
1731
1732                 /* TOSLink detection */
1733                 sc->tos_link = 0;
1734                 tmp = emu_rd(sc, HCFG, 4);
1735                 if (tmp & (HCFG_GPINPUT0 | HCFG_GPINPUT1)) {
1736                         emu_wr(sc, HCFG, tmp | HCFG_GPOUT1, 4);
1737                         DELAY(50);
1738                         if (tmp != (emu_rd(sc, HCFG, 4) & ~HCFG_GPOUT1)) {
1739                                 sc->tos_link = 1;
1740                                 emu_wr(sc, HCFG, tmp, 4);
1741                         }
1742                 }
1743         }
1744
1745         return 0;
1746 }
1747
1748 static int
1749 emu_uninit(struct sc_info *sc)
1750 {
1751         u_int32_t ch;
1752
1753         emu_wr(sc, INTE, 0, 4);
1754         for (ch = 0; ch < NUM_G; ch++)
1755                 emu_wrptr(sc, ch, DCYSUSV, ENV_OFF);
1756         for (ch = 0; ch < NUM_G; ch++) {
1757                 emu_wrptr(sc, ch, VTFT, 0);
1758                 emu_wrptr(sc, ch, CVCF, 0);
1759                 emu_wrptr(sc, ch, PTRX, 0);
1760                 emu_wrptr(sc, ch, CPF, 0);
1761         }
1762
1763         if (sc->audigy) {
1764                 /* stop fx processor */
1765                 emu_wrptr(sc, 0, A_DBG, A_DBG_SINGLE_STEP);
1766         }
1767
1768         /* disable audio and lock cache */
1769         emu_wr(sc, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE | HCFG_MUTEBUTTONENABLE, 4);
1770
1771         emu_wrptr(sc, 0, PTB, 0);
1772         /* reset recording buffers */
1773         emu_wrptr(sc, 0, MICBS, ADCBS_BUFSIZE_NONE);
1774         emu_wrptr(sc, 0, MICBA, 0);
1775         emu_wrptr(sc, 0, FXBS, ADCBS_BUFSIZE_NONE);
1776         emu_wrptr(sc, 0, FXBA, 0);
1777         emu_wrptr(sc, 0, FXWC, 0);
1778         emu_wrptr(sc, 0, ADCBS, ADCBS_BUFSIZE_NONE);
1779         emu_wrptr(sc, 0, ADCBA, 0);
1780         emu_wrptr(sc, 0, TCB, 0);
1781         emu_wrptr(sc, 0, TCBS, 0);
1782
1783         /* disable channel interrupt */
1784         emu_wrptr(sc, 0, CLIEL, 0);
1785         emu_wrptr(sc, 0, CLIEH, 0);
1786         emu_wrptr(sc, 0, SOLEL, 0);
1787         emu_wrptr(sc, 0, SOLEH, 0);
1788
1789
1790         /* init envelope engine */
1791         if (!SLIST_EMPTY(&sc->mem.blocks))
1792                 device_printf(sc->dev, "warning: memblock list not empty\n");
1793         emu_free(sc, sc->mem.ptb_pages);
1794         emu_free(sc, sc->mem.silent_page);
1795
1796         return 0;
1797 }
1798
1799 static int
1800 emu_pci_probe(device_t dev)
1801 {
1802         char *s = NULL;
1803
1804         switch (pci_get_devid(dev)) {
1805         case EMU10K1_PCI_ID:
1806                 s = "Creative EMU10K1";
1807                 break;
1808
1809         case EMU10K1X_PCI_ID:
1810                 s = "Creative SB Live! (Dell OEM)";
1811                 break;
1812
1813         case EMU10K2_PCI_ID:
1814                 if (pci_get_revid(dev) == 0x04)
1815                         s = "Creative Audigy 2 (EMU10K2)";
1816                 else
1817                         s = "Creative Audigy (EMU10K2)";
1818                 break;
1819
1820         default:
1821                 return ENXIO;
1822         }
1823
1824         device_set_desc(dev, s);
1825         return 0;
1826 }
1827
1828 static int
1829 emu_pci_attach(device_t dev)
1830 {
1831         struct ac97_info *codec = NULL;
1832         struct sc_info *sc;
1833         u_int32_t data;
1834         int i, gotmic;
1835         char status[SND_STATUSLEN];
1836
1837         if ((sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO)) == NULL) {
1838                 device_printf(dev, "cannot allocate softc\n");
1839                 return ENXIO;
1840         }
1841
1842         sc->lock = snd_mtxcreate(device_get_nameunit(dev), "sound softc");
1843         sc->dev = dev;
1844         sc->type = pci_get_devid(dev);
1845         sc->rev = pci_get_revid(dev);
1846         sc->audigy = (sc->type == EMU10K2_PCI_ID);
1847         sc->audigy2 = (sc->audigy && sc->rev == 0x04);
1848         sc->nchans = sc->audigy ? 8 : 4;
1849         sc->addrmask = sc->audigy ? A_PTR_ADDRESS_MASK : PTR_ADDRESS_MASK;
1850
1851         data = pci_read_config(dev, PCIR_COMMAND, 2);
1852         data |= (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN);
1853         pci_write_config(dev, PCIR_COMMAND, data, 2);
1854         data = pci_read_config(dev, PCIR_COMMAND, 2);
1855
1856         i = PCIR_MAPS;
1857         sc->reg = bus_alloc_resource(dev, SYS_RES_IOPORT, &i, 0, ~0, 1, RF_ACTIVE);
1858         if (sc->reg == NULL) {
1859                 device_printf(dev, "unable to map register space\n");
1860                 goto bad;
1861         }
1862         sc->st = rman_get_bustag(sc->reg);
1863         sc->sh = rman_get_bushandle(sc->reg);
1864
1865         sc->bufsz = pcm_getbuffersize(dev, 4096, EMU_DEFAULT_BUFSZ, 65536);
1866
1867         if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
1868                 /*lowaddr*/1 << 31, /* can only access 0-2gb */
1869                 /*highaddr*/BUS_SPACE_MAXADDR,
1870                 /*filter*/NULL, /*filterarg*/NULL,
1871                 /*maxsize*/sc->bufsz, /*nsegments*/1, /*maxsegz*/0x3ffff,
1872                 /*flags*/0, &sc->parent_dmat) != 0) {
1873                 device_printf(dev, "unable to create dma tag\n");
1874                 goto bad;
1875         }
1876
1877         if (emu_init(sc) == -1) {
1878                 device_printf(dev, "unable to initialize the card\n");
1879                 goto bad;
1880         }
1881
1882         codec = AC97_CREATE(dev, sc, emu_ac97);
1883         if (codec == NULL) goto bad;
1884         gotmic = (ac97_getcaps(codec) & AC97_CAP_MICCHANNEL)? 1 : 0;
1885         if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto bad;
1886
1887         i = 0;
1888         sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &i, 0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
1889         if (!sc->irq || snd_setup_intr(dev, sc->irq, INTR_MPSAFE, emu_intr, sc, &sc->ih)) {
1890                 device_printf(dev, "unable to map interrupt\n");
1891                 goto bad;
1892         }
1893
1894         snprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld", rman_get_start(sc->reg), rman_get_start(sc->irq));
1895
1896         if (pcm_register(dev, sc, sc->nchans, gotmic? 3 : 2)) goto bad;
1897         for (i = 0; i < sc->nchans; i++)
1898                 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
1899         for (i = 0; i < (gotmic? 3 : 2); i++)
1900                 pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc);
1901
1902         pcm_setstatus(dev, status);
1903
1904         return 0;
1905
1906 bad:
1907         if (codec) ac97_destroy(codec);
1908         if (sc->reg) bus_release_resource(dev, SYS_RES_IOPORT, PCIR_MAPS, sc->reg);
1909         if (sc->ih) bus_teardown_intr(dev, sc->irq, sc->ih);
1910         if (sc->irq) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
1911         if (sc->parent_dmat) bus_dma_tag_destroy(sc->parent_dmat);
1912         if (sc->lock) snd_mtxfree(sc->lock);
1913         free(sc, M_DEVBUF);
1914         return ENXIO;
1915 }
1916
1917 static int
1918 emu_pci_detach(device_t dev)
1919 {
1920         int r;
1921         struct sc_info *sc;
1922
1923         r = pcm_unregister(dev);
1924         if (r)
1925                 return r;
1926
1927         sc = pcm_getdevinfo(dev);
1928         /* shutdown chip */
1929         emu_uninit(sc);
1930
1931         bus_release_resource(dev, SYS_RES_IOPORT, PCIR_MAPS, sc->reg);
1932         bus_teardown_intr(dev, sc->irq, sc->ih);
1933         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
1934         bus_dma_tag_destroy(sc->parent_dmat);
1935         snd_mtxfree(sc->lock);
1936         free(sc, M_DEVBUF);
1937
1938         return 0;
1939 }
1940
1941 /* add suspend, resume */
1942 static device_method_t emu_methods[] = {
1943         /* Device interface */
1944         DEVMETHOD(device_probe,         emu_pci_probe),
1945         DEVMETHOD(device_attach,        emu_pci_attach),
1946         DEVMETHOD(device_detach,        emu_pci_detach),
1947
1948         { 0, 0 }
1949 };
1950
1951 static driver_t emu_driver = {
1952         "pcm",
1953         emu_methods,
1954         PCM_SOFTC_SIZE,
1955 };
1956
1957 DRIVER_MODULE(snd_emu10k1, pci, emu_driver, pcm_devclass, 0, 0);
1958 MODULE_DEPEND(snd_emu10k1, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
1959 MODULE_VERSION(snd_emu10k1, 1);
1960
1961 /* dummy driver to silence the joystick device */
1962 static int
1963 emujoy_pci_probe(device_t dev)
1964 {
1965         char *s = NULL;
1966
1967         switch (pci_get_devid(dev)) {
1968         case 0x70021102:
1969                 s = "Creative EMU10K1 Joystick";
1970                 device_quiet(dev);
1971                 break;
1972         case 0x70031102:
1973                 s = "Creative EMU10K2 Joystick";
1974                 device_quiet(dev);
1975                 break;
1976         }
1977
1978         if (s) device_set_desc(dev, s);
1979         return s? -1000 : ENXIO;
1980 }
1981
1982 static int
1983 emujoy_pci_attach(device_t dev)
1984 {
1985         return 0;
1986 }
1987
1988 static int
1989 emujoy_pci_detach(device_t dev)
1990 {
1991         return 0;
1992 }
1993
1994 static device_method_t emujoy_methods[] = {
1995         DEVMETHOD(device_probe,         emujoy_pci_probe),
1996         DEVMETHOD(device_attach,        emujoy_pci_attach),
1997         DEVMETHOD(device_detach,        emujoy_pci_detach),
1998
1999         { 0, 0 }
2000 };
2001
2002 static driver_t emujoy_driver = {
2003         "emujoy",
2004         emujoy_methods,
2005         8,
2006 };
2007
2008 static devclass_t emujoy_devclass;
2009
2010 DRIVER_MODULE(emujoy, pci, emujoy_driver, emujoy_devclass, 0, 0);
2011