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