sys/dev/sound/pci/emu10kx.c

   1 /*-
   2  * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
   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$
  28  */
  29
  30 #include <sys/param.h>
  31 #include <sys/types.h>
  32 #include <sys/bus.h>
  33 #include <machine/bus.h>
  34 #include <sys/rman.h>
  35 #include <sys/systm.h>
  36 #include <sys/sbuf.h>
  37 #include <sys/queue.h>
  38 #include <sys/lock.h>
  39 #include <sys/mutex.h>
  40 #include <sys/sysctl.h>
  41 #include <sys/kdb.h>
  42
  43 #include <dev/pci/pcireg.h>
  44 #include <dev/pci/pcivar.h>
  45
  46 #include <machine/clock.h>      /* for DELAY */
  47
  48 #include <dev/sound/chip.h>
  49 #include <dev/sound/pcm/sound.h>
  50 #include <dev/sound/pcm/ac97.h>
  51
  52 #include <dev/sound/pci/emu10kx.h>
  53
  54 /* hw flags */
  55 #define HAS_51          0x0001
  56 #define HAS_71          0x0002
  57 #define HAS_AC97        0x0004
  58
  59 #define IS_EMU10K1      0x0008
  60 #define IS_EMU10K2      0x0010
  61 #define IS_CA0102       0x0020
  62 #define IS_CA0108       0x0040
  63 #define IS_UNKNOWN      0x0080
  64
  65 #define BROKEN_DIGITAL  0x0100
  66 #define DIGITAL_ONLY    0x0200
  67
  68 #define IS_CARDBUS      0x0400
  69
  70 #define MODE_ANALOG     1
  71 #define MODE_DIGITAL    2
  72 #define SPDIF_MODE_PCM  1
  73 #define SPDIF_MODE_AC3  2
  74
  75 #define MACS    0x0
  76 #define MACS1   0x1
  77 #define MACW    0x2
  78 #define MACW1   0x3
  79 #define MACINTS 0x4
  80 #define MACINTW 0x5
  81 #define ACC3    0x6
  82 #define MACMV   0x7
  83 #define ANDXOR  0x8
  84 #define TSTNEG  0x9
  85 #define LIMIT   0xA
  86 #define LIMIT1  0xB
  87 #define LOG     0xC
  88 #define EXP     0xD
  89 #define INTERP  0xE
  90 #define SKIP    0xF
  91
  92 #define GPR(i)  (sc->gpr_base+(i))
  93 #define INP(i)  (sc->input_base+(i))
  94 #define OUTP(i) (sc->output_base+(i))
  95 #define FX(i)   (i)
  96 #define FX2(i)  (sc->efxc_base+(i))
  97 #define DSP_CONST(i) (sc->dsp_zero+(i))
  98
  99 #define COND_NORMALIZED DSP_CONST(0x1)
 100 #define COND_BORROW     DSP_CONST(0x2)
 101 #define COND_MINUS      DSP_CONST(0x3)
 102 #define COND_LESS_ZERO  DSP_CONST(0x4)
 103 #define COND_EQ_ZERO    DSP_CONST(0x5)
 104 #define COND_SATURATION DSP_CONST(0x6)
 105 #define COND_NEQ_ZERO   DSP_CONST(0x8)
 106
 107 #define DSP_ACCUM       DSP_CONST(0x16)
 108 #define DSP_CCR         DSP_CONST(0x17)
 109
 110 /* Live! Inputs */
 111 #define IN_AC97_L       0x00
 112 #define IN_AC97_R       0x01
 113 #define IN_AC97         IN_AC97_L
 114 #define IN_SPDIF_CD_L   0x02
 115 #define IN_SPDIF_CD_R   0x03
 116 #define IN_SPDIF_CD     IN_SPDIF_CD_L
 117 #define IN_ZOOM_L       0x04
 118 #define IN_ZOOM_R       0x05
 119 #define IN_ZOOM         IN_ZOOM_L
 120 #define IN_TOSLINK_L    0x06
 121 #define IN_TOSLINK_R    0x07
 122 #define IN_TOSLINK      IN_TOSLINK_L
 123 #define IN_LINE1_L      0x08
 124 #define IN_LINE1_R      0x09
 125 #define IN_LINE1        IN_LINE1_L
 126 #define IN_COAX_SPDIF_L 0x0a
 127 #define IN_COAX_SPDIF_R 0x0b
 128 #define IN_COAX_SPDIF   IN_COAX_SPDIF_L
 129 #define IN_LINE2_L      0x0c
 130 #define IN_LINE2_R      0x0d
 131 #define IN_LINE2        IN_LINE2_L
 132 #define IN_0E           0x0e
 133 #define IN_0F           0x0f
 134
 135 /* Outputs */
 136 #define OUT_AC97_L      0x00
 137 #define OUT_AC97_R      0x01
 138 #define OUT_AC97        OUT_AC97_L
 139 #define OUT_A_FRONT     OUT_AC97
 140 #define OUT_TOSLINK_L   0x02
 141 #define OUT_TOSLINK_R   0x03
 142 #define OUT_TOSLINK     OUT_TOSLINK_L
 143 #define OUT_D_CENTER    0x04
 144 #define OUT_D_SUB       0x05
 145 #define OUT_HEADPHONE_L 0x06
 146 #define OUT_HEADPHONE_R 0x07
 147 #define OUT_HEADPHONE   OUT_HEADPHONE_L
 148 #define OUT_REAR_L      0x08
 149 #define OUT_REAR_R      0x09
 150 #define OUT_REAR        OUT_REAR_L
 151 #define OUT_ADC_REC_L   0x0a
 152 #define OUT_ADC_REC_R   0x0b
 153 #define OUT_ADC_REC     OUT_ADC_REC_L
 154 #define OUT_MIC_CAP     0x0c
 155
 156 /* Live! 5.1 Digital, non-standart 5.1 (center & sub) outputs */
 157 #define OUT_A_CENTER    0x11
 158 #define OUT_A_SUB       0x12
 159
 160 /* Audigy Inputs */
 161 #define A_IN_AC97_L     0x00
 162 #define A_IN_AC97_R     0x01
 163 #define A_IN_AC97       A_IN_AC97_L
 164 #define A_IN_SPDIF_CD_L 0x02
 165 #define A_IN_SPDIF_CD_R 0x03
 166 #define A_IN_SPDIF_CD   A_IN_SPDIF_CD_L
 167 #define A_IN_O_SPDIF_L  0x04
 168 #define A_IN_O_SPDIF_R  0x05
 169 #define A_IN_O_SPDIF    A_IN_O_SPDIF_L
 170 #define A_IN_LINE2_L    0x08
 171 #define A_IN_LINE2_R    0x09
 172 #define A_IN_LINE2      A_IN_LINE2_L
 173 #define A_IN_R_SPDIF_L  0x0a
 174 #define A_IN_R_SPDIF_R  0x0b
 175 #define A_IN_R_SPDIF    A_IN_R_SPDIF_L
 176 #define A_IN_AUX2_L     0x0c
 177 #define A_IN_AUX2_R     0x0d
 178 #define A_IN_AUX2       A_IN_AUX2_L
 179
 180 /* Audigiy Outputs */
 181 #define A_OUT_D_FRONT_L 0x00
 182 #define A_OUT_D_FRONT_R 0x01
 183 #define A_OUT_D_FRONT   A_OUT_D_FRONT_L
 184 #define A_OUT_D_CENTER  0x02
 185 #define A_OUT_D_SUB     0x03
 186 #define A_OUT_D_SIDE_L  0x04
 187 #define A_OUT_D_SIDE_R  0x05
 188 #define A_OUT_D_SIDE    A_OUT_D_SIDE_L
 189 #define A_OUT_D_REAR_L  0x06
 190 #define A_OUT_D_REAR_R  0x07
 191 #define A_OUT_D_REAR    A_OUT_D_REAR_L
 192
 193 /* on Audigy Platinum only */
 194 #define A_OUT_HPHONE_L  0x04
 195 #define A_OUT_HPHONE_R  0x05
 196 #define A_OUT_HPHONE    A_OUT_HPHONE_L
 197
 198 #define A_OUT_A_FRONT_L 0x08
 199 #define A_OUT_A_FRONT_R 0x09
 200 #define A_OUT_A_FRONT   A_OUT_A_FRONT_L
 201 #define A_OUT_A_CENTER  0x0a
 202 #define A_OUT_A_SUB     0x0b
 203 #define A_OUT_A_SIDE_L  0x0c
 204 #define A_OUT_A_SIDE_R  0x0d
 205 #define A_OUT_A_SIDE    A_OUT_A_SIDE_L
 206 #define A_OUT_A_REAR_L  0x0e
 207 #define A_OUT_A_REAR_R  0x0f
 208 #define A_OUT_A_REAR    A_OUT_A_REAR_L
 209 #define A_OUT_AC97_L    0x10
 210 #define A_OUT_AC97_R    0x11
 211 #define A_OUT_AC97      A_OUT_AC97_L
 212 #define A_OUT_ADC_REC_L 0x16
 213 #define A_OUT_ADC_REC_R 0x17
 214 #define A_OUT_ADC_REC   A_OUT_ADC_REC_L
 215
 216 #include "emu10k1-alsa%diked.h"
 217 #include "p16v-alsa%diked.h"
 218 #include "p17v-alsa%diked.h"
 219
 220 #define C_FRONT_L       0
 221 #define C_FRONT_R       1
 222 #define C_REC_L         2
 223 #define C_REC_R         3
 224 #define C_REAR_L        4
 225 #define C_REAR_R        5
 226 #define C_CENTER        6
 227 #define C_SUB           7
 228 #define C_SIDE_L        8
 229 #define C_SIDE_R        9
 230 #define NUM_CACHES      10
 231
 232 #define CDSPDIFMUTE     0
 233 #define ANALOGMUTE      1
 234 #define NUM_MUTE        2
 235
 236 #define EMU_MAX_GPR     512
 237 #define EMU_MAX_IRQ_CONSUMERS 32
 238
 239 struct emu_voice {
 240         int     vnum;
 241         unsigned int    b16:1, stereo:1, busy:1, running:1, ismaster:1;
 242         int     speed;
 243         int     start;
 244         int     end;
 245         int     vol;
 246         uint32_t buf;
 247         void    *vbuf;
 248         struct emu_voice *slave;
 249         uint32_t sa;
 250         uint32_t ea;
 251         uint32_t routing[8];
 252         uint32_t amounts[8];
 253 };
 254
 255 struct emu_memblk {
 256         SLIST_ENTRY(emu_memblk) link;
 257         void            *buf;
 258         char            owner[16];
 259         bus_addr_t      buf_addr;
 260         uint32_t        pte_start, pte_size;
 261 };
 262
 263 struct emu_mem {
 264         uint8_t         bmap[EMU_MAXPAGES / 8];
 265         uint32_t        *ptb_pages;
 266         void            *silent_page;
 267         bus_addr_t      silent_page_addr;
 268         bus_addr_t      ptb_pages_addr;
 269         bus_dma_tag_t   dmat;
 270         struct emu_sc_info *card;
 271         SLIST_HEAD(, emu_memblk) blocks;
 272 };
 273
 274 /* rm */
 275 struct emu_rm {
 276         struct emu_sc_info *card;
 277         struct mtx      gpr_lock;
 278         signed int      allocmap[EMU_MAX_GPR];
 279         int             num_gprs;
 280         int             last_free_gpr;
 281         int             num_used;
 282 };
 283
 284 struct emu_intr_handler {
 285         void*           softc;
 286         uint32_t        intr_mask;
 287         uint32_t        inte_mask;
 288         uint32_t(*irq_func) (void *softc, uint32_t irq);
 289 };
 290
 291 struct emu_sc_info {
 292         struct mtx      lock;
 293         struct mtx      rw;             /* Hardware exclusive access lock */
 294
 295         /* Hardware and subdevices */
 296         device_t        dev;
 297         device_t        pcm[RT_COUNT];
 298         device_t        midi[2];
 299         uint32_t        type;
 300         uint32_t        rev;
 301
 302         bus_space_tag_t st;
 303         bus_space_handle_t sh;
 304
 305         struct cdev     *cdev;          /* /dev/emu10k character device */
 306         struct mtx      emu10kx_lock;
 307         int             emu10kx_isopen;
 308         struct sbuf     emu10kx_sbuf;
 309         int             emu10kx_bufptr;
 310
 311
 312         /* Resources */
 313         struct resource *reg;
 314         struct resource *irq;
 315         void            *ih;
 316
 317         /* IRQ handlers */
 318         struct emu_intr_handler ihandler[EMU_MAX_IRQ_CONSUMERS];
 319
 320         /* Card HW configuration */
 321         unsigned int    mode;   /* analog / digital */
 322         unsigned int    mchannel_fx;
 323         unsigned int    dsp_zero;
 324         unsigned int    code_base;
 325         unsigned int    code_size;
 326         unsigned int    gpr_base;
 327         unsigned int    num_gprs;
 328         unsigned int    input_base;
 329         unsigned int    output_base;
 330         unsigned int    efxc_base;
 331         unsigned int    opcode_shift;
 332         unsigned int    high_operand_shift;
 333         unsigned int    address_mask;
 334         uint32_t        is_emu10k1:1, is_emu10k2, is_ca0102, is_ca0108:1,
 335                         has_ac97:1, has_51:1, has_71:1,
 336                         enable_ir:1,
 337                         broken_digital:1, is_cardbus:1;
 338
 339         signed int      mch_disabled, mch_rec, dbg_level;
 340         signed int      num_inputs;
 341         unsigned int    num_outputs;
 342         unsigned int    num_fxbuses;
 343         unsigned int    routing_code_start;
 344         unsigned int    routing_code_end;
 345
 346         /* HW resources */
 347         struct emu_voice voice[NUM_G];                  /* Hardware voices */
 348         uint32_t        irq_mask[EMU_MAX_IRQ_CONSUMERS]; /* IRQ manager data */
 349         int             timer[EMU_MAX_IRQ_CONSUMERS];   /* timer */
 350         int             timerinterval;
 351         struct          emu_rm *rm;
 352         struct          emu_mem mem;                    /* memory */
 353
 354         /* Mixer */
 355         int             mixer_gpr[NUM_MIXERS];
 356         int             mixer_volcache[NUM_MIXERS];
 357         int             cache_gpr[NUM_CACHES];
 358         int             dummy_gpr;
 359         int             mute_gpr[NUM_MUTE];
 360         struct sysctl_ctx_list  *ctx;
 361         struct sysctl_oid       *root;
 362 };
 363
 364 static void     emu_setmap(void *arg, bus_dma_segment_t * segs, int nseg, int error);
 365 static void*    emu_malloc(struct emu_mem *mem, uint32_t sz, bus_addr_t * addr);
 366 static void     emu_free(struct emu_mem *mem, void *dmabuf);
 367 static void*    emu_memalloc(struct emu_mem *mem, uint32_t sz, bus_addr_t * addr, const char * owner);
 368 static int      emu_memfree(struct emu_mem *mem, void *membuf);
 369 static int      emu_memstart(struct emu_mem *mem, void *membuf);
 370
 371 /* /dev */
 372 static int      emu10kx_dev_init(struct emu_sc_info *sc);
 373 static int      emu10kx_dev_uninit(struct emu_sc_info *sc);
 374 static int      emu10kx_prepare(struct emu_sc_info *sc, struct sbuf *s);
 375
 376 static void     emumix_set_mode(struct emu_sc_info *sc, int mode);
 377 static void     emumix_set_spdif_mode(struct emu_sc_info *sc, int mode);
 378 static void     emumix_set_fxvol(struct emu_sc_info *sc, unsigned gpr, int32_t vol);
 379 static void     emumix_set_gpr(struct emu_sc_info *sc, unsigned gpr, int32_t val);
 380 static int      sysctl_emu_mixer_control(SYSCTL_HANDLER_ARGS);
 381
 382 static int      emu_rm_init(struct emu_sc_info *sc);
 383 static int      emu_rm_uninit(struct emu_sc_info *sc);
 384 static int      emu_rm_gpr_alloc(struct emu_rm *rm, int count);
 385
 386 static unsigned int emu_getcard(device_t dev);
 387 static uint32_t emu_rd_nolock(struct emu_sc_info *sc, unsigned int regno, unsigned int size);
 388 static void     emu_wr_nolock(struct emu_sc_info *sc, unsigned int regno, uint32_t data, unsigned int size);
 389 static void     emu_wr_cbptr(struct emu_sc_info *sc, uint32_t data);
 390
 391 static void     emu_vstop(struct emu_sc_info *sc, char channel, int enable);
 392
 393 static void     emu_intr(void *p);
 394 static void     emu_wrefx(struct emu_sc_info *sc, unsigned int pc, unsigned int data);
 395 static void     emu_addefxop(struct emu_sc_info *sc, unsigned int op, unsigned int z, unsigned int w, unsigned int x, unsigned int y, uint32_t * pc);
 396 static void     emu_initefx(struct emu_sc_info *sc);
 397
 398 static int      emu_cardbus_init(struct emu_sc_info *sc);
 399 static int      emu_init(struct emu_sc_info *sc);
 400 static int      emu_uninit(struct emu_sc_info *sc);
 401
 402 static int      emu_read_ivar(device_t bus __unused, device_t dev, int ivar_index, uintptr_t * result);
 403 static int      emu_write_ivar(device_t bus __unused, device_t dev __unused,
 404     int ivar_index, uintptr_t value __unused);
 405
 406 static int      emu_pci_probe(device_t dev);
 407 static int      emu_pci_attach(device_t dev);
 408 static int      emu_pci_detach(device_t dev);
 409 static int      emu_modevent(module_t mod __unused, int cmd, void *data __unused);
 410
 411 #ifdef  SND_EMU10KX_DEBUG
 412
 413 #define EMU_MTX_DEBUG() do {                                            \
 414                 if (mtx_owned(&sc->rw)) {                               \
 415                 printf("RW owned in %s line %d for %s\n", __func__,     \
 416                         __LINE__ , device_get_nameunit(sc->dev));       \
 417                 printf("rw lock owned: %d\n", mtx_owned(&sc->rw));      \
 418                 printf("rw lock: value %x thread %x\n",                 \
 419                         ((&sc->rw)->mtx_lock & ~MTX_FLAGMASK),          \
 420                         (uintptr_t)curthread);                          \
 421                 printf("rw lock: recursed %d\n", mtx_recursed(&sc->rw));\
 422                 db_show_mtx(&sc->rw);                                   \
 423                 }                                                       \
 424         } while (0)
 425 #else
 426 #define EMU_MTX_DEBUG() do {                                            \
 427         } while (0)
 428 #endif
 429
 430 #define EMU_RWLOCK() do {               \
 431         EMU_MTX_DEBUG();                \
 432         mtx_lock(&(sc->rw));            \
 433         } while (0)
 434
 435 #define EMU_RWUNLOCK() do {             \
 436         mtx_unlock(&(sc->rw));          \
 437         EMU_MTX_DEBUG();                \
 438         } while (0)
 439
 440 /* Supported cards */
 441 struct emu_hwinfo {
 442         uint16_t        vendor;
 443         uint16_t        device;
 444         uint16_t        subvendor;
 445         uint16_t        subdevice;
 446         char            SBcode[8];
 447         char            desc[32];
 448         int             flags;
 449 };
 450
 451 static struct emu_hwinfo emu_cards[] = {
 452         {0xffff, 0xffff, 0xffff, 0xffff, "BADCRD", "Not a compatible card", 0},
 453         /* 0x0020..0x002f 4.0 EMU10K1 cards */
 454         {0x1102, 0x0002, 0x1102, 0x0020, "CT4850", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
 455         {0x1102, 0x0002, 0x1102, 0x0021, "CT4620", "SBLive!", HAS_AC97 | IS_EMU10K1},
 456         {0x1102, 0x0002, 0x1102, 0x002f, "CT????", "SBLive! mainboard implementation", HAS_AC97 | IS_EMU10K1},
 457
 458         /* (range unknown) 5.1 EMU10K1 cards */
 459         {0x1102, 0x0002, 0x1102, 0x100a, "CT????", "SBLive! 5.1", HAS_AC97 | HAS_51 | IS_EMU10K1},
 460
 461         /* 0x80??..0x805? 4.0 EMU10K1 cards */
 462         {0x1102, 0x0002, 0x1102, 0x8022, "CT4780", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
 463         {0x1102, 0x0002, 0x1102, 0x8023, "CT4790", "SB PCI512", HAS_AC97 | IS_EMU10K1},
 464         {0x1102, 0x0002, 0x1102, 0x8024, "CT4760", "SBLive!", HAS_AC97 | IS_EMU10K1},
 465         {0x1102, 0x0002, 0x1102, 0x8025, "CT????", "SBLive! Mainboard Implementation", HAS_AC97 | IS_EMU10K1},
 466         {0x1102, 0x0002, 0x1102, 0x8026, "CT4830", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
 467         {0x1102, 0x0002, 0x1102, 0x8027, "CT4832", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
 468         {0x1102, 0x0002, 0x1102, 0x8028, "CT4760", "SBLive! OEM version", HAS_AC97 | IS_EMU10K1},
 469         {0x1102, 0x0002, 0x1102, 0x8031, "CT4831", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
 470         {0x1102, 0x0002, 0x1102, 0x8040, "CT4760", "SBLive!", HAS_AC97 | IS_EMU10K1},
 471         {0x1102, 0x0002, 0x1102, 0x8051, "CT4850", "SBLive! Value", HAS_AC97 | IS_EMU10K1},
 472
 473         /* 0x8061..0x???? 5.1 EMU10K1  cards */
 474         {0x1102, 0x0002, 0x1102, 0x8061, "SB????", "SBLive! Player 5.1", HAS_AC97 | HAS_51 | IS_EMU10K1},
 475         {0x1102, 0x0002, 0x1102, 0x8062, "CT4830", "SBLive! 1024", HAS_AC97 | HAS_51 | IS_EMU10K1},
 476         {0x1102, 0x0002, 0x1102, 0x8064, "SB????", "SBLive! 5.1", HAS_AC97 | HAS_51 | IS_EMU10K1},
 477         {0x1102, 0x0002, 0x1102, 0x8065, "SB0220", "SBLive! 5.1 Digital", HAS_AC97 | HAS_51 | IS_EMU10K1},
 478         {0x1102, 0x0002, 0x1102, 0x8066, "CT4780", "SBLive! 5.1 Digital", HAS_AC97 | HAS_51 | IS_EMU10K1},
 479         {0x1102, 0x0002, 0x1102, 0x8067, "SB????", "SBLive!", HAS_AC97 | HAS_51 | IS_EMU10K1},
 480
 481         /* Generic SB Live! */
 482         {0x1102, 0x0002, 0x1102, 0x0000, "SB????", "SBLive! (Unknown model)", HAS_AC97 | IS_EMU10K1},
 483
 484         /* 0x0041..0x0043 EMU10K2 (some kind of Audigy) cards */
 485
 486         /* 0x0051..0x0051 5.1 CA0100-IAF cards */
 487         {0x1102, 0x0004, 0x1102, 0x0051, "SB0090", "Audigy", HAS_AC97 | HAS_51 | IS_EMU10K2},
 488         /* ES is CA0100-IDF chip that don't work in digital mode */
 489         {0x1102, 0x0004, 0x1102, 0x0052, "SB0160", "Audigy ES", HAS_AC97 | HAS_71 | IS_EMU10K2 | BROKEN_DIGITAL},
 490         /* 0x0053..0x005C 5.1 CA0101-NAF cards */
 491         {0x1102, 0x0004, 0x1102, 0x0053, "SB0090", "Audigy Player/OEM", HAS_AC97 | HAS_51 | IS_EMU10K2},
 492         {0x1102, 0x0004, 0x1102, 0x0058, "SB0090", "Audigy Player/OEM", HAS_AC97 | HAS_51 | IS_EMU10K2},
 493
 494         /* 0x1002..0x1009 5.1 CA0102-IAT cards */
 495         {0x1102, 0x0004, 0x1102, 0x1002, "SB????", "Audigy 2 Platinum", HAS_51 | IS_CA0102},
 496         {0x1102, 0x0004, 0x1102, 0x1005, "SB????", "Audigy 2 Platinum EX", HAS_51 | IS_CA0102},
 497         {0x1102, 0x0004, 0x1102, 0x1007, "SB0240", "Audigy 2", HAS_AC97 | HAS_51 | IS_CA0102},
 498
 499         /* 0x2001..0x2003 7.1 CA0102-ICT cards */
 500         {0x1102, 0x0004, 0x1102, 0x2001, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
 501         {0x1102, 0x0004, 0x1102, 0x2002, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
 502         /* XXX No reports about 0x2003 & 0x2004 cards */
 503         {0x1102, 0x0004, 0x1102, 0x2003, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
 504         {0x1102, 0x0004, 0x1102, 0x2004, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
 505         {0x1102, 0x0004, 0x1102, 0x2005, "SB0350", "Audigy 2 ZS", HAS_AC97 | HAS_71 | IS_CA0102},
 506
 507         /* (range unknown) 7.1 CA0102-xxx Audigy 4 cards */
 508         {0x1102, 0x0004, 0x1102, 0x2007, "SB0380", "Audigy 4 Pro", HAS_AC97 | HAS_71 | IS_CA0102},
 509
 510         /* Generic Audigy or Audigy 2 */
 511         {0x1102, 0x0004, 0x1102, 0x0000, "SB????", "Audigy (Unknown model)", HAS_AC97 | HAS_51 | IS_EMU10K2},
 512
 513         /* We don't support CA0103-DAT (Audigy LS) cards */
 514         /* There is NO CA0104-xxx cards */
 515         /* There is NO CA0105-xxx cards */
 516         /* We don't support CA0106-DAT (SB Live! 24 bit) cards */
 517         /* There is NO CA0107-xxx cards */
 518
 519         /* 0x1000..0x1001 7.1 CA0108-IAT cards */
 520         {0x1102, 0x0008, 0x1102, 0x1000, "SB????", "Audigy 2 LS", HAS_AC97 | HAS_51 | IS_CA0108 | DIGITAL_ONLY},
 521         {0x1102, 0x0008, 0x1102, 0x1001, "SB0400", "Audigy 2 Value", HAS_AC97 | HAS_71 | IS_CA0108 | DIGITAL_ONLY},
 522         {0x1102, 0x0008, 0x1102, 0x1021, "SB0610", "Audigy 4", HAS_AC97 | HAS_71 | IS_CA0108 | DIGITAL_ONLY},
 523
 524         {0x1102, 0x0008, 0x1102, 0x2001, "SB0530", "Audigy 2 ZS CardBus", HAS_AC97 | HAS_71 | IS_CA0108 | IS_CARDBUS},
 525
 526         {0x1102, 0x0008, 0x0000, 0x0000, "SB????", "Audigy 2 Value (Unknown model)", HAS_AC97 | HAS_51 | IS_CA0108},
 527 };
 528 /* Unsupported cards */
 529
 530 static struct emu_hwinfo emu_bad_cards[] = {
 531         /* APS cards should be possible to support */
 532         {0x1102, 0x0002, 0x1102, 0x4001, "EMUAPS", "E-mu APS", 0},
 533         {0x1102, 0x0002, 0x1102, 0x4002, "EMUAPS", "E-mu APS", 0},
 534         {0x1102, 0x0004, 0x1102, 0x4001, "EMU???", "E-mu 1212m [4001]", 0},
 535         /* Similar-named ("Live!" or "Audigy") cards on different chipsets */
 536         {0x1102, 0x8064, 0x0000, 0x0000, "SB0100", "SBLive! 5.1 OEM", 0},
 537         {0x1102, 0x0006, 0x0000, 0x0000, "SB0200", "DELL OEM SBLive! Value", 0},
 538         {0x1102, 0x0007, 0x0000, 0x0000, "SB0310", "Audigy LS", 0},
 539 };
 540
 541 /*
 542  * Get best known information about device.
 543  */
 544 static unsigned int
 545 emu_getcard(device_t dev)
 546 {
 547         uint16_t device;
 548         uint16_t subdevice;
 549         int n_cards;
 550         unsigned int thiscard;
 551         int i;
 552
 553         device = pci_read_config(dev, PCIR_DEVICE, /* bytes */ 2);
 554         subdevice = pci_read_config(dev, PCIR_SUBDEV_0, /* bytes */ 2);
 555
 556         n_cards = sizeof(emu_cards) / sizeof(struct emu_hwinfo);
 557         thiscard = 0;
 558         for (i = 1; i < n_cards; i++) {
 559                 if (device == emu_cards[i].device) {
 560                         if (subdevice == emu_cards[i].subdevice) {
 561                                 thiscard = i;
 562                                 break;
 563                         }
 564                         if (0x0000 == emu_cards[i].subdevice) {
 565                                 thiscard = i;
 566                                 /*
 567                                  * don't break, we can get more specific card
 568                                  * later in the list.
 569                                  */
 570                         }
 571                 }
 572         }
 573
 574         n_cards = sizeof(emu_bad_cards) / sizeof(struct emu_hwinfo);
 575         for (i = 0; i < n_cards; i++) {
 576                 if (device == emu_bad_cards[i].device) {
 577                         if (subdevice == emu_bad_cards[i].subdevice) {
 578                                 thiscard = 0;
 579                                 break;
 580                         }
 581                         if (0x0000 == emu_bad_cards[i].subdevice) {
 582                                 thiscard = 0;
 583                                 break;  /* we avoid all this cards */
 584                         }
 585                 }
 586         }
 587         return (thiscard);
 588 }
 589
 590
 591 /*
 592  * Base hardware interface are 32 (Audigy) or 64 (Audigy2) registers.
 593  * Some of them are used directly, some of them provide pointer / data pairs.
 594  */
 595 static uint32_t
 596 emu_rd_nolock(struct emu_sc_info *sc, unsigned int regno, unsigned int size)
 597 {
 598
 599         KASSERT(sc != NULL, ("emu_rd: NULL sc"));
 600         switch (size) {
 601         case 1:
 602                 return (bus_space_read_1(sc->st, sc->sh, regno));
 603         case 2:
 604                 return (bus_space_read_2(sc->st, sc->sh, regno));
 605         case 4:
 606                 return (bus_space_read_4(sc->st, sc->sh, regno));
 607         }
 608         return (0xffffffff);
 609 }
 610
 611 static void
 612 emu_wr_nolock(struct emu_sc_info *sc, unsigned int regno, uint32_t data, unsigned int size)
 613 {
 614
 615         KASSERT(sc != NULL, ("emu_rd: NULL sc"));
 616         switch (size) {
 617         case 1:
 618                 bus_space_write_1(sc->st, sc->sh, regno, data);
 619                 break;
 620         case 2:
 621                 bus_space_write_2(sc->st, sc->sh, regno, data);
 622                 break;
 623         case 4:
 624                 bus_space_write_4(sc->st, sc->sh, regno, data);
 625                 break;
 626         }
 627 }
 628 /*
 629  * PTR / DATA interface. Access to EMU10Kx is made
 630  * via (channel, register) pair. Some registers are channel-specific,
 631  * some not.
 632  */
 633 uint32_t
 634 emu_rdptr(struct emu_sc_info *sc, unsigned int chn, unsigned int reg)
 635 {
 636         uint32_t ptr, val, mask, size, offset;
 637
 638         ptr = ((reg << 16) & sc->address_mask) | (chn & PTR_CHANNELNUM_MASK);
 639
 640         EMU_RWLOCK();
 641         emu_wr_nolock(sc, PTR, ptr, 4);
 642         val = emu_rd_nolock(sc, DATA, 4);
 643         EMU_RWUNLOCK();
 644
 645         /*
 646          * XXX Some register numbers has data size and offset encoded in
 647          * it to get only part of 32bit register. This use is not described
 648          * in register name, be careful!
 649          */
 650         if (reg & 0xff000000) {
 651                 size = (reg >> 24) & 0x3f;
 652                 offset = (reg >> 16) & 0x1f;
 653                 mask = ((1 << size) - 1) << offset;
 654                 val &= mask;
 655                 val >>= offset;
 656         }
 657         return (val);
 658 }
 659
 660 void
 661 emu_wrptr(struct emu_sc_info *sc, unsigned int chn, unsigned int reg, uint32_t data)
 662 {
 663         uint32_t ptr, mask, size, offset;
 664
 665         ptr = ((reg << 16) & sc->address_mask) | (chn & PTR_CHANNELNUM_MASK);
 666
 667         EMU_RWLOCK();
 668         emu_wr_nolock(sc, PTR, ptr, 4);
 669         /*
 670          * XXX Another kind of magic encoding in register number. This can
 671          * give you side effect - it will read previous data from register
 672          * and change only required bits.
 673          */
 674         if (reg & 0xff000000) {
 675                 size = (reg >> 24) & 0x3f;
 676                 offset = (reg >> 16) & 0x1f;
 677                 mask = ((1 << size) - 1) << offset;
 678                 data <<= offset;
 679                 data &= mask;
 680                 data |= emu_rd_nolock(sc, DATA, 4) & ~mask;
 681         }
 682         emu_wr_nolock(sc, DATA, data, 4);
 683         EMU_RWUNLOCK();
 684 }
 685 /*
 686  * PTR2 / DATA2 interface. Access to P16v is made
 687  * via (channel, register) pair. Some registers are channel-specific,
 688  * some not. This interface is supported by CA0102 and CA0108 chips only.
 689  */
 690 uint32_t
 691 emu_rd_p16vptr(struct emu_sc_info *sc, uint16_t chn, uint16_t reg)
 692 {
 693         uint32_t val;
 694
 695         /* XXX separate lock? */
 696         EMU_RWLOCK();
 697         emu_wr_nolock(sc, PTR2, (reg << 16) | chn, 4);
 698         val = emu_rd_nolock(sc, DATA2, 4);
 699
 700         EMU_RWUNLOCK();
 701
 702         return (val);
 703 }
 704
 705 void
 706 emu_wr_p16vptr(struct emu_sc_info *sc, uint16_t chn, uint16_t reg, uint32_t data)
 707 {
 708
 709         EMU_RWLOCK();
 710         emu_wr_nolock(sc, PTR2, (reg << 16) | chn, 4);
 711         emu_wr_nolock(sc, DATA2, data, 4);
 712         EMU_RWUNLOCK();
 713 }
 714 /*
 715  * XXX CardBus interface. Not tested on any real hardware.
 716  */
 717 static void
 718 emu_wr_cbptr(struct emu_sc_info *sc, uint32_t data)
 719 {
 720         uint32_t val;
 721
 722         /*
 723          * 0x38 is IPE3 (CD S/PDIF interrupt pending register) on CA0102. Seems
 724          * to be some reg/value accessible kind of config register on CardBus
 725          * CA0108, with value(?) in top 16 bit, address(?) in low 16
 726          */
 727
 728         val = emu_rd_nolock(sc, 0x38, 4);
 729         emu_wr_nolock(sc, 0x38, data, 4);
 730         val = emu_rd_nolock(sc, 0x38, 4);
 731
 732 }
 733
 734 /*
 735  * Direct hardware register access
 736  * Assume that it is never used to access PTR-based registers and can run unlocked.
 737  */
 738 void
 739 emu_wr(struct emu_sc_info *sc, unsigned int regno, uint32_t data, unsigned int size)
 740 {
 741         KASSERT(regno != PTR, ("emu_wr: attempt to write to PTR"));
 742         KASSERT(regno != PTR2, ("emu_wr: attempt to write to PTR2"));
 743
 744         emu_wr_nolock(sc, regno, data, size);
 745 }
 746
 747 uint32_t
 748 emu_rd(struct emu_sc_info *sc, unsigned int regno, unsigned int size)
 749 {
 750         uint32_t rd;
 751
 752         KASSERT(regno != DATA, ("emu_rd: attempt to read DATA"));
 753         KASSERT(regno != DATA2, ("emu_rd: attempt to read DATA2"));
 754
 755         rd = emu_rd_nolock(sc, regno, size);
 756         return (rd);
 757 }
 758
 759 /*
 760  * Enabling IR MIDI messages is another kind of black magic. It just
 761  * has to be made this way. It really do it.
 762  */
 763 void
 764 emu_enable_ir(struct emu_sc_info *sc)
 765 {
 766         uint32_t iocfg;
 767
 768         if (sc->is_emu10k2 || sc->is_ca0102) {
 769                 iocfg = emu_rd_nolock(sc, A_IOCFG, 2);
 770                 emu_wr_nolock(sc, A_IOCFG, iocfg | A_IOCFG_GPOUT2, 2);
 771                 DELAY(500);
 772                 emu_wr_nolock(sc, A_IOCFG, iocfg | A_IOCFG_GPOUT1 | A_IOCFG_GPOUT2, 2);
 773                 DELAY(500);
 774                 emu_wr_nolock(sc, A_IOCFG, iocfg | A_IOCFG_GPOUT1, 2);
 775                 DELAY(100);
 776                 emu_wr_nolock(sc, A_IOCFG, iocfg, 2);
 777                 device_printf(sc->dev, "Audigy IR MIDI events enabled.\n");
 778                 sc->enable_ir = 1;
 779         }
 780         if (sc->is_emu10k1) {
 781                 iocfg = emu_rd_nolock(sc, HCFG, 4);
 782                 emu_wr_nolock(sc, HCFG, iocfg | HCFG_GPOUT2, 4);
 783                 DELAY(500);
 784                 emu_wr_nolock(sc, HCFG, iocfg | HCFG_GPOUT1 | HCFG_GPOUT2, 4);
 785                 DELAY(100);
 786                 emu_wr_nolock(sc, HCFG, iocfg, 4);
 787                 device_printf(sc->dev, "SB Live! IR MIDI events enabled.\n");
 788                 sc->enable_ir = 1;
 789         }
 790 }
 791
 792
 793 /*
 794  * emu_timer_ - HW timer managment
 795  */
 796 int
 797 emu_timer_create(struct emu_sc_info *sc)
 798 {
 799         int i, timer;
 800
 801         timer = -1;
 802
 803         mtx_lock(&sc->lock);
 804         for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
 805                 if (sc->timer[i] == 0) {
 806                         sc->timer[i] = -1;      /* disable it */
 807                         timer = i;
 808                         mtx_unlock(&sc->lock);
 809                         return (timer);
 810                 }
 811         mtx_unlock(&sc->lock);
 812
 813         return (-1);
 814 }
 815
 816 int
 817 emu_timer_set(struct emu_sc_info *sc, int timer, int delay)
 818 {
 819         int i;
 820
 821         if (timer < 0)
 822                 return (-1);
 823
 824         RANGE(delay, 16, 1024);
 825         RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
 826
 827         mtx_lock(&sc->lock);
 828         sc->timer[timer] = delay;
 829         for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
 830                 if (sc->timerinterval > sc->timer[i])
 831                         sc->timerinterval = sc->timer[i];
 832
 833         /* XXX */
 834         emu_wr(sc, TIMER, sc->timerinterval & 0x03ff, 2);
 835         mtx_unlock(&sc->lock);
 836
 837         return (timer);
 838 }
 839
 840 int
 841 emu_timer_enable(struct emu_sc_info *sc, int timer, int go)
 842 {
 843         uint32_t x;
 844         int ena_int;
 845         int i;
 846
 847         if (timer < 0)
 848                 return (-1);
 849
 850         RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
 851
 852         mtx_lock(&sc->lock);
 853
 854         if ((go == 1) && (sc->timer[timer] < 0))
 855                 sc->timer[timer] = -sc->timer[timer];
 856         if ((go == 0) && (sc->timer[timer] > 0))
 857                 sc->timer[timer] = -sc->timer[timer];
 858
 859         ena_int = 0;
 860         for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++) {
 861                 if (sc->timerinterval > sc->timer[i])
 862                         sc->timerinterval = sc->timer[i];
 863                 if (sc->timer[i] > 0)
 864                         ena_int = 1;
 865         }
 866
 867         emu_wr(sc, TIMER, sc->timerinterval & 0x03ff, 2);
 868
 869         if (ena_int == 1) {
 870                 x = emu_rd(sc, INTE, 4);
 871                 x |= INTE_INTERVALTIMERENB;
 872                 emu_wr(sc, INTE, x, 4);
 873         } else {
 874                 x = emu_rd(sc, INTE, 4);
 875                 x &= ~INTE_INTERVALTIMERENB;
 876                 emu_wr(sc, INTE, x, 4);
 877         }
 878         mtx_unlock(&sc->lock);
 879         return (0);
 880 }
 881
 882 int
 883 emu_timer_clear(struct emu_sc_info *sc, int timer)
 884 {
 885         if (timer < 0)
 886                 return (-1);
 887
 888         RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
 889
 890         emu_timer_enable(sc, timer, 0);
 891
 892         mtx_lock(&sc->lock);
 893         if (sc->timer[timer] != 0)
 894                 sc->timer[timer] = 0;
 895         mtx_unlock(&sc->lock);
 896
 897         return (timer);
 898 }
 899
 900 /*
 901  * emu_intr_ - HW interrupt handler managment
 902  */
 903 int
 904 emu_intr_register(struct emu_sc_info *sc, uint32_t inte_mask, uint32_t intr_mask, uint32_t(*func) (void *softc, uint32_t irq), void *isc)
 905 {
 906         int i;
 907         uint32_t x;
 908
 909         mtx_lock(&sc->lock);
 910         for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
 911                 if (sc->ihandler[i].inte_mask == 0) {
 912                         sc->ihandler[i].inte_mask = inte_mask;
 913                         sc->ihandler[i].intr_mask = intr_mask;
 914                         sc->ihandler[i].softc = isc;
 915                         sc->ihandler[i].irq_func = func;
 916                         x = emu_rd(sc, INTE, 4);
 917                         x |= inte_mask;
 918                         emu_wr(sc, INTE, x, 4);
 919                         mtx_unlock(&sc->lock);
 920                         if (sc->dbg_level > 1)
 921                                 device_printf(sc->dev, "ihandle %d registered\n", i);
 922
 923                         return (i);
 924                 }
 925         mtx_unlock(&sc->lock);
 926         if (sc->dbg_level > 1)
 927                 device_printf(sc->dev, "ihandle not registered\n");
 928
 929         return (-1);
 930 }
 931
 932 int
 933 emu_intr_unregister(struct emu_sc_info *sc, int hnumber)
 934 {
 935         uint32_t x;
 936         int i;
 937
 938         mtx_lock(&sc->lock);
 939
 940         if (sc->ihandler[hnumber].inte_mask == 0) {
 941                 mtx_unlock(&sc->lock);
 942                 return (-1);
 943         }
 944
 945         x = emu_rd(sc, INTE, 4);
 946         x &= ~sc->ihandler[hnumber].inte_mask;
 947
 948         sc->ihandler[hnumber].inte_mask = 0;
 949         sc->ihandler[hnumber].intr_mask = 0;
 950         sc->ihandler[hnumber].softc = NULL;
 951         sc->ihandler[hnumber].irq_func = NULL;
 952
 953         /* other interrupt handlers may use this INTE value */
 954         for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
 955                 if (sc->ihandler[i].inte_mask != 0)
 956                         x |= sc->ihandler[i].inte_mask;
 957
 958         emu_wr(sc, INTE, x, 4);
 959
 960         mtx_unlock(&sc->lock);
 961         return (hnumber);
 962 }
 963
 964 static void
 965 emu_intr(void *p)
 966 {
 967         struct emu_sc_info *sc = (struct emu_sc_info *)p;
 968         uint32_t stat, ack;
 969         int i;
 970
 971         for (;;) {
 972                 stat = emu_rd(sc, IPR, 4);
 973                 ack = 0;
 974                 if (stat == 0)
 975                         break;
 976                 emu_wr(sc, IPR, stat, 4);
 977                 for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++) {
 978                         if ((((sc->ihandler[i].intr_mask) & stat) != 0) &&
 979                             (((void *)sc->ihandler[i].irq_func) != NULL)) {
 980                                 ack |= sc->ihandler[i].irq_func(sc->ihandler[i].softc,
 981                                     (sc->ihandler[i].intr_mask) & stat);
 982                         }
 983                 }
 984         if (sc->dbg_level > 1)
 985                 if (stat & (~ack))
 986                         device_printf(sc->dev, "Unhandled interrupt: %08x\n", stat & (~ack));
 987
 988         }
 989
 990         if ((sc->is_ca0102) || (sc->is_ca0108))
 991                 for (;;) {
 992                         stat = emu_rd(sc, IPR2, 4);
 993                         ack = 0;
 994                         if (stat == 0)
 995                                 break;
 996                         emu_wr(sc, IPR2, stat, 4);
 997                         if (sc->dbg_level > 1)
 998                                 device_printf(sc->dev, "IPR2: %08x\n", stat);
 999
1000                         break;  /* to avoid infinite loop. shoud be removed
1001                                  * after completion of P16V interface. */
1002                 }
1003
1004         if (sc->is_ca0102)
1005                 for (;;) {
1006                         stat = emu_rd(sc, IPR3, 4);
1007                         ack = 0;
1008                         if (stat == 0)
1009                                 break;
1010                         emu_wr(sc, IPR3, stat, 4);
1011                         if (sc->dbg_level > 1)
1012                                 device_printf(sc->dev, "IPR3: %08x\n", stat);
1013
1014                         break;  /* to avoid infinite loop. should be removed
1015                                  * after completion of S/PDIF interface */
1016                 }
1017 }
1018
1019
1020 /*
1021  * Get data from private emu10kx structure for PCM buffer allocation.
1022  * Used by PCM code only.
1023  */
1024 bus_dma_tag_t
1025 emu_gettag(struct emu_sc_info *sc)
1026 {
1027         return (sc->mem.dmat);
1028 }
1029
1030 static void
1031 emu_setmap(void *arg, bus_dma_segment_t * segs, int nseg, int error)
1032 {
1033         bus_addr_t *phys = (bus_addr_t *) arg;
1034
1035         *phys = error ? 0 : (bus_addr_t) segs->ds_addr;
1036
1037         if (bootverbose) {
1038                 printf("emu10kx: setmap (%lx, %lx), nseg=%d, error=%d\n",
1039                     (unsigned long)segs->ds_addr, (unsigned long)segs->ds_len,
1040                     nseg, error);
1041         }
1042 }
1043
1044 static void *
1045 emu_malloc(struct emu_mem *mem, uint32_t sz, bus_addr_t * addr)
1046 {
1047         void *dmabuf;
1048         bus_dmamap_t map;
1049         int error;
1050
1051         *addr = 0;
1052         if ((error = bus_dmamem_alloc(mem->dmat, &dmabuf, BUS_DMA_NOWAIT, &map))) {
1053                 if (mem->card->dbg_level > 2)
1054                         device_printf(mem->card->dev, "emu_malloc: failed to alloc DMA map: %d\n", error);
1055                 return (NULL);
1056                 }
1057         if ((error = bus_dmamap_load(mem->dmat, map, dmabuf, sz, emu_setmap, addr, 0)) || !*addr) {
1058                 if (mem->card->dbg_level > 2)
1059                         device_printf(mem->card->dev, "emu_malloc: failed to load DMA memory: %d\n", error);
1060                 return (NULL);
1061                 }
1062         return (dmabuf);
1063 }
1064
1065 static void
1066 emu_free(struct emu_mem *mem, void *dmabuf)
1067 {
1068         bus_dmamem_free(mem->dmat, dmabuf, NULL);
1069 }
1070
1071 static void *
1072 emu_memalloc(struct emu_mem *mem, uint32_t sz, bus_addr_t * addr, const char *owner)
1073 {
1074         uint32_t blksz, start, idx, ofs, tmp, found;
1075         struct emu_memblk *blk;
1076         void *membuf;
1077
1078         blksz = sz / EMUPAGESIZE;
1079         if (sz > (blksz * EMUPAGESIZE))
1080                 blksz++;
1081         if (blksz > EMU_MAX_BUFSZ / EMUPAGESIZE) {
1082                 if (mem->card->dbg_level > 2)
1083                         device_printf(mem->card->dev, "emu_memalloc: memory request tool large\n");
1084                 return (NULL);
1085                 }
1086         /* find a free block in the bitmap */
1087         found = 0;
1088         start = 1;
1089         while (!found && start + blksz < EMU_MAXPAGES) {
1090                 found = 1;
1091                 for (idx = start; idx < start + blksz; idx++)
1092                         if (mem->bmap[idx >> 3] & (1 << (idx & 7)))
1093                                 found = 0;
1094                 if (!found)
1095                         start++;
1096         }
1097         if (!found) {
1098                 if (mem->card->dbg_level > 2)
1099                         device_printf(mem->card->dev, "emu_memalloc: no free space in bitmap\n");
1100                 return (NULL);
1101                 }
1102         blk = malloc(sizeof(*blk), M_DEVBUF, M_NOWAIT);
1103         if (blk == NULL) {
1104                 if (mem->card->dbg_level > 2)
1105                         device_printf(mem->card->dev, "emu_memalloc: buffer allocation failed\n");
1106                 return (NULL);
1107                 }
1108         bzero(blk, sizeof(*blk));
1109         membuf = emu_malloc(mem, sz, &blk->buf_addr);
1110         *addr = blk->buf_addr;
1111         if (membuf == NULL) {
1112                 if (mem->card->dbg_level > 2)
1113                         device_printf(mem->card->dev, "emu_memalloc: can't setup HW memory\n");
1114                 free(blk, M_DEVBUF);
1115                 return (NULL);
1116         }
1117         blk->buf = membuf;
1118         blk->pte_start = start;
1119         blk->pte_size = blksz;
1120         strncpy(blk->owner, owner, 15);
1121         blk->owner[15] = '\0';
1122         ofs = 0;
1123         for (idx = start; idx < start + blksz; idx++) {
1124                 mem->bmap[idx >> 3] |= 1 << (idx & 7);
1125                 tmp = (uint32_t) (u_long) ((uint8_t *) blk->buf_addr + ofs);
1126                 mem->ptb_pages[idx] = (tmp << 1) | idx;
1127                 ofs += EMUPAGESIZE;
1128         }
1129         SLIST_INSERT_HEAD(&mem->blocks, blk, link);
1130         return (membuf);
1131 }
1132
1133 static int
1134 emu_memfree(struct emu_mem *mem, void *membuf)
1135 {
1136         uint32_t idx, tmp;
1137         struct emu_memblk *blk, *i;
1138
1139         blk = NULL;
1140         SLIST_FOREACH(i, &mem->blocks, link) {
1141                 if (i->buf == membuf)
1142                         blk = i;
1143         }
1144         if (blk == NULL)
1145                 return (EINVAL);
1146         SLIST_REMOVE(&mem->blocks, blk, emu_memblk, link);
1147         emu_free(mem, membuf);
1148         tmp = (uint32_t) (mem->silent_page_addr) << 1;
1149         for (idx = blk->pte_start; idx < blk->pte_start + blk->pte_size; idx++) {
1150                 mem->bmap[idx >> 3] &= ~(1 << (idx & 7));
1151                 mem->ptb_pages[idx] = tmp | idx;
1152         }
1153         free(blk, M_DEVBUF);
1154         return (0);
1155 }
1156
1157 static int
1158 emu_memstart(struct emu_mem *mem, void *membuf)
1159 {
1160         struct emu_memblk *blk, *i;
1161
1162         blk = NULL;
1163         SLIST_FOREACH(i, &mem->blocks, link) {
1164                 if (i->buf == membuf)
1165                         blk = i;
1166         }
1167         if (blk == NULL)
1168                 return (-1);
1169         return (blk->pte_start);
1170 }
1171
1172
1173 static uint32_t
1174 emu_rate_to_pitch(uint32_t rate)
1175 {
1176         static uint32_t logMagTable[128] = {
1177                 0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3, 0x13aa2,
1178                 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a, 0x2655d, 0x28ed5,
1179                 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb, 0x381b6, 0x3a93d, 0x3d081,
1180                 0x3f782, 0x41e42, 0x444c1, 0x46b01, 0x49101, 0x4b6c4, 0x4dc49, 0x50191,
1181                 0x5269e, 0x54b6f, 0x57006, 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7,
1182                 0x646ee, 0x66a00, 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829,
1183                 0x759d4, 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
1184                 0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20, 0x93d26,
1185                 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec, 0xa11d8, 0xa2f9d,
1186                 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241, 0xadf26, 0xafbe7, 0xb1885,
1187                 0xb3500, 0xb5157, 0xb6d8c, 0xb899f, 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899,
1188                 0xc1404, 0xc2f50, 0xc4a7b, 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c,
1189                 0xceaec, 0xd053f, 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3,
1190                 0xdba4a, 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
1191                 0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a, 0xf2c83,
1192                 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57, 0xfd1a7, 0xfe8df
1193         };
1194         static char logSlopeTable[128] = {
1195                 0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
1196                 0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
1197                 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
1198                 0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
1199                 0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
1200                 0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
1201                 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
1202                 0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
1203                 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
1204                 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
1205                 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
1206                 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
1207                 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
1208                 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
1209                 0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
1210                 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
1211         };
1212         int i;
1213
1214         if (rate == 0)
1215                 return (0);
1216         rate *= 11185;          /* Scale 48000 to 0x20002380 */
1217         for (i = 31; i > 0; i--) {
1218                 if (rate & 0x80000000) {        /* Detect leading "1" */
1219                         return (((uint32_t) (i - 15) << 20) +
1220                             logMagTable[0x7f & (rate >> 24)] +
1221                             (0x7f & (rate >> 17)) *
1222                             logSlopeTable[0x7f & (rate >> 24)]);
1223                 }
1224                 rate <<= 1;
1225         }
1226         /* NOTREACHED */
1227         return (0);
1228 }
1229
1230 static uint32_t
1231 emu_rate_to_linearpitch(uint32_t rate)
1232 {
1233         rate = (rate << 8) / 375;
1234         return ((rate >> 1) + (rate & 1));
1235 }
1236
1237 struct emu_voice *
1238 emu_valloc(struct emu_sc_info *sc)
1239 {
1240         struct emu_voice *v;
1241         int i;
1242
1243         v = NULL;
1244         mtx_lock(&sc->lock);
1245         for (i = 0; i < NUM_G && sc->voice[i].busy; i++);
1246         if (i < NUM_G) {
1247                 v = &sc->voice[i];
1248                 v->busy = 1;
1249         }
1250         mtx_unlock(&sc->lock);
1251         return (v);
1252 }
1253
1254 void
1255 emu_vfree(struct emu_sc_info *sc, struct emu_voice *v)
1256 {
1257         int i, r;
1258
1259         mtx_lock(&sc->lock);
1260         for (i = 0; i < NUM_G; i++) {
1261                 if (v == &sc->voice[i] && sc->voice[i].busy) {
1262                         v->busy = 0;
1263                         /*
1264                          * XXX What we should do with mono channels?
1265                          * See -pcm.c emupchan_init for other side of
1266                          * this problem
1267                          */
1268                         if (v->slave != NULL)
1269                                 r = emu_memfree(&sc->mem, v->vbuf);
1270                 }
1271         }
1272         mtx_unlock(&sc->lock);
1273 }
1274
1275 int
1276 emu_vinit(struct emu_sc_info *sc, struct emu_voice *m, struct emu_voice *s,
1277     uint32_t sz, struct snd_dbuf *b)
1278 {
1279         void *vbuf;
1280         bus_addr_t tmp_addr;
1281
1282         vbuf = emu_memalloc(&sc->mem, sz, &tmp_addr, "vinit");
1283         if (vbuf == NULL) {
1284                 if(sc->dbg_level > 2)
1285                         device_printf(sc->dev, "emu_memalloc returns NULL in enu_vinit\n");
1286                 return (ENOMEM);
1287                 }
1288         if (b != NULL)
1289                 sndbuf_setup(b, vbuf, sz);
1290         m->start = emu_memstart(&sc->mem, vbuf) * EMUPAGESIZE;
1291         if (m->start < 0) {
1292                 if(sc->dbg_level > 2)
1293                         device_printf(sc->dev, "emu_memstart returns (-1) in enu_vinit\n");
1294                 emu_memfree(&sc->mem, vbuf);
1295                 return (ENOMEM);
1296         }
1297         m->end = m->start + sz;
1298         m->speed = 0;
1299         m->b16 = 0;
1300         m->stereo = 0;
1301         m->running = 0;
1302         m->ismaster = 1;
1303         m->vol = 0xff;
1304         m->buf = tmp_addr;
1305         m->vbuf = vbuf;
1306         m->slave = s;
1307         if (s != NULL) {
1308                 s->start = m->start;
1309                 s->end = m->end;
1310                 s->speed = 0;
1311                 s->b16 = 0;
1312                 s->stereo = 0;
1313                 s->running = 0;
1314                 s->ismaster = 0;
1315                 s->vol = m->vol;
1316                 s->buf = m->buf;
1317                 s->vbuf = NULL;
1318                 s->slave = NULL;
1319         }
1320         return (0);
1321 }
1322
1323 void
1324 emu_vsetup(struct emu_voice *v, int fmt, int spd)
1325 {
1326         if (fmt) {
1327                 v->b16 = (fmt & AFMT_16BIT) ? 1 : 0;
1328                 v->stereo = (fmt & AFMT_STEREO) ? 1 : 0;
1329                 if (v->slave != NULL) {
1330                         v->slave->b16 = v->b16;
1331                         v->slave->stereo = v->stereo;
1332                 }
1333         }
1334         if (spd) {
1335                 v->speed = spd;
1336                 if (v->slave != NULL)
1337                         v->slave->speed = v->speed;
1338         }
1339 }
1340
1341 void
1342 emu_vroute(struct emu_sc_info *sc, struct emu_route *rt,  struct emu_voice *v)
1343 {
1344         int i;
1345
1346         for (i = 0; i < 8; i++) {
1347                 v->routing[i] = rt->routing_left[i];
1348                 v->amounts[i] = rt->amounts_left[i];
1349         }
1350         if ((v->stereo) && (v->ismaster == 0))
1351                 for (i = 0; i < 8; i++) {
1352                         v->routing[i] = rt->routing_right[i];
1353                         v->amounts[i] = rt->amounts_right[i];
1354                 }
1355
1356         if ((v->stereo) && (v->slave != NULL))
1357                 emu_vroute(sc, rt, v->slave);
1358 }
1359
1360 void
1361 emu_vwrite(struct emu_sc_info *sc, struct emu_voice *v)
1362 {
1363         int s;
1364         uint32_t start, val, silent_page;
1365
1366         s = (v->stereo ? 1 : 0) + (v->b16 ? 1 : 0);
1367
1368         v->sa = v->start >> s;
1369         v->ea = v->end >> s;
1370
1371
1372         if (v->stereo) {
1373                 emu_wrptr(sc, v->vnum, CPF, CPF_STEREO_MASK);
1374         } else {
1375                 emu_wrptr(sc, v->vnum, CPF, 0);
1376         }
1377         val = v->stereo ? 28 : 30;
1378         val *= v->b16 ? 1 : 2;
1379         start = v->sa + val;
1380
1381         if (sc->is_emu10k1) {
1382                 emu_wrptr(sc, v->vnum, FXRT, ((v->routing[3] << 12) |
1383                     (v->routing[2] << 8) |
1384                     (v->routing[1] << 4) |
1385                     (v->routing[0] << 0)) << 16);
1386         } else {
1387                 emu_wrptr(sc, v->vnum, A_FXRT1, (v->routing[3] << 24) |
1388                     (v->routing[2] << 16) |
1389                     (v->routing[1] << 8) |
1390                     (v->routing[0] << 0));
1391                 emu_wrptr(sc, v->vnum, A_FXRT2, (v->routing[7] << 24) |
1392                     (v->routing[6] << 16) |
1393                     (v->routing[5] << 8) |
1394                     (v->routing[4] << 0));
1395                 emu_wrptr(sc, v->vnum, A_SENDAMOUNTS, (v->amounts[7] << 24) |
1396                     (v->amounts[6] << 26) |
1397                     (v->amounts[5] << 8) |
1398                     (v->amounts[4] << 0));
1399         }
1400         emu_wrptr(sc, v->vnum, PTRX, (v->amounts[0] << 8) | (v->amounts[1] << 0));
1401         emu_wrptr(sc, v->vnum, DSL, v->ea | (v->amounts[3] << 24));
1402         emu_wrptr(sc, v->vnum, PSST, v->sa | (v->amounts[2] << 24));
1403
1404         emu_wrptr(sc, v->vnum, CCCA, start | (v->b16 ? 0 : CCCA_8BITSELECT));
1405         emu_wrptr(sc, v->vnum, Z1, 0);
1406         emu_wrptr(sc, v->vnum, Z2, 0);
1407
1408         silent_page = ((uint32_t) (sc->mem.silent_page_addr) << 1) | MAP_PTI_MASK;
1409         emu_wrptr(sc, v->vnum, MAPA, silent_page);
1410         emu_wrptr(sc, v->vnum, MAPB, silent_page);
1411
1412         emu_wrptr(sc, v->vnum, CVCF, CVCF_CURRENTFILTER_MASK);
1413         emu_wrptr(sc, v->vnum, VTFT, VTFT_FILTERTARGET_MASK);
1414         emu_wrptr(sc, v->vnum, ATKHLDM, 0);
1415         emu_wrptr(sc, v->vnum, DCYSUSM, DCYSUSM_DECAYTIME_MASK);
1416         emu_wrptr(sc, v->vnum, LFOVAL1, 0x8000);
1417         emu_wrptr(sc, v->vnum, LFOVAL2, 0x8000);
1418         emu_wrptr(sc, v->vnum, FMMOD, 0);
1419         emu_wrptr(sc, v->vnum, TREMFRQ, 0);
1420         emu_wrptr(sc, v->vnum, FM2FRQ2, 0);
1421         emu_wrptr(sc, v->vnum, ENVVAL, 0x8000);
1422
1423         emu_wrptr(sc, v->vnum, ATKHLDV, ATKHLDV_HOLDTIME_MASK | ATKHLDV_ATTACKTIME_MASK);
1424         emu_wrptr(sc, v->vnum, ENVVOL, 0x8000);
1425
1426         emu_wrptr(sc, v->vnum, PEFE_FILTERAMOUNT, 0x7f);
1427         emu_wrptr(sc, v->vnum, PEFE_PITCHAMOUNT, 0);
1428         if ((v->stereo) && (v->slave != NULL))
1429                 emu_vwrite(sc, v->slave);
1430 }
1431
1432 static void
1433 emu_vstop(struct emu_sc_info *sc, char channel, int enable)
1434 {
1435         int reg;
1436
1437         reg = (channel & 0x20) ? SOLEH : SOLEL;
1438         channel &= 0x1f;
1439         reg |= 1 << 24;
1440         reg |= channel << 16;
1441         emu_wrptr(sc, 0, reg, enable);
1442 }
1443
1444 void
1445 emu_vtrigger(struct emu_sc_info *sc, struct emu_voice *v, int go)
1446 {
1447         uint32_t pitch_target, initial_pitch;
1448         uint32_t cra, cs, ccis;
1449         uint32_t sample, i;
1450
1451         if (go) {
1452                 cra = 64;
1453                 cs = v->stereo ? 4 : 2;
1454                 ccis = v->stereo ? 28 : 30;
1455                 ccis *= v->b16 ? 1 : 2;
1456                 sample = v->b16 ? 0x00000000 : 0x80808080;
1457                 for (i = 0; i < cs; i++)
1458                         emu_wrptr(sc, v->vnum, CD0 + i, sample);
1459                 emu_wrptr(sc, v->vnum, CCR_CACHEINVALIDSIZE, 0);
1460                 emu_wrptr(sc, v->vnum, CCR_READADDRESS, cra);
1461                 emu_wrptr(sc, v->vnum, CCR_CACHEINVALIDSIZE, ccis);
1462
1463                 emu_wrptr(sc, v->vnum, IFATN, 0xff00);
1464                 emu_wrptr(sc, v->vnum, VTFT, 0xffffffff);
1465                 emu_wrptr(sc, v->vnum, CVCF, 0xffffffff);
1466                 emu_wrptr(sc, v->vnum, DCYSUSV, 0x00007f7f);
1467                 emu_vstop(sc, v->vnum, 0);
1468
1469                 pitch_target = emu_rate_to_linearpitch(v->speed);
1470                 initial_pitch = emu_rate_to_pitch(v->speed) >> 8;
1471                 emu_wrptr(sc, v->vnum, PTRX_PITCHTARGET, pitch_target);
1472                 emu_wrptr(sc, v->vnum, CPF_CURRENTPITCH, pitch_target);
1473                 emu_wrptr(sc, v->vnum, IP, initial_pitch);
1474         } else {
1475                 emu_wrptr(sc, v->vnum, PTRX_PITCHTARGET, 0);
1476                 emu_wrptr(sc, v->vnum, CPF_CURRENTPITCH, 0);
1477                 emu_wrptr(sc, v->vnum, IFATN, 0xffff);
1478                 emu_wrptr(sc, v->vnum, VTFT, 0x0000ffff);
1479                 emu_wrptr(sc, v->vnum, CVCF, 0x0000ffff);
1480                 emu_wrptr(sc, v->vnum, IP, 0);
1481                 emu_vstop(sc, v->vnum, 1);
1482         }
1483         if ((v->stereo) && (v->slave != NULL))
1484                 emu_vtrigger(sc, v->slave, go);
1485 }
1486
1487 int
1488 emu_vpos(struct emu_sc_info *sc, struct emu_voice *v)
1489 {
1490         int s, ptr;
1491
1492         s = (v->b16 ? 1 : 0) + (v->stereo ? 1 : 0);
1493         ptr = (emu_rdptr(sc, v->vnum, CCCA_CURRADDR) - (v->start >> s)) << s;
1494         return (ptr & ~0x0000001f);
1495 }
1496
1497
1498 /* fx */
1499 static void
1500 emu_wrefx(struct emu_sc_info *sc, unsigned int pc, unsigned int data)
1501 {
1502         emu_wrptr(sc, 0, sc->code_base + pc, data);
1503 }
1504
1505
1506 static void
1507 emu_addefxop(struct emu_sc_info *sc, unsigned int op, unsigned int z, unsigned int w, unsigned int x, unsigned int y, uint32_t * pc)
1508 {
1509         if ((*pc) + 1 > sc->code_size) {
1510                 device_printf(sc->dev, "DSP CODE OVERRUN: attept to write past code_size (pc=%d)\n", (*pc));
1511                 return;
1512         }
1513         emu_wrefx(sc, (*pc) * 2, (x << sc->high_operand_shift) | y);
1514         emu_wrefx(sc, (*pc) * 2 + 1, (op << sc->opcode_shift) | (z << sc->high_operand_shift) | w);
1515         (*pc)++;
1516 }
1517
1518 static int
1519 sysctl_emu_mixer_control(SYSCTL_HANDLER_ARGS)
1520 {
1521         struct emu_sc_info *sc;
1522         int     mixer_id;
1523         int     new_vol;
1524         int     err;
1525
1526         sc = arg1;
1527         mixer_id = arg2;
1528
1529         new_vol = emumix_get_volume(sc, mixer_id);
1530         err = sysctl_handle_int(oidp, &new_vol, 0, req);
1531
1532         if (err || req->newptr == NULL)
1533                 return (err);
1534         if (new_vol < 0 || new_vol > 100)
1535                 return (EINVAL);
1536         emumix_set_volume(sc, mixer_id, new_vol);
1537
1538         return (0);
1539 }
1540
1541 static int
1542 emu_addefxmixer(struct emu_sc_info *sc, const char *mix_name, const int mix_id, uint32_t defvolume)
1543 {
1544         int volgpr;
1545         char    sysctl_name[32];
1546
1547         volgpr = emu_rm_gpr_alloc(sc->rm, 1);
1548         emumix_set_fxvol(sc, volgpr, defvolume);
1549         /*
1550          * Mixer controls with NULL mix_name are handled
1551          * by AC97 emulation code or PCM mixer.
1552          */
1553         if (mix_name != NULL) {
1554                 /*
1555                  * Temporary sysctls should start with underscore,
1556                  * see freebsd-current mailing list, emu10kx driver
1557                  * discussion around 2006-05-24.
1558                  */
1559                 snprintf(sysctl_name, 32, "_%s", mix_name);
1560                 SYSCTL_ADD_PROC(sc->ctx,
1561                         SYSCTL_CHILDREN(sc->root),
1562                         OID_AUTO, sysctl_name,
1563                         CTLTYPE_INT | CTLFLAG_RW, sc, mix_id,
1564                         sysctl_emu_mixer_control, "I", "");
1565         }
1566
1567         return (volgpr);
1568 }
1569
1570 static int
1571 sysctl_emu_digitalswitch_control(SYSCTL_HANDLER_ARGS)
1572 {
1573         struct emu_sc_info *sc;
1574         int     new_val;
1575         int     err;
1576
1577         sc = arg1;
1578
1579         new_val = (sc->mode == MODE_DIGITAL) ? 1 : 0;
1580         err = sysctl_handle_int(oidp, &new_val, 0, req);
1581
1582         if (err || req->newptr == NULL)
1583                 return (err);
1584         if (new_val < 0 || new_val > 1)
1585                 return (EINVAL);
1586
1587         switch (new_val) {
1588                 case 0:
1589                         emumix_set_mode(sc, MODE_ANALOG);
1590                         break;
1591                 case 1:
1592                         emumix_set_mode(sc, MODE_DIGITAL);
1593                         break;
1594         }
1595         return (0);
1596 }
1597
1598 static void
1599 emu_digitalswitch(struct emu_sc_info *sc)
1600 {
1601         /* XXX temporary? */
1602         SYSCTL_ADD_PROC(sc->ctx,
1603                 SYSCTL_CHILDREN(sc->root),
1604                 OID_AUTO, "_digital",
1605                 CTLTYPE_INT | CTLFLAG_RW, sc, 0,
1606                 sysctl_emu_digitalswitch_control, "I", "Enable digital output");
1607
1608         return;
1609 }
1610
1611 /*
1612  * Allocate cache GPRs that will hold mixed output channels
1613  * and clear it on every DSP run.
1614  */
1615 #define EFX_CACHE(CACHE_IDX) do {                               \
1616         sc->cache_gpr[CACHE_IDX] = emu_rm_gpr_alloc(sc->rm, 1); \
1617         emu_addefxop(sc, ACC3,                                  \
1618                 GPR(sc->cache_gpr[CACHE_IDX]),                  \
1619                 DSP_CONST(0),                                   \
1620                 DSP_CONST(0),                                   \
1621                 DSP_CONST(0),                                   \
1622                 &pc);                                           \
1623 } while (0)
1624
1625 /* Allocate GPR for volume control and route sound: OUT = OUT + IN * VOL */
1626 #define EFX_ROUTE(TITLE, INP_NR, IN_GPR_IDX, OUT_CACHE_IDX, DEF) do {   \
1627         sc->mixer_gpr[IN_GPR_IDX] = emu_addefxmixer(sc, TITLE, IN_GPR_IDX,  DEF); \
1628         sc->mixer_volcache[IN_GPR_IDX] = DEF;                   \
1629         emu_addefxop(sc, MACS,                                  \
1630                 GPR(sc->cache_gpr[OUT_CACHE_IDX]),              \
1631                 GPR(sc->cache_gpr[OUT_CACHE_IDX]),              \
1632                 INP_NR,                                         \
1633                 GPR(sc->mixer_gpr[IN_GPR_IDX]),                 \
1634                 &pc);                                           \
1635 } while (0)
1636
1637 /* allocate GPR, OUT = IN * VOL */
1638 #define EFX_OUTPUT(TITLE, OUT_CACHE_IDX, OUT_GPR_IDX, OUTP_NR, DEF) do {        \
1639         sc->mixer_gpr[OUT_GPR_IDX] = emu_addefxmixer(sc, TITLE, OUT_GPR_IDX, DEF); \
1640         sc->mixer_volcache[OUT_GPR_IDX] = DEF;                  \
1641         emu_addefxop(sc, MACS,                                  \
1642                 OUTP(OUTP_NR),                                  \
1643                 DSP_CONST(0),                                   \
1644                 GPR(sc->cache_gpr[OUT_CACHE_IDX]),              \
1645                 GPR(sc->mixer_gpr[OUT_GPR_IDX]),                \
1646                 &pc);                                           \
1647 } while (0)
1648
1649 /* like EFX_OUTPUT, but don't allocate mixer gpr */
1650 #define EFX_OUTPUTD(OUT_CACHE_IDX, OUT_GPR_IDX, OUTP_NR) do {   \
1651         emu_addefxop(sc, MACS,                                  \
1652                 OUTP(OUTP_NR),                                  \
1653                 DSP_CONST(0),                                   \
1654                 GPR(sc->cache_gpr[OUT_CACHE_IDX]),              \
1655                 GPR(sc->mixer_gpr[OUT_GPR_IDX]),                \
1656                 &pc);                                           \
1657 } while (0)
1658
1659 /* skip next OPCOUNT instructions if FLAG != 0 */
1660 #define EFX_SKIP(OPCOUNT, FLAG_GPR) do {                        \
1661         emu_addefxop(sc, MACS,                                  \
1662                 DSP_CONST(0),                                   \
1663                 GPR(sc->mute_gpr[FLAG_GPR]),                                    \
1664                 DSP_CONST(0),                                   \
1665                 DSP_CONST(0),                                   \
1666                 &pc);                                           \
1667         emu_addefxop(sc, SKIP,                                  \
1668                 DSP_CCR,                                        \
1669                 DSP_CCR,                                        \
1670                 COND_NEQ_ZERO,                                  \
1671                 OPCOUNT,                                        \
1672                 &pc);                                           \
1673 } while (0)
1674
1675 #define EFX_COPY(TO, FROM) do {                                 \
1676         emu_addefxop(sc, ACC3,                                  \
1677                 TO,                                             \
1678                 DSP_CONST(0),                                   \
1679                 DSP_CONST(0),                                   \
1680                 FROM,                                           \
1681                 &pc);                                           \
1682 } while (0)
1683
1684
1685 static void
1686 emu_initefx(struct emu_sc_info *sc)
1687 {
1688         unsigned int i;
1689         uint32_t pc;
1690
1691         /* stop DSP */
1692         if (sc->is_emu10k1) {
1693                 emu_wrptr(sc, 0, DBG, EMU10K1_DBG_SINGLE_STEP);
1694         } else {
1695                 emu_wrptr(sc, 0, A_DBG, A_DBG_SINGLE_STEP);
1696         }
1697
1698         /* code size is in instructions */
1699         pc = 0;
1700         for (i = 0; i < sc->code_size; i++) {
1701                 if (sc->is_emu10k1) {
1702                         emu_addefxop(sc, ACC3, DSP_CONST(0x0), DSP_CONST(0x0), DSP_CONST(0x0), DSP_CONST(0x0), &pc);
1703                 } else {
1704                         emu_addefxop(sc, SKIP, DSP_CONST(0x0), DSP_CONST(0x0), DSP_CONST(0xf), DSP_CONST(0x0), &pc);
1705                 }
1706         }
1707
1708         /* allocate GPRs for mute switches (EFX_SKIP). Mute by default */
1709         for (i = 0; i < NUM_MUTE; i++) {
1710                 sc->mute_gpr[i] = emu_rm_gpr_alloc(sc->rm, 1);
1711                 emumix_set_gpr(sc, sc->mute_gpr[i], 1);
1712         }
1713         emu_digitalswitch(sc);
1714
1715         pc = 0;
1716
1717         /*
1718          * DSP code below is not good, because:
1719          * 1. It can be written smaller, if it can use DSP accumulator register
1720          * instead of cache_gpr[].
1721          * 2. It can be more careful when volume is 100%, because in DSP
1722          * x*0x7fffffff may not be equal to x !
1723          */
1724
1725         /* clean outputs */
1726         for (i = 0; i < 16 ; i++) {
1727                 emu_addefxop(sc, ACC3, OUTP(i), DSP_CONST(0), DSP_CONST(0), DSP_CONST(0), &pc);
1728         }
1729
1730
1731         if (sc->is_emu10k1) {
1732                 EFX_CACHE(C_FRONT_L);
1733                 EFX_CACHE(C_FRONT_R);
1734                 EFX_CACHE(C_REC_L);
1735                 EFX_CACHE(C_REC_R);
1736
1737                 /* fx0 to front/record, 100%/muted by default */
1738                 EFX_ROUTE("pcm_front_l", FX(0), M_FX0_FRONT_L, C_FRONT_L, 100);
1739                 EFX_ROUTE("pcm_front_r", FX(1), M_FX1_FRONT_R, C_FRONT_R, 100);
1740                 EFX_ROUTE(NULL, FX(0), M_FX0_REC_L, C_REC_L, 0);
1741                 EFX_ROUTE(NULL, FX(1), M_FX1_REC_R, C_REC_R, 0);
1742
1743                 /* in0, from AC97 codec output */
1744                 EFX_ROUTE("ac97_front_l", INP(IN_AC97_L), M_IN0_FRONT_L, C_FRONT_L, 0);
1745                 EFX_ROUTE("ac97_front_r", INP(IN_AC97_R), M_IN0_FRONT_R, C_FRONT_R, 0);
1746                 EFX_ROUTE("ac97_rec_l", INP(IN_AC97_L), M_IN0_REC_L, C_REC_L, 0);
1747                 EFX_ROUTE("ac97_rec_r", INP(IN_AC97_R), M_IN0_REC_R, C_REC_R, 0);
1748
1749                 /* in1, from CD S/PDIF */
1750                 /* XXX EFX_SKIP 4 assumes that each EFX_ROUTE is one DSP op */
1751                 EFX_SKIP(4, CDSPDIFMUTE);
1752                 EFX_ROUTE(NULL, INP(IN_SPDIF_CD_L), M_IN1_FRONT_L, C_FRONT_L, 0);
1753                 EFX_ROUTE(NULL, INP(IN_SPDIF_CD_R), M_IN1_FRONT_R, C_FRONT_R, 0);
1754                 EFX_ROUTE(NULL, INP(IN_SPDIF_CD_L), M_IN1_REC_L, C_REC_L, 0);
1755                 EFX_ROUTE(NULL, INP(IN_SPDIF_CD_R), M_IN1_REC_R, C_REC_R, 0);
1756
1757                 if (sc->dbg_level > 0) {
1758                         /* in2, ZoomVide (???) */
1759                         EFX_ROUTE("zoom_front_l", INP(IN_ZOOM_L), M_IN2_FRONT_L, C_FRONT_L, 0);
1760                         EFX_ROUTE("zoom_front_r", INP(IN_ZOOM_R), M_IN2_FRONT_R, C_FRONT_R, 0);
1761                         EFX_ROUTE("zoom_rec_l", INP(IN_ZOOM_L), M_IN2_REC_L, C_REC_L, 0);
1762                         EFX_ROUTE("zoom_rec_r", INP(IN_ZOOM_R), M_IN2_REC_R, C_REC_R, 0);
1763                 }
1764
1765                 /* in3, TOSLink  */
1766                 EFX_ROUTE(NULL, INP(IN_TOSLINK_L), M_IN3_FRONT_L, C_FRONT_L, 0);
1767                 EFX_ROUTE(NULL, INP(IN_TOSLINK_R), M_IN3_FRONT_R, C_FRONT_R, 0);
1768                 EFX_ROUTE(NULL, INP(IN_TOSLINK_L), M_IN3_REC_L, C_REC_L, 0);
1769                 EFX_ROUTE(NULL, INP(IN_TOSLINK_R), M_IN3_REC_R, C_REC_R, 0);
1770                 /* in4, LineIn  */
1771                 EFX_ROUTE(NULL, INP(IN_LINE1_L), M_IN4_FRONT_L, C_FRONT_L, 0);
1772                 EFX_ROUTE(NULL, INP(IN_LINE1_R), M_IN4_FRONT_R, C_FRONT_R, 0);
1773                 EFX_ROUTE(NULL, INP(IN_LINE1_L), M_IN4_REC_L, C_REC_L, 0);
1774                 EFX_ROUTE(NULL, INP(IN_LINE1_R), M_IN4_REC_R, C_REC_R, 0);
1775
1776                 /* in5, on-card S/PDIF */
1777                 EFX_ROUTE(NULL, INP(IN_COAX_SPDIF_L), M_IN5_FRONT_L, C_FRONT_L, 0);
1778                 EFX_ROUTE(NULL, INP(IN_COAX_SPDIF_R), M_IN5_FRONT_R, C_FRONT_R, 0);
1779                 EFX_ROUTE(NULL, INP(IN_COAX_SPDIF_L), M_IN5_REC_L, C_REC_L, 0);
1780                 EFX_ROUTE(NULL, INP(IN_COAX_SPDIF_R), M_IN5_REC_R, C_REC_R, 0);
1781
1782                 /* in6, Line2 on Live!Drive */
1783                 EFX_ROUTE(NULL, INP(IN_LINE2_L), M_IN6_FRONT_L, C_FRONT_L, 0);
1784                 EFX_ROUTE(NULL, INP(IN_LINE2_R), M_IN6_FRONT_R, C_FRONT_R, 0);
1785                 EFX_ROUTE(NULL, INP(IN_LINE2_L), M_IN6_REC_L, C_REC_L, 0);
1786                 EFX_ROUTE(NULL, INP(IN_LINE2_R), M_IN6_REC_R, C_REC_R, 0);
1787
1788                 if (sc->dbg_level > 0) {
1789                         /* in7, unknown */
1790                         EFX_ROUTE("in7_front_l", INP(0xE), M_IN7_FRONT_L, C_FRONT_L, 0);
1791                         EFX_ROUTE("in7_front_r", INP(0xF), M_IN7_FRONT_R, C_FRONT_R, 0);
1792                         EFX_ROUTE("in7_rec_l", INP(0xE), M_IN7_REC_L, C_REC_L, 0);
1793                         EFX_ROUTE("in7_rec_r", INP(0xF), M_IN7_REC_R, C_REC_R, 0);
1794                 }
1795
1796                 /* analog and digital */
1797                 EFX_OUTPUT("master_front_l", C_FRONT_L, M_MASTER_FRONT_L, OUT_AC97_L, 100);
1798                 EFX_OUTPUT("master_front_r", C_FRONT_R, M_MASTER_FRONT_R, OUT_AC97_R, 100);
1799                 /* S/PDIF */
1800                 EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, OUT_TOSLINK_L);
1801                 EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, OUT_TOSLINK_R);
1802                 /* Headphones */
1803                 EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, OUT_HEADPHONE_L);
1804                 EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, OUT_HEADPHONE_R);
1805
1806                 /* rec output to "ADC" */
1807                 EFX_OUTPUT("master_rec_l", C_REC_L, M_MASTER_REC_L, OUT_ADC_REC_L, 100);
1808                 EFX_OUTPUT("master_rec_r", C_REC_R, M_MASTER_REC_R, OUT_ADC_REC_R, 100);
1809
1810                 if (!(sc->mch_disabled)) {
1811                         /*
1812                          * Additional channel volume is controlled by mixer in
1813                          * emu_dspmixer_set() in -pcm.c
1814                          */
1815
1816                         /* fx2/3 (pcm1) to rear */
1817                         EFX_CACHE(C_REAR_L);
1818                         EFX_CACHE(C_REAR_R);
1819                         EFX_ROUTE(NULL, FX(2), M_FX2_REAR_L, C_REAR_L, 100);
1820                         EFX_ROUTE(NULL, FX(3), M_FX3_REAR_R, C_REAR_R, 100);
1821
1822                         EFX_OUTPUT(NULL, C_REAR_L, M_MASTER_REAR_L, OUT_REAR_L, 100);
1823                         EFX_OUTPUT(NULL, C_REAR_R, M_MASTER_REAR_R, OUT_REAR_R, 100);
1824                         if (sc->has_51) {
1825                                 /* fx4 (pcm2) to center */
1826                                 EFX_CACHE(C_CENTER);
1827                                 EFX_ROUTE(NULL, FX(4), M_FX4_CENTER, C_CENTER, 100);
1828                                 EFX_OUTPUT(NULL, C_CENTER, M_MASTER_CENTER, OUT_D_CENTER, 100);
1829
1830                                 /* XXX in digital mode (default) this should be muted because
1831                                 this output is shared with digital out */
1832                                 EFX_SKIP(1, ANALOGMUTE);
1833                                 EFX_OUTPUTD(C_CENTER, M_MASTER_CENTER, OUT_A_CENTER);
1834
1835                                 /* fx5 (pcm3) to sub */
1836                                 EFX_CACHE(C_SUB);
1837                                 EFX_ROUTE(NULL, FX(5), M_FX5_SUBWOOFER, C_SUB, 100);
1838                                 EFX_OUTPUT(NULL, C_SUB, M_MASTER_SUBWOOFER, OUT_D_SUB, 100);
1839
1840                                 /* XXX in digital mode (default) this should be muted because
1841                                 this output is shared with digital out */
1842                                 EFX_SKIP(1, ANALOGMUTE);
1843                                 EFX_OUTPUTD(C_SUB, M_MASTER_SUBWOOFER, OUT_A_SUB);
1844
1845                         }
1846                 } else {
1847                         /* SND_EMU10KX_MULTICHANNEL_DISABLED */
1848                         EFX_OUTPUT(NULL, C_FRONT_L, M_MASTER_REAR_L, OUT_REAR_L, 57); /* 75%*75% */
1849                         EFX_OUTPUT(NULL, C_FRONT_R, M_MASTER_REAR_R, OUT_REAR_R, 57); /* 75%*75% */
1850
1851 #if 0
1852                         /* XXX 5.1 does not work */
1853
1854                         if (sc->has_51) {
1855                                 /* (fx0+fx1)/2 to center */
1856                                 EFX_CACHE(C_CENTER);
1857                                 emu_addefxop(sc, MACS,
1858                                         GPR(sc->cache_gpr[C_CENTER]),
1859                                         GPR(sc->cache_gpr[C_CENTER]),
1860                                         DSP_CONST(0xd), /* = 1/2 */
1861                                         GPR(sc->cache_gpr[C_FRONT_L]),
1862                                         &pc);
1863                                 emu_addefxop(sc, MACS,
1864                                         GPR(sc->cache_gpr[C_CENTER]),
1865                                         GPR(sc->cache_gpr[C_CENTER]),
1866                                         DSP_CONST(0xd), /* = 1/2 */
1867                                         GPR(sc->cache_gpr[C_FRONT_R]),
1868                                         &pc);
1869                                 EFX_OUTPUT(NULL, C_CENTER, M_MASTER_CENTER, OUT_D_CENTER, 100);
1870
1871                                 /* XXX in digital mode (default) this should be muted because
1872                                 this output is shared with digital out */
1873                                 EFX_SKIP(1, ANALOGMUTE);
1874                                 EFX_OUTPUTD(C_CENTER, M_MASTER_CENTER, OUT_A_CENTER);
1875
1876                                 /* (fx0+fx1)/2  to sub */
1877                                 EFX_CACHE(C_SUB);
1878                                 emu_addefxop(sc, MACS,
1879                                         GPR(sc->cache_gpr[C_CENTER]),
1880                                         GPR(sc->cache_gpr[C_CENTER]),
1881                                         DSP_CONST(0xd), /* = 1/2 */
1882                                         GPR(sc->cache_gpr[C_FRONT_L]),
1883                                         &pc);
1884                                 emu_addefxop(sc, MACS,
1885                                         GPR(sc->cache_gpr[C_CENTER]),
1886                                         GPR(sc->cache_gpr[C_CENTER]),
1887                                         DSP_CONST(0xd), /* = 1/2 */
1888                                         GPR(sc->cache_gpr[C_FRONT_R]),
1889                                         &pc);
1890                                 /* XXX add lowpass filter here */
1891
1892                                 EFX_OUTPUT(NULL, C_SUB, M_MASTER_SUBWOOFER, OUT_D_SUB, 100);
1893
1894                                 /* XXX in digital mode (default) this should be muted because
1895                                 this output is shared with digital out */
1896                                 EFX_SKIP(1, ANALOGMUTE);
1897                                 EFX_OUTPUTD(C_SUB, M_MASTER_SUBWOOFER, OUT_A_SUB);
1898                         }
1899 #endif
1900                 } /* !mch_disabled */
1901                 if (sc->mch_rec) {
1902                         /*
1903                          * MCH RECORDING , hight 16 slots. On 5.1 cards first 4 slots
1904                          * are used as outputs and already filled with data
1905                          */
1906                         /*
1907                          * XXX On Live! cards stream does not begin at zero offset.
1908                          * It can be HW, driver or sound buffering problem.
1909                          * Use sync substream (offset 0x3E) to let userland find
1910                          * correct data.
1911                          */
1912
1913                         /*
1914                          * Substream map (in byte offsets, each substream is 2 bytes):
1915                          *      0x00..0x1E - outputs
1916                          *      0x20..0x3E - FX, inputs ans sync stream
1917                          */
1918
1919                         /* First 2 channels (offset 0x20,0x22) are empty */
1920                         for(i = (sc->has_51 ? 2 : 0); i < 2; i++)
1921                                 EFX_COPY(FX2(i), DSP_CONST(0));
1922
1923                         /* PCM Playback monitoring, offset 0x24..0x2A */
1924                         for(i = 0; i < 4; i++)
1925                                 EFX_COPY(FX2(i+2), FX(i));
1926
1927                         /* Copy of some inputs, offset 0x2C..0x3C */
1928                         for(i = 0; i < 9; i++)
1929                                 EFX_COPY(FX2(i+8), INP(i));
1930
1931                         /* sync data (0xc0de, offset 0x3E) */
1932                         sc->dummy_gpr = emu_rm_gpr_alloc(sc->rm, 1);
1933                         emumix_set_gpr(sc, sc->dummy_gpr, 0xc0de0000);
1934
1935                         EFX_COPY(FX2(15), GPR(sc->dummy_gpr));
1936                 } /* mch_rec */
1937         } else /* emu10k2 and later */ {
1938                 EFX_CACHE(C_FRONT_L);
1939                 EFX_CACHE(C_FRONT_R);
1940                 EFX_CACHE(C_REC_L);
1941                 EFX_CACHE(C_REC_R);
1942
1943                 /* fx0 to front/record, 100%/muted by default */
1944                 /*
1945                  * FRONT_[L|R] is controlled by AC97 emulation in
1946                  * emu_ac97_[read|write]_emulation in -pcm.c
1947                  */
1948                 EFX_ROUTE(NULL, FX(0), M_FX0_FRONT_L, C_FRONT_L, 100);
1949                 EFX_ROUTE(NULL, FX(1), M_FX1_FRONT_R, C_FRONT_R, 100);
1950                 EFX_ROUTE(NULL, FX(0), M_FX0_REC_L, C_REC_L, 0);
1951                 EFX_ROUTE(NULL, FX(1), M_FX1_REC_R, C_REC_R, 0);
1952
1953                 /* in0, from AC97 codec output */
1954                 EFX_ROUTE(NULL, INP(A_IN_AC97_L), M_IN0_FRONT_L, C_FRONT_L, 100);
1955                 EFX_ROUTE(NULL, INP(A_IN_AC97_R), M_IN0_FRONT_R, C_FRONT_R, 100);
1956                 EFX_ROUTE(NULL, INP(A_IN_AC97_L), M_IN0_REC_L, C_REC_L, 0);
1957                 EFX_ROUTE(NULL, INP(A_IN_AC97_R), M_IN0_REC_R, C_REC_R, 0);
1958
1959                 /* in1, from CD S/PDIF */
1960                 EFX_ROUTE(NULL, INP(A_IN_SPDIF_CD_L), M_IN1_FRONT_L, C_FRONT_L, 0);
1961                 EFX_ROUTE(NULL, INP(A_IN_SPDIF_CD_R), M_IN1_FRONT_R, C_FRONT_R, 0);
1962                 EFX_ROUTE(NULL, INP(A_IN_SPDIF_CD_L), M_IN1_REC_L, C_REC_L, 0);
1963                 EFX_ROUTE(NULL, INP(A_IN_SPDIF_CD_R), M_IN1_REC_R, C_REC_R, 0);
1964
1965                 /* in2, optical & coax S/PDIF on AudigyDrive*/
1966                 /* XXX Should be muted when GPRSCS valid stream == 0 */
1967                 EFX_ROUTE(NULL, INP(A_IN_O_SPDIF_L), M_IN2_FRONT_L, C_FRONT_L, 0);
1968                 EFX_ROUTE(NULL, INP(A_IN_O_SPDIF_R), M_IN2_FRONT_R, C_FRONT_R, 0);
1969                 EFX_ROUTE(NULL, INP(A_IN_O_SPDIF_L), M_IN2_REC_L, C_REC_L, 0);
1970                 EFX_ROUTE(NULL, INP(A_IN_O_SPDIF_R), M_IN2_REC_R, C_REC_R, 0);
1971
1972                 if (sc->dbg_level > 0) {
1973                         /* in3, unknown */
1974                         EFX_ROUTE("in3_front_l", INP(0x6), M_IN3_FRONT_L, C_FRONT_L, 0);
1975                         EFX_ROUTE("in3_front_r", INP(0x7), M_IN3_FRONT_R, C_FRONT_R, 0);
1976                         EFX_ROUTE("in3_rec_l", INP(0x6), M_IN3_REC_L, C_REC_L, 0);
1977                         EFX_ROUTE("in3_rec_r", INP(0x7), M_IN3_REC_R, C_REC_R, 0);
1978                 }
1979
1980                 /* in4, LineIn 2 on AudigyDrive */
1981                 EFX_ROUTE(NULL, INP(A_IN_LINE2_L), M_IN4_FRONT_L, C_FRONT_L, 0);
1982                 EFX_ROUTE(NULL, INP(A_IN_LINE2_R), M_IN4_FRONT_R, C_FRONT_R, 0);
1983                 EFX_ROUTE(NULL, INP(A_IN_LINE2_L), M_IN4_REC_L, C_REC_L, 0);
1984                 EFX_ROUTE(NULL, INP(A_IN_LINE2_R), M_IN4_REC_R, C_REC_R, 0);
1985
1986                 /* in5, on-card S/PDIF */
1987                 EFX_ROUTE(NULL, INP(A_IN_R_SPDIF_L), M_IN5_FRONT_L, C_FRONT_L, 0);
1988                 EFX_ROUTE(NULL, INP(A_IN_R_SPDIF_R), M_IN5_FRONT_R, C_FRONT_R, 0);
1989                 EFX_ROUTE(NULL, INP(A_IN_R_SPDIF_L), M_IN5_REC_L, C_REC_L, 0);
1990                 EFX_ROUTE(NULL, INP(A_IN_R_SPDIF_R), M_IN5_REC_R, C_REC_R, 0);
1991
1992                 /* in6, AUX2 on AudigyDrive */
1993                 EFX_ROUTE(NULL, INP(A_IN_AUX2_L), M_IN6_FRONT_L, C_FRONT_L, 0);
1994                 EFX_ROUTE(NULL, INP(A_IN_AUX2_R), M_IN6_FRONT_R, C_FRONT_R, 0);
1995                 EFX_ROUTE(NULL, INP(A_IN_AUX2_L), M_IN6_REC_L, C_REC_L, 0);
1996                 EFX_ROUTE(NULL, INP(A_IN_AUX2_R), M_IN6_REC_R, C_REC_R, 0);
1997
1998                 if (sc->dbg_level > 0) {
1999                         /* in7, unknown */
2000                         EFX_ROUTE("in7_front_l", INP(0xE), M_IN7_FRONT_L, C_FRONT_L, 0);
2001                         EFX_ROUTE("in7_front_r", INP(0xF), M_IN7_FRONT_R, C_FRONT_R, 0);
2002                         EFX_ROUTE("in7_rec_l", INP(0xE), M_IN7_REC_L, C_REC_L, 0);
2003                         EFX_ROUTE("in7_rec_r", INP(0xF), M_IN7_REC_R, C_REC_R, 0);
2004                 }
2005
2006                 /* front output to headphones and  alog and digital *front */
2007                 /* volume controlled by AC97 emulation */
2008                 EFX_OUTPUT(NULL, C_FRONT_L, M_MASTER_FRONT_L, A_OUT_A_FRONT_L, 100);
2009                 EFX_OUTPUT(NULL, C_FRONT_R, M_MASTER_FRONT_R, A_OUT_A_FRONT_R, 100);
2010                 EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, A_OUT_D_FRONT_L);
2011                 EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, A_OUT_D_FRONT_R);
2012                 EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, A_OUT_HPHONE_L);
2013                 EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, A_OUT_HPHONE_R);
2014
2015                 /* rec output to "ADC" */
2016                 /* volume controlled by AC97 emulation */
2017                 EFX_OUTPUT(NULL, C_REC_L, M_MASTER_REC_L, A_OUT_ADC_REC_L, 100);
2018                 EFX_OUTPUT(NULL, C_REC_R, M_MASTER_REC_R, A_OUT_ADC_REC_R, 100);
2019
2020                 if (!(sc->mch_disabled)) {
2021                         /*
2022                          * Additional channel volume is controlled by mixer in
2023                          * emu_dspmixer_set() in -pcm.c
2024                          */
2025
2026                         /* fx2/3 (pcm1) to rear */
2027                         EFX_CACHE(C_REAR_L);
2028                         EFX_CACHE(C_REAR_R);
2029                         EFX_ROUTE(NULL, FX(2), M_FX2_REAR_L, C_REAR_L, 100);
2030                         EFX_ROUTE(NULL, FX(3), M_FX3_REAR_R, C_REAR_R, 100);
2031
2032                         EFX_OUTPUT(NULL, C_REAR_L, M_MASTER_REAR_L, A_OUT_A_REAR_L, 100);
2033                         EFX_OUTPUT(NULL, C_REAR_R, M_MASTER_REAR_R, A_OUT_A_REAR_R, 100);
2034                         EFX_OUTPUTD(C_REAR_L, M_MASTER_REAR_L, A_OUT_D_REAR_L);
2035                         EFX_OUTPUTD(C_REAR_R, M_MASTER_REAR_R, A_OUT_D_REAR_R);
2036
2037                         /* fx4 (pcm2) to center */
2038                         EFX_CACHE(C_CENTER);
2039                         EFX_ROUTE(NULL, FX(4), M_FX4_CENTER, C_CENTER, 100);
2040                         EFX_OUTPUT(NULL, C_CENTER, M_MASTER_CENTER, A_OUT_D_CENTER, 100);
2041 #if 0
2042                         /*
2043                          * XXX in digital mode (default) this should be muted
2044                          * because this output is shared with digital out
2045                          */
2046                         EFX_OUTPUTD(C_CENTER, M_MASTER_CENTER, A_OUT_A_CENTER);
2047 #endif
2048                         /* fx5 (pcm3) to sub */
2049                         EFX_CACHE(C_SUB);
2050                         EFX_ROUTE(NULL, FX(5), M_FX5_SUBWOOFER, C_SUB, 100);
2051                         EFX_OUTPUT(NULL, C_SUB, M_MASTER_SUBWOOFER, A_OUT_D_SUB, 100);
2052 #if 0
2053                         /*
2054                          * XXX in digital mode (default) this should be muted
2055                          * because this output is shared with digital out
2056                          */
2057                         EFX_OUTPUTD(C_SUB, M_MASTER_SUBWOOFER, A_OUT_A_SUB);
2058 #endif
2059                         if (sc->has_71) {
2060                                 /* XXX this will broke headphones on AudigyDrive */
2061                                 /* fx6/7 (pcm4) to side */
2062                                 EFX_CACHE(C_SIDE_L);
2063                                 EFX_CACHE(C_SIDE_R);
2064                                 EFX_ROUTE(NULL, FX(6), M_FX6_SIDE_L, C_SIDE_L, 100);
2065                                 EFX_ROUTE(NULL, FX(7), M_FX7_SIDE_R, C_SIDE_R, 100);
2066                                 EFX_OUTPUT(NULL, C_SIDE_L, M_MASTER_SIDE_L, A_OUT_A_SIDE_L, 100);
2067                                 EFX_OUTPUT(NULL, C_SIDE_R, M_MASTER_SIDE_R, A_OUT_A_SIDE_R, 100);
2068                                 EFX_OUTPUTD(C_SIDE_L, M_MASTER_SIDE_L, A_OUT_D_SIDE_L);
2069                                 EFX_OUTPUTD(C_SIDE_R, M_MASTER_SIDE_R, A_OUT_D_SIDE_R);
2070                         }
2071                 } else {        /* mch_disabled */
2072                         EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, A_OUT_A_REAR_L);
2073                         EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, A_OUT_A_REAR_R);
2074
2075                         EFX_OUTPUTD(C_FRONT_L, M_MASTER_FRONT_L, A_OUT_D_REAR_L);
2076                         EFX_OUTPUTD(C_FRONT_R, M_MASTER_FRONT_R, A_OUT_D_REAR_R);
2077
2078                         if (sc->has_51) {
2079                                 /* (fx0+fx1)/2 to center */
2080                                 EFX_CACHE(C_CENTER);
2081                                 emu_addefxop(sc, MACS,
2082                                         GPR(sc->cache_gpr[C_CENTER]),
2083                                         GPR(sc->cache_gpr[C_CENTER]),
2084                                         DSP_CONST(0xd), /* = 1/2 */
2085                                         GPR(sc->cache_gpr[C_FRONT_L]),
2086                                         &pc);
2087                                 emu_addefxop(sc, MACS,
2088                                         GPR(sc->cache_gpr[C_CENTER]),
2089                                         GPR(sc->cache_gpr[C_CENTER]),
2090                                         DSP_CONST(0xd), /* = 1/2 */
2091                                         GPR(sc->cache_gpr[C_FRONT_R]),
2092                                         &pc);
2093                                 EFX_OUTPUT(NULL, C_CENTER, M_MASTER_CENTER, A_OUT_D_CENTER, 100);
2094
2095                                 /* XXX in digital mode (default) this should be muted because
2096                                 this output is shared with digital out */
2097                                 EFX_SKIP(1, ANALOGMUTE);
2098                                 EFX_OUTPUTD(C_CENTER, M_MASTER_CENTER, A_OUT_A_CENTER);
2099
2100                                 /* (fx0+fx1)/2  to sub */
2101                                 EFX_CACHE(C_SUB);
2102                                 emu_addefxop(sc, MACS,
2103                                         GPR(sc->cache_gpr[C_SUB]),
2104                                         GPR(sc->cache_gpr[C_SUB]),
2105                                         DSP_CONST(0xd), /* = 1/2 */
2106                                         GPR(sc->cache_gpr[C_FRONT_L]),
2107                                         &pc);
2108                                 emu_addefxop(sc, MACS,
2109                                         GPR(sc->cache_gpr[C_SUB]),
2110                                         GPR(sc->cache_gpr[C_SUB]),
2111                                         DSP_CONST(0xd), /* = 1/2 */
2112                                         GPR(sc->cache_gpr[C_FRONT_R]),
2113                                         &pc);
2114                                 /* XXX add lowpass filter here */
2115
2116                                 EFX_OUTPUT(NULL, C_SUB, M_MASTER_SUBWOOFER, A_OUT_D_SUB, 100);
2117
2118                                 /* XXX in digital mode (default) this should be muted because
2119                                 this output is shared with digital out */
2120                                 EFX_SKIP(1, ANALOGMUTE);
2121                                 EFX_OUTPUTD(C_SUB, M_MASTER_SUBWOOFER, A_OUT_A_SUB);
2122                         }
2123                 } /* mch_disabled */
2124                 if (sc->mch_rec) {
2125                         /* MCH RECORDING, high 32 slots */
2126
2127                         /*
2128                          * Stream map (in byte offsets):
2129                          *      0x00..0x3E - outputs
2130                          *      0x40..0x7E - FX, inputs
2131                          *      each substream is 2 bytes.
2132                          */
2133                         /*
2134                          * XXX Audigy 2 Value cards (and, possibly,
2135                          * Audigy 4) write some unknown data in place of
2136                          * some outputs (offsets 0x20..0x3F) and one
2137                          * input (offset 0x7E).
2138                          */
2139
2140                         /* PCM Playback monitoring, offsets 0x40..0x5E */
2141                         for(i = 0; i < 16; i++)
2142                                 EFX_COPY(FX2(i), FX(i));
2143
2144                         /* Copy of all inputs, offsets 0x60..0x7E */
2145                         for(i = 0; i < 16; i++)
2146                                 EFX_COPY(FX2(i+16), INP(i));
2147 #if 0
2148                         /* XXX Audigy seems to work correct and does not need this */
2149                         /* sync data (0xc0de), offset 0x7E */
2150                         sc->dummy_gpr = emu_rm_gpr_alloc(sc->rm, 1);
2151                         emumix_set_gpr(sc, sc->dummy_gpr, 0xc0de0000);
2152                         EFX_COPY(FX2(31), GPR(sc->dummy_gpr));
2153 #endif
2154                 } /* mch_rec */
2155         }
2156
2157         sc->routing_code_end = pc;
2158
2159         /* start DSP */
2160         if (sc->is_emu10k1) {
2161                 emu_wrptr(sc, 0, DBG, 0);
2162         } else {
2163                 emu_wrptr(sc, 0, A_DBG, 0);
2164         }
2165 }
2166
2167 /* /dev/em10kx */
2168 static d_open_t         emu10kx_open;
2169 static d_close_t        emu10kx_close;
2170 static d_read_t         emu10kx_read;
2171
2172 static struct cdevsw emu10kx_cdevsw = {
2173         .d_open =       emu10kx_open,
2174         .d_close =      emu10kx_close,
2175         .d_read =       emu10kx_read,
2176         .d_name =       "emu10kx",
2177         .d_version =    D_VERSION,
2178 };
2179
2180
2181 static int
2182 emu10kx_open(struct cdev *i_dev, int flags __unused, int mode __unused, struct thread *td __unused)
2183 {
2184         int error;
2185         struct emu_sc_info *sc;
2186
2187         sc = i_dev->si_drv1;
2188         mtx_lock(&sc->emu10kx_lock);
2189         if (sc->emu10kx_isopen) {
2190                 mtx_unlock(&sc->emu10kx_lock);
2191                 return (EBUSY);
2192         }
2193         sc->emu10kx_isopen = 1;
2194         mtx_unlock(&sc->emu10kx_lock);
2195         if (sbuf_new(&sc->emu10kx_sbuf, NULL, 4096, 0) == NULL) {
2196                 error = ENXIO;
2197                 goto out;
2198         }
2199         sc->emu10kx_bufptr = 0;
2200         error = (emu10kx_prepare(sc, &sc->emu10kx_sbuf) > 0) ? 0 : ENOMEM;
2201 out:
2202         if (error) {
2203                 mtx_lock(&sc->emu10kx_lock);
2204                 sc->emu10kx_isopen = 0;
2205                 mtx_unlock(&sc->emu10kx_lock);
2206         }
2207         return (error);
2208 }
2209
2210 static int
2211 emu10kx_close(struct cdev *i_dev, int flags __unused, int mode __unused, struct thread *td __unused)
2212 {
2213         struct emu_sc_info *sc;
2214
2215         sc = i_dev->si_drv1;
2216
2217         mtx_lock(&sc->emu10kx_lock);
2218         if (!(sc->emu10kx_isopen)) {
2219                 mtx_unlock(&sc->emu10kx_lock);
2220                 return (EBADF);
2221         }
2222         sbuf_delete(&sc->emu10kx_sbuf);
2223         sc->emu10kx_isopen = 0;
2224         mtx_unlock(&sc->emu10kx_lock);
2225
2226         return (0);
2227 }
2228
2229 static int
2230 emu10kx_read(struct cdev *i_dev, struct uio *buf, int flag __unused)
2231 {
2232         int l, err;
2233         struct emu_sc_info *sc;
2234
2235         sc = i_dev->si_drv1;
2236         mtx_lock(&sc->emu10kx_lock);
2237         if (!(sc->emu10kx_isopen)) {
2238                 mtx_unlock(&sc->emu10kx_lock);
2239                 return (EBADF);
2240         }
2241         mtx_unlock(&sc->emu10kx_lock);
2242
2243         l = min(buf->uio_resid, sbuf_len(&sc->emu10kx_sbuf) - sc->emu10kx_bufptr);
2244         err = (l > 0) ? uiomove(sbuf_data(&sc->emu10kx_sbuf) + sc->emu10kx_bufptr, l, buf) : 0;
2245         sc->emu10kx_bufptr += l;
2246
2247         return (err);
2248 }
2249
2250 static int
2251 emu10kx_prepare(struct emu_sc_info *sc, struct sbuf *s)
2252 {
2253         int i;
2254
2255         sbuf_printf(s, "FreeBSD EMU10Kx Audio Driver\n");
2256         sbuf_printf(s, "\nHardware resource usage:\n");
2257         sbuf_printf(s, "DSP General Purpose Registers: %d used, %d total\n", sc->rm->num_used, sc->rm->num_gprs);
2258         sbuf_printf(s, "DSP Instruction Registers: %d used, %d total\n", sc->routing_code_end, sc->code_size);
2259         sbuf_printf(s, "Card supports");
2260         if (sc->has_ac97) {
2261                 sbuf_printf(s, " AC97 codec");
2262         } else {
2263                 sbuf_printf(s, " NO AC97 codec");
2264         }
2265         if (sc->has_51) {
2266                 if (sc->has_71)
2267                         sbuf_printf(s, " and 7.1 output");
2268                 else
2269                         sbuf_printf(s, " and 5.1 output");
2270         }
2271         if (sc->is_emu10k1)
2272                 sbuf_printf(s, ", SBLive! DSP code");
2273         if (sc->is_emu10k2)
2274                 sbuf_printf(s, ", Audigy DSP code");
2275         if (sc->is_ca0102)
2276                 sbuf_printf(s, ", Audigy DSP code with Audigy2 hacks");
2277         if (sc->is_ca0108)
2278                 sbuf_printf(s, ", Audigy DSP code with Audigy2Value hacks");
2279         sbuf_printf(s, "\n");
2280         if (sc->broken_digital)
2281                 sbuf_printf(s, "Digital mode unsupported\n");
2282         sbuf_printf(s, "\nInstalled devices:\n");
2283         for (i = 0; i < RT_COUNT; i++)
2284                 if (sc->pcm[i] != NULL)
2285                         if (device_is_attached(sc->pcm[i])) {
2286                                 sbuf_printf(s, "%s on %s\n", device_get_desc(sc->pcm[i]), device_get_nameunit(sc->pcm[i]));
2287                         }
2288         if (sc->midi[0] != NULL)
2289                 if (device_is_attached(sc->midi[0])) {
2290                         sbuf_printf(s, "EMU10Kx MIDI Interface\n");
2291                         sbuf_printf(s, "\tOn-card connector on %s\n", device_get_nameunit(sc->midi[0]));
2292                 }
2293         if (sc->midi[1] != NULL)
2294                 if (device_is_attached(sc->midi[1])) {
2295                         sbuf_printf(s, "\tOn-Drive connector on %s\n", device_get_nameunit(sc->midi[1]));
2296                 }
2297         if (sc->midi[0] != NULL)
2298                 if (device_is_attached(sc->midi[0])) {
2299                         sbuf_printf(s, "\tIR reciever MIDI events %s\n", sc->enable_ir ? "enabled" : "disabled");
2300                 }
2301         sbuf_printf(s, "Card is in %s mode\n", (sc->mode == MODE_ANALOG) ? "analog" : "digital");
2302
2303         sbuf_finish(s);
2304         return (sbuf_len(s));
2305 }
2306
2307 /* INIT & UNINIT */
2308 static int
2309 emu10kx_dev_init(struct emu_sc_info *sc)
2310 {
2311         int unit;
2312
2313         mtx_init(&sc->emu10kx_lock, device_get_nameunit(sc->dev), "kxdevlock", 0);
2314         unit = device_get_unit(sc->dev);
2315
2316         sc->cdev = make_dev(&emu10kx_cdevsw, unit2minor(unit), UID_ROOT, GID_WHEEL, 0640, "emu10kx%d", unit);
2317         if (sc->cdev != NULL) {
2318                 sc->cdev->si_drv1 = sc;
2319                 return (0);
2320         }
2321         return (ENXIO);
2322 }
2323
2324 static int
2325 emu10kx_dev_uninit(struct emu_sc_info *sc)
2326 {
2327         mtx_lock(&sc->emu10kx_lock);
2328         if (sc->emu10kx_isopen) {
2329                 mtx_unlock(&sc->emu10kx_lock);
2330                 return (EBUSY);
2331         }
2332         if (sc->cdev)
2333                 destroy_dev(sc->cdev);
2334         sc->cdev = 0;
2335
2336         mtx_destroy(&sc->emu10kx_lock);
2337         return (0);
2338 }
2339
2340 /* resource manager */
2341 int
2342 emu_rm_init(struct emu_sc_info *sc)
2343 {
2344         int i;
2345         int maxcount;
2346         struct emu_rm *rm;
2347
2348         rm = malloc(sizeof(struct emu_rm), M_DEVBUF, M_NOWAIT | M_ZERO);
2349         if (rm == NULL) {
2350                 return (ENOMEM);
2351         }
2352         sc->rm = rm;
2353         rm->card = sc;
2354         maxcount = sc->num_gprs;
2355         rm->num_used = 0;
2356         mtx_init(&(rm->gpr_lock), device_get_nameunit(sc->dev), "gpr alloc", MTX_DEF);
2357         rm->num_gprs = (maxcount < EMU_MAX_GPR ? maxcount : EMU_MAX_GPR);
2358         for (i = 0; i < rm->num_gprs; i++)
2359                 rm->allocmap[i] = 0;
2360         /* pre-allocate gpr[0] */
2361         rm->allocmap[0] = 1;
2362         rm->last_free_gpr = 1;
2363
2364         return (0);
2365 }
2366
2367 int
2368 emu_rm_uninit(struct emu_sc_info *sc)
2369 {
2370         int i;
2371
2372         if (sc->dbg_level > 1) {
2373                 mtx_lock(&(sc->rm->gpr_lock));
2374                 for (i = 1; i < sc->rm->last_free_gpr; i++)
2375                         if (sc->rm->allocmap[i] > 0)
2376                                 device_printf(sc->dev, "rm: gpr %d not free before uninit\n", i);
2377                 mtx_unlock(&(sc->rm->gpr_lock));
2378         }
2379
2380         mtx_destroy(&(sc->rm->gpr_lock));
2381         free(sc->rm, M_DEVBUF);
2382         return (0);
2383 }
2384
2385 static int
2386 emu_rm_gpr_alloc(struct emu_rm *rm, int count)
2387 {
2388         int i, j;
2389         int allocated_gpr;
2390
2391         allocated_gpr = rm->num_gprs;
2392         /* try fast way first */
2393         mtx_lock(&(rm->gpr_lock));
2394         if (rm->last_free_gpr + count <= rm->num_gprs) {
2395                 allocated_gpr = rm->last_free_gpr;
2396                 rm->last_free_gpr += count;
2397                 rm->allocmap[allocated_gpr] = count;
2398                 for (i = 1; i < count; i++)
2399                         rm->allocmap[allocated_gpr + i] = -(count - i);
2400         } else {
2401                 /* longer */
2402                 i = 0;
2403                 allocated_gpr = rm->num_gprs;
2404                 while (i < rm->last_free_gpr - count) {
2405                         if (rm->allocmap[i] > 0) {
2406                                 i += rm->allocmap[i];
2407                         } else {
2408                                 allocated_gpr = i;
2409                                 for (j = 1; j < count; j++) {
2410                                         if (rm->allocmap[i + j] != 0)
2411                                                 allocated_gpr = rm->num_gprs;
2412                                 }
2413                                 if (allocated_gpr == i)
2414                                         break;
2415                         }
2416                 }
2417                 if (allocated_gpr + count < rm->last_free_gpr) {
2418                         rm->allocmap[allocated_gpr] = count;
2419                         for (i = 1; i < count; i++)
2420                                 rm->allocmap[allocated_gpr + i] = -(count - i);
2421
2422                 }
2423         }
2424         if (allocated_gpr == rm->num_gprs)
2425                 allocated_gpr = (-1);
2426         if (allocated_gpr >= 0)
2427                 rm->num_used += count;
2428         mtx_unlock(&(rm->gpr_lock));
2429         return (allocated_gpr);
2430 }
2431
2432 /* mixer */
2433 void
2434 emumix_set_mode(struct emu_sc_info *sc, int mode)
2435 {
2436         uint32_t a_iocfg;
2437         uint32_t hcfg;
2438         uint32_t tmp;
2439
2440         switch (mode) {
2441         case MODE_DIGITAL:
2442                 /* FALLTHROUGH */
2443         case MODE_ANALOG:
2444                 break;
2445         default:
2446                 return;
2447         }
2448
2449         hcfg = HCFG_AUDIOENABLE | HCFG_AUTOMUTE;
2450         a_iocfg = 0;
2451
2452         if (sc->rev >= 6)
2453                 hcfg |= HCFG_JOYENABLE;
2454
2455         if (sc->is_emu10k1)
2456                 hcfg |= HCFG_LOCKTANKCACHE_MASK;
2457         else
2458                 hcfg |= HCFG_CODECFORMAT_I2S | HCFG_JOYENABLE;
2459
2460
2461         if (mode == MODE_DIGITAL) {
2462                 if (sc->broken_digital) {
2463                         device_printf(sc->dev, "Digital mode is reported as broken on this card.\n");
2464                 }
2465                 a_iocfg |= A_IOCFG_ENABLE_DIGITAL;
2466                 hcfg |= HCFG_GPOUT0;
2467         }
2468
2469         if (mode == MODE_ANALOG)
2470                 emumix_set_spdif_mode(sc, SPDIF_MODE_PCM);
2471
2472         if (sc->is_emu10k2)
2473                 a_iocfg |= 0x80; /* XXX */
2474
2475         if ((sc->is_ca0102) || (sc->is_ca0108))
2476                 /*
2477                  * Setting A_IOCFG_DISABLE_ANALOG will do opposite things
2478                  * on diffrerent cards.
2479                  * "don't disable analog outs" on Audigy 2 (ca0102/ca0108)
2480                  * "disable analog outs" on Audigy (emu10k2)
2481                  */
2482                 a_iocfg |= A_IOCFG_DISABLE_ANALOG;
2483
2484         if (sc->is_ca0108)
2485                 a_iocfg |= 0x20; /* XXX */
2486
2487         /* Mute analog center & subwoofer before mode change */
2488         if (mode == MODE_DIGITAL)
2489                 emumix_set_gpr(sc, sc->mute_gpr[ANALOGMUTE], 1);
2490
2491         emu_wr(sc, HCFG, hcfg, 4);
2492
2493         if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2494                 tmp = emu_rd(sc, A_IOCFG, 2);
2495                 tmp = a_iocfg;
2496                 emu_wr(sc, A_IOCFG, tmp, 2);
2497         }
2498
2499         /* Unmute if we have changed mode to analog. */
2500
2501         if (mode == MODE_ANALOG)
2502                 emumix_set_gpr(sc, sc->mute_gpr[ANALOGMUTE], 0);
2503
2504         sc->mode = mode;
2505 }
2506
2507 void
2508 emumix_set_spdif_mode(struct emu_sc_info *sc, int mode)
2509 {
2510         uint32_t spcs;
2511
2512         switch (mode) {
2513         case SPDIF_MODE_PCM:
2514                 break;
2515         case SPDIF_MODE_AC3:
2516                 device_printf(sc->dev, "AC3 mode does not work and disabled\n");
2517                 return;
2518         default:
2519                 return;
2520         }
2521
2522         spcs = SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
2523             SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
2524             SPCS_GENERATIONSTATUS | 0x00001200 | 0x00000000 |
2525             SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT;
2526
2527         mode = SPDIF_MODE_PCM;
2528
2529         emu_wrptr(sc, 0, SPCS0, spcs);
2530         emu_wrptr(sc, 0, SPCS1, spcs);
2531         emu_wrptr(sc, 0, SPCS2, spcs);
2532 }
2533
2534 #define L2L_POINTS      10
2535
2536 static int l2l_df[L2L_POINTS] = {
2537         0x572C5CA,              /* 100..90 */
2538         0x3211625,              /* 90..80 */
2539         0x1CC1A76,              /* 80..70 */
2540         0x108428F,              /* 70..60 */
2541         0x097C70A,              /* 60..50 */
2542         0x0572C5C,              /* 50..40 */
2543         0x0321162,              /* 40..30 */
2544         0x01CC1A7,              /* 30..20 */
2545         0x0108428,              /* 20..10 */
2546         0x016493D               /* 10..0 */
2547 };
2548
2549 static int l2l_f[L2L_POINTS] = {
2550         0x4984461A,             /* 90 */
2551         0x2A3968A7,             /* 80 */
2552         0x18406003,             /* 70 */
2553         0x0DEDC66D,             /* 60 */
2554         0x07FFFFFF,             /* 50 */
2555         0x04984461,             /* 40 */
2556         0x02A3968A,             /* 30 */
2557         0x01840600,             /* 20 */
2558         0x00DEDC66,             /* 10 */
2559         0x00000000              /* 0 */
2560 };
2561
2562
2563 static int
2564 log2lin(int log_t)
2565 {
2566         int lin_t;
2567         int idx, lin;
2568
2569         if (log_t <= 0) {
2570                 lin_t = 0x00000000;
2571                 return (lin_t);
2572         }
2573
2574         if (log_t >= 100) {
2575                 lin_t = 0x7fffffff;
2576                 return (lin_t);
2577         }
2578
2579         idx = (L2L_POINTS - 1) - log_t / (L2L_POINTS);
2580         lin = log_t % (L2L_POINTS);
2581         lin_t = l2l_df[idx] * lin + l2l_f[idx];
2582         return (lin_t);
2583 }
2584
2585
2586 void
2587 emumix_set_fxvol(struct emu_sc_info *sc, unsigned gpr, int32_t vol)
2588 {
2589
2590         vol = log2lin(vol);
2591         emumix_set_gpr(sc, gpr, vol);
2592 }
2593
2594 void
2595 emumix_set_gpr(struct emu_sc_info *sc, unsigned gpr, int32_t val)
2596 {
2597         if (sc->dbg_level > 1)
2598                 if (gpr == 0) {
2599                         device_printf(sc->dev, "Zero gpr write access\n");
2600 #ifdef KDB
2601                         kdb_backtrace();
2602 #endif
2603                         return;
2604                         }
2605
2606         emu_wrptr(sc, 0, GPR(gpr), val);
2607 }
2608
2609 void
2610 emumix_set_volume(struct emu_sc_info *sc, int mixer_idx, int volume)
2611 {
2612
2613         RANGE(volume, 0, 100);
2614         if (mixer_idx < NUM_MIXERS) {
2615                 sc->mixer_volcache[mixer_idx] = volume;
2616                 emumix_set_fxvol(sc, sc->mixer_gpr[mixer_idx], volume);
2617         }
2618 }
2619
2620 int
2621 emumix_get_volume(struct emu_sc_info *sc, int mixer_idx)
2622 {
2623         if ((mixer_idx < NUM_MIXERS) && (mixer_idx >= 0))
2624                 return (sc->mixer_volcache[mixer_idx]);
2625         return (-1);
2626 }
2627
2628 /* Init CardBus part */
2629 static int
2630 emu_cardbus_init(struct emu_sc_info *sc)
2631 {
2632
2633         /*
2634          * XXX May not need this if we have IPR3 handler.
2635          * Is it a real init calls, or IPR3 interrupt acknowledgments?
2636          * Looks much like "(data << 16) | register".
2637          */
2638         emu_wr_cbptr(sc, (0x00d0 << 16) | 0x0000);
2639         emu_wr_cbptr(sc, (0x00d0 << 16) | 0x0001);
2640         emu_wr_cbptr(sc, (0x00d0 << 16) | 0x005f);
2641         emu_wr_cbptr(sc, (0x00d0 << 16) | 0x007f);
2642
2643         emu_wr_cbptr(sc, (0x0090 << 16) | 0x007f);
2644
2645         return (0);
2646 }
2647
2648 /* Probe and attach the card */
2649 static int
2650 emu_init(struct emu_sc_info *sc)
2651 {
2652         uint32_t ch, tmp;
2653         uint32_t spdif_sr;
2654         uint32_t ac97slot;
2655         int def_mode;
2656         int i;
2657
2658         /* disable audio and lock cache */
2659         emu_wr(sc, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE, 4);
2660
2661         /* reset recording buffers */
2662         emu_wrptr(sc, 0, MICBS, ADCBS_BUFSIZE_NONE);
2663         emu_wrptr(sc, 0, MICBA, 0);
2664         emu_wrptr(sc, 0, FXBS, ADCBS_BUFSIZE_NONE);
2665         emu_wrptr(sc, 0, FXBA, 0);
2666         emu_wrptr(sc, 0, ADCBS, ADCBS_BUFSIZE_NONE);
2667         emu_wrptr(sc, 0, ADCBA, 0);
2668
2669         /* disable channel interrupt */
2670         emu_wr(sc, INTE, INTE_INTERVALTIMERENB | INTE_SAMPLERATETRACKER | INTE_PCIERRORENABLE, 4);
2671         emu_wrptr(sc, 0, CLIEL, 0);
2672         emu_wrptr(sc, 0, CLIEH, 0);
2673         emu_wrptr(sc, 0, SOLEL, 0);
2674         emu_wrptr(sc, 0, SOLEH, 0);
2675
2676         /* disable P16V and S/PDIF interrupts */
2677         if ((sc->is_ca0102) || (sc->is_ca0108))
2678                 emu_wr(sc, INTE2, 0, 4);
2679
2680         if (sc->is_ca0102)
2681                 emu_wr(sc, INTE3, 0, 4);
2682
2683         /* init phys inputs and outputs */
2684         ac97slot = 0;
2685         if (sc->has_51)
2686                 ac97slot = AC97SLOT_CNTR | AC97SLOT_LFE;
2687         if (sc->has_71)
2688                 ac97slot = AC97SLOT_CNTR | AC97SLOT_LFE | AC97SLOT_REAR_LEFT | AC97SLOT_REAR_RIGHT;
2689         if (sc->is_emu10k2)
2690                 ac97slot |= 0x40;
2691         emu_wrptr(sc, 0, AC97SLOT, ac97slot);
2692
2693         if (sc->is_emu10k2)     /* XXX for later cards? */
2694                 emu_wrptr(sc, 0, SPBYPASS, 0xf00);      /* What will happen if
2695                                                          * we write 1 here? */
2696
2697         if (bus_dma_tag_create( /* parent */ bus_get_dma_tag(sc->dev),
2698              /* alignment */ 2, /* boundary */ 0,
2699              /* lowaddr */ 1 << 31,     /* can only access 0-2gb */
2700              /* highaddr */ BUS_SPACE_MAXADDR,
2701              /* filter */ NULL, /* filterarg */ NULL,
2702              /* maxsize */ EMU_MAX_BUFSZ, /* nsegments */ 1, /* maxsegz */ 0x3ffff,
2703              /* flags */ 0, /* lockfunc */ busdma_lock_mutex,
2704              /* lockarg */ &Giant, &(sc->mem.dmat)) != 0) {
2705                 device_printf(sc->dev, "unable to create dma tag\n");
2706                 bus_dma_tag_destroy(sc->mem.dmat);
2707                 return (ENOMEM);
2708         }
2709
2710         sc->mem.card = sc;
2711         SLIST_INIT(&sc->mem.blocks);
2712         sc->mem.ptb_pages = emu_malloc(&sc->mem, EMU_MAXPAGES * sizeof(uint32_t), &sc->mem.ptb_pages_addr);
2713         if (sc->mem.ptb_pages == NULL)
2714                 return (ENOMEM);
2715
2716         sc->mem.silent_page = emu_malloc(&sc->mem, EMUPAGESIZE, &sc->mem.silent_page_addr);
2717         if (sc->mem.silent_page == NULL) {
2718                 emu_free(&sc->mem, sc->mem.ptb_pages);
2719                 return (ENOMEM);
2720         }
2721         /* Clear page with silence & setup all pointers to this page */
2722         bzero(sc->mem.silent_page, EMUPAGESIZE);
2723         tmp = (uint32_t) (sc->mem.silent_page_addr) << 1;
2724         for (i = 0; i < EMU_MAXPAGES; i++)
2725                 sc->mem.ptb_pages[i] = tmp | i;
2726
2727         for (ch = 0; ch < NUM_G; ch++) {
2728                 emu_wrptr(sc, ch, MAPA, tmp | MAP_PTI_MASK);
2729                 emu_wrptr(sc, ch, MAPB, tmp | MAP_PTI_MASK);
2730         }
2731         emu_wrptr(sc, 0, PTB, (sc->mem.ptb_pages_addr));
2732         emu_wrptr(sc, 0, TCB, 0);       /* taken from original driver */
2733         emu_wrptr(sc, 0, TCBS, 0);      /* taken from original driver */
2734
2735         /* init envelope engine */
2736         for (ch = 0; ch < NUM_G; ch++) {
2737                 emu_wrptr(sc, ch, DCYSUSV, 0);
2738                 emu_wrptr(sc, ch, IP, 0);
2739                 emu_wrptr(sc, ch, VTFT, 0xffff);
2740                 emu_wrptr(sc, ch, CVCF, 0xffff);
2741                 emu_wrptr(sc, ch, PTRX, 0);
2742                 emu_wrptr(sc, ch, CPF, 0);
2743                 emu_wrptr(sc, ch, CCR, 0);
2744
2745                 emu_wrptr(sc, ch, PSST, 0);
2746                 emu_wrptr(sc, ch, DSL, 0x10);
2747                 emu_wrptr(sc, ch, CCCA, 0);
2748                 emu_wrptr(sc, ch, Z1, 0);
2749                 emu_wrptr(sc, ch, Z2, 0);
2750                 emu_wrptr(sc, ch, FXRT, 0xd01c0000);
2751
2752                 emu_wrptr(sc, ch, ATKHLDM, 0);
2753                 emu_wrptr(sc, ch, DCYSUSM, 0);
2754                 emu_wrptr(sc, ch, IFATN, 0xffff);
2755                 emu_wrptr(sc, ch, PEFE, 0);
2756                 emu_wrptr(sc, ch, FMMOD, 0);
2757                 emu_wrptr(sc, ch, TREMFRQ, 24); /* 1 Hz */
2758                 emu_wrptr(sc, ch, FM2FRQ2, 24); /* 1 Hz */
2759                 emu_wrptr(sc, ch, TEMPENV, 0);
2760
2761                 /*** these are last so OFF prevents writing ***/
2762                 emu_wrptr(sc, ch, LFOVAL2, 0);
2763                 emu_wrptr(sc, ch, LFOVAL1, 0);
2764                 emu_wrptr(sc, ch, ATKHLDV, 0);
2765                 emu_wrptr(sc, ch, ENVVOL, 0);
2766                 emu_wrptr(sc, ch, ENVVAL, 0);
2767
2768                 if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2769                         emu_wrptr(sc, ch, 0x4c, 0x0);
2770                         emu_wrptr(sc, ch, 0x4d, 0x0);
2771                         emu_wrptr(sc, ch, 0x4e, 0x0);
2772                         emu_wrptr(sc, ch, 0x4f, 0x0);
2773                         emu_wrptr(sc, ch, A_FXRT1, 0x3f3f3f3f);
2774                         emu_wrptr(sc, ch, A_FXRT2, 0x3f3f3f3f);
2775                         emu_wrptr(sc, ch, A_SENDAMOUNTS, 0x0);
2776                 }
2777         }
2778
2779         emumix_set_spdif_mode(sc, SPDIF_MODE_PCM);
2780
2781         if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108))
2782                 emu_wrptr(sc, 0, A_SPDIF_SAMPLERATE, A_SPDIF_48000);
2783
2784         /*
2785          * CAxxxx cards needs additional setup:
2786          * 1. Set I2S capture sample rate to 96000
2787          * 2. Disable P16v / P17v proceesing
2788          * 3. Allow EMU10K DSP inputs
2789          */
2790         if ((sc->is_ca0102) || (sc->is_ca0108)) {
2791
2792                 spdif_sr = emu_rdptr(sc, 0, A_SPDIF_SAMPLERATE);
2793                 spdif_sr &= 0xfffff1ff;
2794                 spdif_sr |= A_I2S_CAPTURE_96000;
2795                 emu_wrptr(sc, 0, A_SPDIF_SAMPLERATE, spdif_sr);
2796
2797                 /* Disable P16v processing */
2798                 emu_wr_p16vptr(sc, 0, SRCSel, 0x14);
2799
2800                 /* Setup P16v/P17v sound routing */
2801                 if (sc->is_ca0102)
2802                         emu_wr_p16vptr(sc, 0, SRCMULTI_ENABLE, 0xFF00FF00);
2803                 else {
2804                         emu_wr_p16vptr(sc, 0, P17V_MIXER_I2S_ENABLE, 0xFF000000);
2805                         emu_wr_p16vptr(sc, 0, P17V_MIXER_SPDIF_ENABLE, 0xFF000000);
2806
2807                         tmp = emu_rd(sc, A_IOCFG, 2);
2808                         emu_wr(sc, A_IOCFG, tmp & ~0x8, 2);
2809                 }
2810         }
2811         emu_initefx(sc);
2812
2813         def_mode = MODE_ANALOG;
2814         if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108))
2815                 def_mode = MODE_DIGITAL;
2816         if (((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) && (sc->broken_digital)) {
2817                 device_printf(sc->dev, "Audigy card initialized in analog mode.\n");
2818                 def_mode = MODE_ANALOG;
2819         }
2820         emumix_set_mode(sc, def_mode);
2821
2822         if (bootverbose) {
2823                 tmp = emu_rd(sc, HCFG, 4);
2824                 device_printf(sc->dev, "Card Configuration (   0x%08x )\n", tmp);
2825                 device_printf(sc->dev, "Card Configuration ( & 0xff000000 ) : %s%s%s%s%s%s%s%s\n",
2826                     (tmp & 0x80000000 ? "[Legacy MPIC] " : ""),
2827                     (tmp & 0x40000000 ? "[0x40] " : ""),
2828                     (tmp & 0x20000000 ? "[0x20] " : ""),
2829                     (tmp & 0x10000000 ? "[0x10] " : ""),
2830                     (tmp & 0x08000000 ? "[0x08] " : ""),
2831                     (tmp & 0x04000000 ? "[0x04] " : ""),
2832                     (tmp & 0x02000000 ? "[0x02] " : ""),
2833                     (tmp & 0x01000000 ? "[0x01]" : " "));
2834                 device_printf(sc->dev, "Card Configuration ( & 0x00ff0000 ) : %s%s%s%s%s%s%s%s\n",
2835                     (tmp & 0x00800000 ? "[0x80] " : ""),
2836                     (tmp & 0x00400000 ? "[0x40] " : ""),
2837                     (tmp & 0x00200000 ? "[Legacy INT] " : ""),
2838                     (tmp & 0x00100000 ? "[0x10] " : ""),
2839                     (tmp & 0x00080000 ? "[0x08] " : ""),
2840                     (tmp & 0x00040000 ? "[Codec4] " : ""),
2841                     (tmp & 0x00020000 ? "[Codec2] " : ""),
2842                     (tmp & 0x00010000 ? "[I2S Codec]" : " "));
2843                 device_printf(sc->dev, "Card Configuration ( & 0x0000ff00 ) : %s%s%s%s%s%s%s%s\n",
2844                     (tmp & 0x00008000 ? "[0x80] " : ""),
2845                     (tmp & 0x00004000 ? "[GPINPUT0] " : ""),
2846                     (tmp & 0x00002000 ? "[GPINPUT1] " : ""),
2847                     (tmp & 0x00001000 ? "[GPOUT0] " : ""),
2848                     (tmp & 0x00000800 ? "[GPOUT1] " : ""),
2849                     (tmp & 0x00000400 ? "[GPOUT2] " : ""),
2850                     (tmp & 0x00000200 ? "[Joystick] " : ""),
2851                     (tmp & 0x00000100 ? "[0x01]" : " "));
2852                 device_printf(sc->dev, "Card Configuration ( & 0x000000ff ) : %s%s%s%s%s%s%s%s\n",
2853                     (tmp & 0x00000080 ? "[0x80] " : ""),
2854                     (tmp & 0x00000040 ? "[0x40] " : ""),
2855                     (tmp & 0x00000020 ? "[0x20] " : ""),
2856                     (tmp & 0x00000010 ? "[AUTOMUTE] " : ""),
2857                     (tmp & 0x00000008 ? "[LOCKSOUNDCACHE] " : ""),
2858                     (tmp & 0x00000004 ? "[LOCKTANKCACHE] " : ""),
2859                     (tmp & 0x00000002 ? "[MUTEBUTTONENABLE] " : ""),
2860                     (tmp & 0x00000001 ? "[AUDIOENABLE]" : " "));
2861
2862                 if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2863                         tmp = emu_rd(sc, A_IOCFG, 2);
2864                         device_printf(sc->dev, "Audigy Card Configuration (    0x%04x )\n", tmp);
2865                         device_printf(sc->dev, "Audigy Card Configuration (  & 0xff00 )");
2866                         printf(" : %s%s%s%s%s%s%s%s\n",
2867                             (tmp & 0x8000 ? "[Rear Speakers] " : ""),
2868                             (tmp & 0x4000 ? "[Front Speakers] " : ""),
2869                             (tmp & 0x2000 ? "[0x20] " : ""),
2870                             (tmp & 0x1000 ? "[0x10] " : ""),
2871                             (tmp & 0x0800 ? "[0x08] " : ""),
2872                             (tmp & 0x0400 ? "[0x04] " : ""),
2873                             (tmp & 0x0200 ? "[0x02] " : ""),
2874                             (tmp & 0x0100 ? "[AudigyDrive Phones]" : " "));
2875                         device_printf(sc->dev, "Audigy Card Configuration (  & 0x00ff )");
2876                         printf(" : %s%s%s%s%s%s%s%s\n",
2877                             (tmp & 0x0080 ? "[0x80] " : ""),
2878                             (tmp & 0x0040 ? "[Mute AnalogOut] " : ""),
2879                             (tmp & 0x0020 ? "[0x20] " : ""),
2880                             (tmp & 0x0010 ? "[0x10] " : ""),
2881                             (tmp & 0x0008 ? "[0x08] " : ""),
2882                             (tmp & 0x0004 ? "[GPOUT0] " : ""),
2883                             (tmp & 0x0002 ? "[GPOUT1] " : ""),
2884                             (tmp & 0x0001 ? "[GPOUT2]" : " "));
2885                 }               /* is_emu10k2 or ca* */
2886         }                       /* bootverbose */
2887         return (0);
2888 }
2889
2890 static int
2891 emu_uninit(struct emu_sc_info *sc)
2892 {
2893         uint32_t ch;
2894         struct emu_memblk *blk;
2895
2896         emu_wr(sc, INTE, 0, 4);
2897         for (ch = 0; ch < NUM_G; ch++)
2898                 emu_wrptr(sc, ch, DCYSUSV, 0);
2899         for (ch = 0; ch < NUM_G; ch++) {
2900                 emu_wrptr(sc, ch, VTFT, 0);
2901                 emu_wrptr(sc, ch, CVCF, 0);
2902                 emu_wrptr(sc, ch, PTRX, 0);
2903                 emu_wrptr(sc, ch, CPF, 0);
2904         }
2905
2906         /* disable audio and lock cache */
2907         emu_wr(sc, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE, 4);
2908
2909         emu_wrptr(sc, 0, PTB, 0);
2910         /* reset recording buffers */
2911         emu_wrptr(sc, 0, MICBS, ADCBS_BUFSIZE_NONE);
2912         emu_wrptr(sc, 0, MICBA, 0);
2913         emu_wrptr(sc, 0, FXBS, ADCBS_BUFSIZE_NONE);
2914         emu_wrptr(sc, 0, FXBA, 0);
2915         emu_wrptr(sc, 0, FXWC, 0);
2916         emu_wrptr(sc, 0, ADCBS, ADCBS_BUFSIZE_NONE);
2917         emu_wrptr(sc, 0, ADCBA, 0);
2918         emu_wrptr(sc, 0, TCB, 0);
2919         emu_wrptr(sc, 0, TCBS, 0);
2920
2921         /* disable channel interrupt */
2922         emu_wrptr(sc, 0, CLIEL, 0);
2923         emu_wrptr(sc, 0, CLIEH, 0);
2924         emu_wrptr(sc, 0, SOLEL, 0);
2925         emu_wrptr(sc, 0, SOLEH, 0);
2926
2927         if (!SLIST_EMPTY(&sc->mem.blocks))
2928                 device_printf(sc->dev, "warning: memblock list not empty\n");
2929
2930         SLIST_FOREACH(blk, &sc->mem.blocks, link)
2931                 if (blk != NULL)
2932                 device_printf(sc->dev, "lost %d for %s\n", blk->pte_size, blk->owner);
2933
2934         emu_free(&sc->mem, sc->mem.ptb_pages);
2935         emu_free(&sc->mem, sc->mem.silent_page);
2936
2937         return (0);
2938 }
2939
2940 static int
2941 emu_read_ivar(device_t bus, device_t dev, int ivar_index, uintptr_t * result)
2942 {
2943         struct sndcard_func *func = device_get_ivars(dev);
2944         struct emu_sc_info *sc = device_get_softc(bus);
2945
2946         if (func==NULL)
2947                 return (ENOMEM);
2948         if (sc == NULL)
2949                 return (ENOMEM);
2950
2951         switch (ivar_index) {
2952         case EMU_VAR_FUNC:
2953                 *result = func->func;
2954                 break;
2955         case EMU_VAR_ROUTE:
2956                 if (func->varinfo == NULL)
2957                         return (ENOMEM);
2958                 *result = ((struct emu_pcminfo *)func->varinfo)->route;
2959                 break;
2960         case EMU_VAR_ISEMU10K1:
2961                 *result = sc->is_emu10k1;
2962                 break;
2963         case EMU_VAR_MCH_DISABLED:
2964                 *result = sc->mch_disabled;
2965                 break;
2966         case EMU_VAR_MCH_REC:
2967                 *result = sc->mch_rec;
2968                 break;
2969         default:
2970                 return (ENOENT);
2971         }
2972
2973         return (0);
2974 }
2975
2976 static int
2977 emu_write_ivar(device_t bus __unused, device_t dev __unused,
2978     int ivar_index, uintptr_t value __unused)
2979 {
2980
2981         switch (ivar_index) {
2982                 case 0:
2983                 return (EINVAL);
2984
2985         default:
2986                 return (ENOENT);
2987         }
2988 }
2989
2990 static int
2991 emu_pci_probe(device_t dev)
2992 {
2993         struct sbuf *s;
2994         unsigned int thiscard = 0;
2995         uint16_t vendor;
2996
2997         vendor = pci_read_config(dev, PCIR_DEVVENDOR, /* bytes */ 2);
2998         if (vendor != 0x1102)
2999                 return (ENXIO); /* Not Creative */
3000
3001         thiscard = emu_getcard(dev);
3002         if (thiscard == 0)
3003                 return (ENXIO);
3004
3005         s = sbuf_new(NULL, NULL, 4096, 0);
3006         if (s == NULL)
3007                 return (ENOMEM);
3008         sbuf_printf(s, "Creative %s [%s]", emu_cards[thiscard].desc, emu_cards[thiscard].SBcode);
3009         sbuf_finish(s);
3010
3011         device_set_desc_copy(dev, sbuf_data(s));
3012
3013         sbuf_delete(s);
3014
3015         return (BUS_PROBE_DEFAULT);
3016 }
3017
3018
3019 static int
3020 emu_pci_attach(device_t dev)
3021 {
3022         struct sndcard_func *func;
3023         struct emu_sc_info *sc;
3024         struct emu_pcminfo *pcminfo;
3025 #if 0
3026         struct emu_midiinfo *midiinfo;
3027 #endif
3028         uint32_t data;
3029         int i;
3030         int device_flags;
3031         char status[255];
3032         int error = ENXIO;
3033         int unit;
3034
3035         sc = device_get_softc(dev);
3036         unit = device_get_unit(dev);
3037
3038         if (resource_disabled("emu10kx", unit)) {
3039                 device_printf(dev, "disabled by kernel hints\n");
3040                 return (ENXIO); /* XXX to avoid unit reuse */
3041         }
3042
3043         /* Get configuration */
3044
3045         sc->ctx = device_get_sysctl_ctx(dev);
3046         if (sc->ctx == NULL)
3047                 goto bad;
3048         sc->root = device_get_sysctl_tree(dev);
3049         if (sc->root == NULL)
3050                 goto bad;
3051
3052         if (resource_int_value("emu10kx", unit, "multichannel_disabled", &(sc->mch_disabled)))
3053                 RANGE(sc->mch_disabled, 0, 1);
3054         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3055             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
3056             OID_AUTO, "multichannel_disabled", CTLFLAG_RD, &(sc->mch_disabled), 0, "Multichannel playback setting");
3057
3058         if (resource_int_value("emu10kx", unit, "multichannel_recording", &(sc->mch_rec)))
3059                 RANGE(sc->mch_rec, 0, 1);
3060         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3061             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
3062             OID_AUTO, "multichannel_recording", CTLFLAG_RD,  &(sc->mch_rec), 0, "Multichannel recording setting");
3063
3064         if (resource_int_value("emu10kx", unit, "debug", &(sc->dbg_level)))
3065                 RANGE(sc->mch_rec, 0, 2);
3066         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3067             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
3068             OID_AUTO, "debug", CTLFLAG_RW, &(sc->dbg_level), 0, "Debug level");
3069
3070         /* Fill in the softc. */
3071         mtx_init(&sc->lock, device_get_nameunit(dev), "bridge conf", MTX_DEF);
3072         mtx_init(&sc->rw, device_get_nameunit(dev), "exclusive io", MTX_DEF);
3073         sc->dev = dev;
3074         sc->type = pci_get_devid(dev);
3075         sc->rev = pci_get_revid(dev);
3076         sc->enable_ir = 0;
3077         sc->has_ac97 = 0;
3078         sc->has_51 = 0;
3079         sc->has_71 = 0;
3080         sc->broken_digital = 0;
3081         sc->is_emu10k1 = 0;
3082         sc->is_emu10k2 = 0;
3083         sc->is_ca0102 = 0;
3084         sc->is_ca0108 = 0;
3085         sc->is_cardbus = 0;
3086
3087         device_flags = emu_cards[emu_getcard(dev)].flags;
3088         if (device_flags & HAS_51)
3089                 sc->has_51 = 1;
3090         if (device_flags & HAS_71) {
3091                 sc->has_51 = 1;
3092                 sc->has_71 = 1;
3093         }
3094         if (device_flags & IS_EMU10K1)
3095                 sc->is_emu10k1 = 1;
3096         if (device_flags & IS_EMU10K2)
3097                 sc->is_emu10k2 = 1;
3098         if (device_flags & IS_CA0102)
3099                 sc->is_ca0102 = 1;
3100         if (device_flags & IS_CA0108)
3101                 sc->is_ca0108 = 1;
3102         if ((sc->is_emu10k2) && (sc->rev == 4)) {
3103                 sc->is_emu10k2 = 0;
3104                 sc->is_ca0102 = 1;      /* for unknown Audigy 2 cards */
3105         }
3106         if ((sc->is_ca0102 == 1) || (sc->is_ca0108 == 1))
3107                 if (device_flags & IS_CARDBUS)
3108                         sc->is_cardbus = 1;
3109
3110         if ((sc->is_emu10k1 + sc->is_emu10k2 + sc->is_ca0102 + sc->is_ca0108) != 1) {
3111                 device_printf(sc->dev, "Unable to detect HW chipset\n");
3112                 goto bad;
3113         }
3114         if (device_flags & BROKEN_DIGITAL)
3115                 sc->broken_digital = 1;
3116         if (device_flags & HAS_AC97)
3117                 sc->has_ac97 = 1;
3118
3119         sc->opcode_shift = 0;
3120         if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
3121                 sc->opcode_shift = 24;
3122                 sc->high_operand_shift = 12;
3123
3124         /*      DSP map                         */
3125         /*      sc->fx_base = 0x0               */
3126                 sc->input_base = 0x40;
3127         /*      sc->p16vinput_base = 0x50;      */
3128                 sc->output_base = 0x60;
3129                 sc->efxc_base = 0x80;
3130         /*      sc->output32h_base = 0xa0;      */
3131         /*      sc->output32l_base = 0xb0;      */
3132                 sc->dsp_zero = 0xc0;
3133         /*      0xe0...0x100 are unknown        */
3134         /*      sc->tram_base = 0x200           */
3135         /*      sc->tram_addr_base = 0x300      */
3136                 sc->gpr_base = A_FXGPREGBASE;
3137                 sc->num_gprs = 0x200;
3138                 sc->code_base = A_MICROCODEBASE;
3139                 sc->code_size = 0x800 / 2;      /* 0x600-0xdff,  2048 words,
3140                                                  * 1024 instructions */
3141
3142                 sc->mchannel_fx = 8;
3143                 sc->num_fxbuses = 16;
3144                 sc->num_inputs = 8;
3145                 sc->num_outputs = 16;
3146                 sc->address_mask = A_PTR_ADDRESS_MASK;
3147         }
3148         if (sc->is_emu10k1) {
3149                 sc->has_51 = 0; /* We don't support 5.1 sound on SB Live! 5.1 */
3150                 sc->opcode_shift = 20;
3151                 sc->high_operand_shift = 10;
3152                 sc->code_base = MICROCODEBASE;
3153                 sc->code_size = 0x400 / 2;      /* 0x400-0x7ff,  1024 words,
3154                                                  * 512 instructions */
3155                 sc->gpr_base = FXGPREGBASE;
3156                 sc->num_gprs = 0x100;
3157                 sc->input_base = 0x10;
3158                 sc->output_base = 0x20;
3159                 /*
3160                  * XXX 5.1 Analog outputs are inside efxc address space!
3161                  * They use ouput+0x11/+0x12 (=efxc+1/+2).
3162                  * Don't use this efx registers for recording on SB Live! 5.1!
3163                  */
3164                 sc->efxc_base = 0x30;
3165                 sc->dsp_zero = 0x40;
3166                 sc->mchannel_fx = 0;
3167                 sc->num_fxbuses = 8;
3168                 sc->num_inputs = 8;
3169                 sc->num_outputs = 16;
3170                 sc->address_mask = PTR_ADDRESS_MASK;
3171         }
3172         if (sc->opcode_shift == 0)
3173                 goto bad;
3174
3175         data = pci_read_config(dev, PCIR_COMMAND, 2);
3176         data |= (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN);
3177         pci_write_config(dev, PCIR_COMMAND, data, 2);
3178         data = pci_read_config(dev, PCIR_COMMAND, 2);
3179
3180         pci_enable_busmaster(dev);
3181
3182         i = PCIR_BAR(0);
3183         sc->reg = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &i, RF_ACTIVE);
3184         if (sc->reg == NULL) {
3185                 device_printf(dev, "unable to map register space\n");
3186                 goto bad;
3187         }
3188         sc->st = rman_get_bustag(sc->reg);
3189         sc->sh = rman_get_bushandle(sc->reg);
3190
3191         for (i = 0; i < EMU_MAX_IRQ_CONSUMERS; i++)
3192                 sc->timer[i] = 0;       /* disable it */
3193
3194         i = 0;
3195         sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &i, RF_ACTIVE | RF_SHAREABLE);
3196         if ((sc->irq == NULL) || bus_setup_intr(dev, sc->irq, INTR_MPSAFE | INTR_TYPE_AV, NULL, emu_intr, sc, &sc->ih)) {
3197                 device_printf(dev, "unable to map interrupt\n");
3198                 goto bad;
3199         }
3200         if (emu_rm_init(sc) != 0) {
3201                 device_printf(dev, "unable to create resource manager\n");
3202                 goto bad;
3203         }
3204         if (sc->is_cardbus)
3205                 if (emu_cardbus_init(sc) != 0) {
3206                         device_printf(dev, "unable to initialize CardBus interface\n");
3207                         goto bad;
3208                 }
3209         if (emu_init(sc) != 0) {
3210                 device_printf(dev, "unable to initialize the card\n");
3211                 goto bad;
3212         }
3213         if (emu10kx_dev_init(sc) != 0) {
3214                 device_printf(dev, "unable to create control device\n");
3215                 goto bad;
3216         }
3217         snprintf(status, 255, "rev %d at io 0x%lx irq %ld", sc->rev, rman_get_start(sc->reg), rman_get_start(sc->irq));
3218
3219         /* Voices */
3220         for (i = 0; i < NUM_G; i++) {
3221                 sc->voice[i].vnum = i;
3222                 sc->voice[i].slave = NULL;
3223                 sc->voice[i].busy = 0;
3224                 sc->voice[i].ismaster = 0;
3225                 sc->voice[i].running = 0;
3226                 sc->voice[i].b16 = 0;
3227                 sc->voice[i].stereo = 0;
3228                 sc->voice[i].speed = 0;
3229                 sc->voice[i].start = 0;
3230                 sc->voice[i].end = 0;
3231         }
3232
3233         /* PCM Audio */
3234         for (i = 0; i < RT_COUNT; i++)
3235                 sc->pcm[i] = NULL;
3236
3237         /* FRONT */
3238         func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3239         if (func == NULL) {
3240                 error = ENOMEM;
3241                 goto bad;
3242         }
3243         pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3244         if (pcminfo == NULL) {
3245                 error = ENOMEM;
3246                 goto bad;
3247         }
3248         pcminfo->card = sc;
3249         pcminfo->route = RT_FRONT;
3250
3251         func->func = SCF_PCM;
3252         func->varinfo = pcminfo;
3253         sc->pcm[RT_FRONT] = device_add_child(dev, "pcm", -1);
3254         device_set_ivars(sc->pcm[RT_FRONT], func);
3255
3256         if (!(sc->mch_disabled)) {
3257                 /* REAR */
3258                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3259                 if (func == NULL) {
3260                         error = ENOMEM;
3261                         goto bad;
3262                 }
3263                 pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3264                 if (pcminfo == NULL) {
3265                         error = ENOMEM;
3266                         goto bad;
3267                 }
3268                 pcminfo->card = sc;
3269                 pcminfo->route = RT_REAR;
3270
3271                 func->func = SCF_PCM;
3272                 func->varinfo = pcminfo;
3273                 sc->pcm[RT_REAR] = device_add_child(dev, "pcm", -1);
3274                 device_set_ivars(sc->pcm[RT_REAR], func);
3275                 if (sc->has_51) {
3276                         /* CENTER */
3277                         func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3278                         if (func == NULL) {
3279                                 error = ENOMEM;
3280                                 goto bad;
3281                         }
3282                         pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3283                         if (pcminfo == NULL) {
3284                                 error = ENOMEM;
3285                                 goto bad;
3286                         }
3287                         pcminfo->card = sc;
3288                         pcminfo->route = RT_CENTER;
3289
3290                         func->func = SCF_PCM;
3291                         func->varinfo = pcminfo;
3292                         sc->pcm[RT_CENTER] = device_add_child(dev, "pcm", -1);
3293                         device_set_ivars(sc->pcm[RT_CENTER], func);
3294                         /* SUB */
3295                         func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3296                         if (func == NULL) {
3297                                 error = ENOMEM;
3298                                 goto bad;
3299                         }
3300                         pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3301                         if (pcminfo == NULL) {
3302                                 error = ENOMEM;
3303                                 goto bad;
3304                         }
3305                         pcminfo->card = sc;
3306                         pcminfo->route = RT_SUB;
3307
3308                         func->func = SCF_PCM;
3309                         func->varinfo = pcminfo;
3310                         sc->pcm[RT_SUB] = device_add_child(dev, "pcm", -1);
3311                         device_set_ivars(sc->pcm[RT_SUB], func);
3312                 }
3313                 if (sc->has_71) {
3314                         /* SIDE */
3315                         func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3316                         if (func == NULL) {
3317                                 error = ENOMEM;
3318                                 goto bad;
3319                         }
3320                         pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3321                         if (pcminfo == NULL) {
3322                                 error = ENOMEM;
3323                                 goto bad;
3324                         }
3325                         pcminfo->card = sc;
3326                         pcminfo->route = RT_SIDE;
3327
3328                         func->func = SCF_PCM;
3329                         func->varinfo = pcminfo;
3330                         sc->pcm[RT_SIDE] = device_add_child(dev, "pcm", -1);
3331                         device_set_ivars(sc->pcm[RT_SIDE], func);
3332                 }
3333         } /* mch_disabled */
3334
3335         if (sc->mch_rec) {
3336                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3337                 if (func == NULL) {
3338                         error = ENOMEM;
3339                         goto bad;
3340                 }
3341                 pcminfo = malloc(sizeof(struct emu_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3342                 if (pcminfo == NULL) {
3343                         error = ENOMEM;
3344                         goto bad;
3345                 }
3346                 pcminfo->card = sc;
3347                 pcminfo->route = RT_MCHRECORD;
3348
3349                 func->func = SCF_PCM;
3350                 func->varinfo = pcminfo;
3351                 sc->pcm[RT_MCHRECORD] = device_add_child(dev, "pcm", -1);
3352                 device_set_ivars(sc->pcm[RT_MCHRECORD], func);
3353         } /*mch_rec */
3354
3355         for (i = 0; i < 2; i++)
3356                 sc->midi[i] = NULL;
3357
3358         /* MIDI has some memory mangament and (possible) locking problems */
3359 #if 0
3360         /* Midi Interface 1: Live!, Audigy, Audigy 2 */
3361         if ((sc->is_emu10k1) || (sc->is_emu10k2) || (sc->is_ca0102)) {
3362                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3363                 if (func == NULL) {
3364                         error = ENOMEM;
3365                         goto bad;
3366                 }
3367                 midiinfo = malloc(sizeof(struct emu_midiinfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3368                 if (midiinfo == NULL) {
3369                         error = ENOMEM;
3370                         goto bad;
3371                 }
3372                 midiinfo->card = sc;
3373                 if (sc->is_emu10k2 || (sc->is_ca0102)) {
3374                         midiinfo->port = A_MUDATA1;
3375                         midiinfo->portnr = 1;
3376                 }
3377                 if (sc->is_emu10k1) {
3378                         midiinfo->port = MUDATA;
3379                         midiinfo->portnr = 1;
3380                 }
3381                 func->func = SCF_MIDI;
3382                 func->varinfo = midiinfo;
3383                 sc->midi[0] = device_add_child(dev, "midi", -1);
3384                 device_set_ivars(sc->midi[0], func);
3385         }
3386         /* Midi Interface 2: Audigy, Audigy 2 (on AudigyDrive) */
3387         if (sc->is_emu10k2 || (sc->is_ca0102)) {
3388                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
3389                 if (func == NULL) {
3390                         error = ENOMEM;
3391                         goto bad;
3392                 }
3393                 midiinfo = malloc(sizeof(struct emu_midiinfo), M_DEVBUF, M_NOWAIT | M_ZERO);
3394                 if (midiinfo == NULL) {
3395                         error = ENOMEM;
3396                         goto bad;
3397                 }
3398                 midiinfo->card = sc;
3399
3400                 midiinfo->port = A_MUDATA2;
3401                 midiinfo->portnr = 2;
3402
3403                 func->func = SCF_MIDI;
3404                 func->varinfo = midiinfo;
3405                 sc->midi[1] = device_add_child(dev, "midi", -1);
3406                 device_set_ivars(sc->midi[1], func);
3407         }
3408 #endif
3409         return (bus_generic_attach(dev));
3410
3411 bad:
3412         /* XXX can we just call emu_pci_detach here? */
3413         if (sc->cdev)
3414                 emu10kx_dev_uninit(sc);
3415         if (sc->rm != NULL)
3416                 emu_rm_uninit(sc);
3417         if (sc->reg)
3418                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->reg);
3419         if (sc->ih)
3420                 bus_teardown_intr(dev, sc->irq, sc->ih);
3421         if (sc->irq)
3422                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
3423         mtx_destroy(&sc->rw);
3424         mtx_destroy(&sc->lock);
3425         return (error);
3426 }
3427
3428 static int
3429 emu_pci_detach(device_t dev)
3430 {
3431         struct emu_sc_info *sc;
3432         struct sndcard_func *func;
3433         int devcount, i;
3434         device_t *childlist;
3435         int r = 0;
3436
3437         sc = device_get_softc(dev);
3438
3439         for (i = 0; i < RT_COUNT; i++) {
3440                 if (sc->pcm[i] != NULL) {
3441                         func = device_get_ivars(sc->pcm[i]);
3442                         if (func != NULL && func->func == SCF_PCM) {
3443                                 device_set_ivars(sc->pcm[i], NULL);
3444                                 free(func->varinfo, M_DEVBUF);
3445                                 free(func, M_DEVBUF);
3446                         }
3447                         r = device_delete_child(dev, sc->pcm[i]);
3448                         if (r)  return (r);
3449                 }
3450         }
3451
3452         if (sc->midi[0] != NULL) {
3453                 func = device_get_ivars(sc->midi[0]);
3454                 if (func != NULL && func->func == SCF_MIDI) {
3455                         device_set_ivars(sc->midi[0], NULL);
3456                         free(func->varinfo, M_DEVBUF);
3457                         free(func, M_DEVBUF);
3458                 }
3459                 r = device_delete_child(dev, sc->midi[0]);
3460                 if (r)  return (r);
3461         }
3462
3463         if (sc->midi[1] != NULL) {
3464                 func = device_get_ivars(sc->midi[1]);
3465                 if (func != NULL && func->func == SCF_MIDI) {
3466                         device_set_ivars(sc->midi[1], NULL);
3467                         free(func->varinfo, M_DEVBUF);
3468                         free(func, M_DEVBUF);
3469                 }
3470                 r = device_delete_child(dev, sc->midi[1]);
3471                 if (r)  return (r);
3472         }
3473
3474         if (device_get_children(dev, &childlist, &devcount) == 0)
3475                 for (i = 0; i < devcount - 1; i++) {
3476                         device_printf(dev, "removing stale child %d (unit %d)\n", i, device_get_unit(childlist[i]));
3477                         func = device_get_ivars(childlist[i]);
3478                         if (func != NULL && (func->func == SCF_MIDI || func->func == SCF_PCM)) {
3479                                 device_set_ivars(childlist[i], NULL);
3480                                 free(func->varinfo, M_DEVBUF);
3481                                 free(func, M_DEVBUF);
3482                         }
3483                         device_delete_child(dev, childlist[i]);
3484                 }
3485         if (childlist != NULL)
3486                 free(childlist, M_TEMP);
3487
3488         r = emu10kx_dev_uninit(sc);
3489         if (r)
3490                 return (r);
3491
3492         /* shutdown chip */
3493         emu_uninit(sc);
3494         emu_rm_uninit(sc);
3495
3496         if (sc->mem.dmat)
3497                 bus_dma_tag_destroy(sc->mem.dmat);
3498
3499         if (sc->reg)
3500                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->reg);
3501         bus_teardown_intr(dev, sc->irq, sc->ih);
3502         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
3503         mtx_destroy(&sc->rw);
3504         mtx_destroy(&sc->lock);
3505
3506         return (bus_generic_detach(dev));
3507 }
3508 /* add suspend, resume */
3509 static device_method_t emu_methods[] = {
3510         /* Device interface */
3511         DEVMETHOD(device_probe, emu_pci_probe),
3512         DEVMETHOD(device_attach, emu_pci_attach),
3513         DEVMETHOD(device_detach, emu_pci_detach),
3514         /* Bus methods */
3515         DEVMETHOD(bus_read_ivar, emu_read_ivar),
3516         DEVMETHOD(bus_write_ivar, emu_write_ivar),
3517
3518         {0, 0}
3519 };
3520
3521
3522 static driver_t emu_driver = {
3523         "emu10kx",
3524         emu_methods,
3525         sizeof(struct emu_sc_info),
3526         NULL,
3527         0,
3528         NULL
3529 };
3530
3531 static int
3532 emu_modevent(module_t mod __unused, int cmd, void *data __unused)
3533 {
3534         int err = 0;
3535
3536         switch (cmd) {
3537         case MOD_LOAD:
3538                 break;          /* Success */
3539
3540         case MOD_UNLOAD:
3541         case MOD_SHUTDOWN:
3542
3543                 /* XXX  Should we check state of pcm & midi subdevices here? */
3544
3545                 break;          /* Success */
3546
3547         default:
3548                 err = EINVAL;
3549                 break;
3550         }
3551
3552         return (err);
3553
3554 }
3555
3556 static devclass_t emu_devclass;
3557
3558 DRIVER_MODULE(snd_emu10kx, pci, emu_driver, emu_devclass, emu_modevent, NULL);
3559 DRIVER_MODULE(snd_emu10kx, cardbus, emu_driver, emu_devclass, emu_modevent, NULL);
3560 MODULE_VERSION(snd_emu10kx, SND_EMU10KX_PREFVER);