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