1 /* 2 * Emuxki BeOS Driver for Creative Labs SBLive!/Audigy series 3 * 4 * Copyright (c) 2002, Jerome Duval (jerome.duval@free.fr) 5 * 6 */ 7 /* This code is derived from the NetBSD driver for Creative Labs SBLive! series 8 * 9 * Copyright (c) 2001 The NetBSD Foundation, Inc. 10 * All rights reserved. 11 * 12 * This code is derived from software contributed to The NetBSD Foundation 13 * by Yannick Montulet. 14 * 15 * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions 17 * are met: 18 * 1. Redistributions of source code must retain the above copyright 19 * notice, this list of conditions and the following disclaimer. 20 * 2. Redistributions in binary form must reproduce the above copyright 21 * notice, this list of conditions and the following disclaimer in the 22 * documentation and/or other materials provided with the distribution. 23 * 3. All advertising materials mentioning features or use of this software 24 * must display the following acknowledgement: 25 * This product includes software developed by the NetBSD 26 * Foundation, Inc. and its contributors. 27 * 4. Neither the name of The NetBSD Foundation nor the names of its 28 * contributors may be used to endorse or promote products derived 29 * from this software without specific prior written permission. 30 * 31 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 32 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 33 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 34 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 35 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 36 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 37 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 38 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 39 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 40 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGE. 42 */ 43 44 #include <KernelExport.h> 45 #include <PCI.h> 46 #include <string.h> 47 #include <stdio.h> 48 #include <math.h> 49 #include <midi_driver.h> 50 #include "emuxki.h" 51 #include "debug.h" 52 #include "config.h" 53 #include "util.h" 54 #include "io.h" 55 #include <fcntl.h> 56 #include <unistd.h> 57 #include <malloc.h> 58 #include "multi.h" 59 #include "ac97.h" 60 61 status_t init_hardware(void); 62 status_t init_driver(void); 63 void uninit_driver(void); 64 const char ** publish_devices(void); 65 device_hooks * find_device(const char *); 66 67 static char pci_name[] = B_PCI_MODULE_NAME; 68 pci_module_info *pci; 69 static char mpu401_name[] = B_MPU_401_MODULE_NAME; 70 generic_mpu401_module * mpu401; 71 72 73 int32 num_cards; 74 emuxki_dev cards[NUM_CARDS]; 75 int32 num_names; 76 char * names[NUM_CARDS*20+1]; 77 78 status_t emuxki_init(emuxki_dev * card); 79 80 extern device_hooks multi_hooks; 81 extern device_hooks midi_hooks; 82 83 /* Hardware Dump */ 84 85 static void 86 dump_hardware_regs(device_config *config) 87 { 88 LOG(("EMU_IPR = %#08x\n",emuxki_reg_read_32(config, EMU_IPR))); 89 LOG(("EMU_INTE = %#08x\n",emuxki_reg_read_32(config, EMU_INTE))); 90 LOG(("EMU_HCFG = %#08x\n",emuxki_reg_read_32(config, EMU_HCFG))); 91 snooze(100); 92 /*emuxki_reg_write_8(config, EMU_AC97ADDRESS, EMU_AC97ADDRESS_READY); 93 LOG(("EMU_AC97ADDRESS_READY = %#08x\n", emuxki_reg_read_16(config, EMU_AC97DATA)));*/ 94 95 /*emuxki_reg_write_8(config, EMU_AC97ADDRESS, EMU_AC97ADDRESS_ADDRESS); 96 LOG(("EMU_AC97ADDRESS_ADDRESS = %#08x\n", emuxki_reg_read_16(config, EMU_AC97DATA)));*/ 97 98 /*LOG(("EMU_CHAN_CPF_STEREO = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_CPF_STEREO))); 99 LOG(("EMU_CHAN_FXRT = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_FXRT))); 100 LOG(("EMU_CHAN_PTRX = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_PTRX))); 101 LOG(("EMU_CHAN_DSL = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_DSL))); 102 LOG(("EMU_CHAN_PSST = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_PSST))); 103 LOG(("EMU_CHAN_CCCA = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_CCCA))); 104 LOG(("EMU_CHAN_Z1 = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_Z1))); 105 LOG(("EMU_CHAN_Z2 = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_Z2))); 106 LOG(("EMU_CHAN_MAPA = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_MAPA))); 107 LOG(("EMU_CHAN_MAPB = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_MAPB))); 108 LOG(("EMU_CHAN_CVCF_CURRENTFILTER = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_CVCF_CURRENTFILTER))); 109 LOG(("EMU_CHAN_VTFT_FILTERTARGET = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_VTFT_FILTERTARGET))); 110 LOG(("EMU_CHAN_ATKHLDM = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_ATKHLDM))); 111 LOG(("EMU_CHAN_DCYSUSM = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_DCYSUSM))); 112 LOG(("EMU_CHAN_LFOVAL1 = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_LFOVAL1))); 113 LOG(("EMU_CHAN_LFOVAL2 = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_LFOVAL2))); 114 LOG(("EMU_CHAN_FMMOD = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_FMMOD))); 115 LOG(("EMU_CHAN_TREMFRQ = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_TREMFRQ))); 116 LOG(("EMU_CHAN_FM2FRQ2 = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_FM2FRQ2))); 117 LOG(("EMU_CHAN_ENVVAL = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_ENVVAL))); 118 LOG(("EMU_CHAN_ATKHLDV = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_ATKHLDV))); 119 LOG(("EMU_CHAN_ENVVOL = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_ENVVOL))); 120 LOG(("EMU_CHAN_PEFE = %#08x\n",emuxki_chan_read(config, 0, EMU_CHAN_PEFE)));*/ 121 122 } 123 124 static void 125 trace_hardware_regs(device_config *config) 126 { 127 TRACE(("EMU_IPR = %#08x\n",emuxki_reg_read_32(config, EMU_IPR))); 128 TRACE(("EMU_INTE = %#08x\n",emuxki_reg_read_32(config, EMU_INTE))); 129 TRACE(("EMU_HCFG = %#08x\n",emuxki_reg_read_32(config, EMU_HCFG))); 130 } 131 132 /* Misc stuff relative to Emuxki */ 133 134 int emu10k1_recbuf_sizes[] = { 135 0, 384, 448, 512, 640, 768, 896, 1024, 1280, 1536, 1792, 136 2048, 2560, 3072, 3584, 4096, 5120, 6144, 7168, 8192, 10240, 12288, 137 14366, 16384, 20480, 24576, 28672, 32768, 40960, 49152, 57344, 65536 138 }; 139 140 static uint32 141 emuxki_rate_to_pitch(uint32 rate) 142 { 143 static uint32 logMagTable[128] = { 144 0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3, 145 0x13aa2, 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a, 146 0x2655d, 0x28ed5, 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb, 147 0x381b6, 0x3a93d, 0x3d081, 0x3f782, 0x41e42, 0x444c1, 0x46b01, 148 0x49101, 0x4b6c4, 0x4dc49, 0x50191, 0x5269e, 0x54b6f, 0x57006, 149 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7, 0x646ee, 0x66a00, 150 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829, 0x759d4, 151 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e, 152 0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20, 153 0x93d26, 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec, 154 0xa11d8, 0xa2f9d, 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241, 155 0xadf26, 0xafbe7, 0xb1885, 0xb3500, 0xb5157, 0xb6d8c, 0xb899f, 156 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899, 0xc1404, 0xc2f50, 0xc4a7b, 157 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c, 0xceaec, 0xd053f, 158 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3, 0xdba4a, 159 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3, 160 0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a, 161 0xf2c83, 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57, 162 0xfd1a7, 0xfe8df 163 }; 164 static uint8 logSlopeTable[128] = { 165 0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58, 166 0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53, 167 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f, 168 0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b, 169 0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47, 170 0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44, 171 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41, 172 0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e, 173 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c, 174 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39, 175 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37, 176 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35, 177 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34, 178 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32, 179 0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30, 180 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f 181 }; 182 int8 i; 183 184 if (rate == 0) 185 return 0; /* Bail out if no leading "1" */ 186 rate *= 11185; /* Scale 48000 to 0x20002380 */ 187 for (i = 31; i > 0; i--) { 188 if (rate & 0x80000000) { /* Detect leading "1" */ 189 return (((uint32) (i - 15) << 20) + 190 logMagTable[0x7f & (rate >> 24)] + 191 (0x7f & (rate >> 17)) * 192 logSlopeTable[0x7f & (rate >> 24)]); 193 } 194 rate <<= 1; 195 } 196 return 0; /* Should never reach this point */ 197 } 198 199 /* Emuxki Memory management */ 200 201 static emuxki_mem * 202 emuxki_mem_new(emuxki_dev *card, int ptbidx, size_t size) 203 { 204 emuxki_mem *mem; 205 206 if ((mem = malloc(sizeof(*mem))) == NULL) 207 return (NULL); 208 209 mem->ptbidx = ptbidx; 210 mem->area = alloc_mem(&mem->phy_base, &mem->log_base, size, "emuxki buffer"); 211 mem->size = size; 212 if (mem->area < B_OK) { 213 free(mem); 214 return NULL; 215 } 216 return mem; 217 } 218 219 static void 220 emuxki_mem_delete(emuxki_mem *mem) 221 { 222 if(mem->area > B_OK) 223 delete_area(mem->area); 224 free(mem); 225 } 226 227 void * 228 emuxki_pmem_alloc(emuxki_dev *card, size_t size) 229 { 230 int i;//, s; 231 size_t numblocks; 232 emuxki_mem *mem; 233 uint32 j, *ptb, silentpage; 234 235 ptb = card->ptb_log_base; 236 silentpage = ((uint32)card->silentpage_phy_base) << 1; 237 numblocks = size / EMU_PTESIZE; 238 if (size % EMU_PTESIZE) 239 numblocks++; 240 241 PRINT(("emuxki_pmem_alloc : numblocks : %ld\n", numblocks)); 242 243 for (i = 0; i < EMU_MAXPTE; i++) { 244 PRINT(("emuxki_pmem_alloc : %d\n", i)); 245 if ((ptb[i] & EMU_CHAN_MAP_PTE_MASK) == silentpage) { 246 /* We look for a free PTE */ 247 //s = splaudio(); 248 for (j = 0; j < numblocks; j++) 249 if ((ptb[i + j] & EMU_CHAN_MAP_PTE_MASK) 250 != silentpage) 251 break; 252 if (j == numblocks) { 253 PRINT(("emuxki_pmem_alloc : j == numblocks %ld\n", j)); 254 if ((mem = emuxki_mem_new(card, i, size)) == NULL) { 255 //splx(s); 256 return (NULL); 257 } 258 PRINT(("emuxki_pmem_alloc : j == numblocks emuxki_mem_new ok\n")); 259 for (j = 0; j < numblocks; j++) 260 ptb[i + j] = (uint32) ( 261 (( ((uint32)mem->phy_base) + 262 j * EMU_PTESIZE) << 1) 263 | (i + j)); 264 LIST_INSERT_HEAD(&(card->mem), mem, next); 265 PRINT(("emuxki_pmem_alloc : j == numblocks returning\n")); 266 267 //splx(s); 268 return mem->log_base; 269 } else { 270 PRINT(("emuxki_pmem_alloc : j != numblocks %ld\n", j)); 271 i += j; 272 } 273 //splx(s); 274 } 275 } 276 return NULL; 277 } 278 279 void * 280 emuxki_rmem_alloc(emuxki_dev *card, size_t size) 281 { 282 emuxki_mem *mem; 283 //int s; 284 285 mem = emuxki_mem_new(card, EMU_RMEM, size); 286 if (mem == NULL) 287 return (NULL); 288 289 //s = splaudio(); 290 LIST_INSERT_HEAD(&(card->mem), mem, next); 291 //splx(s); 292 293 return mem->log_base; 294 } 295 296 void 297 emuxki_mem_free(emuxki_dev *card, void *ptr) 298 { 299 emuxki_mem *mem; 300 size_t numblocks; 301 uint32 i, *ptb, silentpage; 302 303 ptb = card->ptb_log_base; 304 silentpage = ((uint32)card->silentpage_phy_base) << 1; 305 LOG(("emuxki_mem_free 1\n")); 306 LIST_FOREACH(mem, &card->mem, next) { 307 LOG(("emuxki_mem_free 2\n")); 308 if (mem->log_base != ptr) 309 continue; 310 LOG(("emuxki_mem_free 3\n")); 311 //s = splaudio(); 312 if (mem->ptbidx != EMU_RMEM) { 313 LOG(("mem_size : %i\n", mem->size)); 314 numblocks = mem->size / EMU_PTESIZE; 315 if (mem->size % EMU_PTESIZE) 316 numblocks++; 317 for (i = 0; i < numblocks; i++) 318 ptb[mem->ptbidx + i] = 319 silentpage | (mem->ptbidx + i); 320 } 321 LIST_REMOVE(mem, next); 322 //splx(s); 323 324 LOG(("freeing mem\n")); 325 emuxki_mem_delete(mem); 326 break; 327 } 328 } 329 330 /* Emuxki channel functions */ 331 332 static void 333 emuxki_chanparms_set_defaults(emuxki_channel *chan) 334 { 335 chan->fxsend.a.level = chan->fxsend.b.level = 336 chan->fxsend.c.level = chan->fxsend.d.level = 337 /* for audigy */ 338 chan->fxsend.e.level = chan->fxsend.f.level = 339 chan->fxsend.g.level = chan->fxsend.h.level = 340 IS_AUDIGY(&chan->voice->stream->card->config) ? 0xc0 : 0xff; /* not max */ 341 342 chan->fxsend.a.dest = 0x0; 343 chan->fxsend.b.dest = 0x1; 344 chan->fxsend.c.dest = 0x2; 345 chan->fxsend.d.dest = 0x3; 346 /* for audigy */ 347 chan->fxsend.e.dest = 0x4; 348 chan->fxsend.f.dest = 0x5; 349 chan->fxsend.g.dest = 0x6; 350 chan->fxsend.h.dest = 0x7; 351 352 chan->pitch.intial = 0x0000; /* shouldn't it be 0xE000 ? */ 353 chan->pitch.current = 0x0000; /* should it be 0x0400 */ 354 chan->pitch.target = 0x0000; /* the unity pitch shift ? */ 355 chan->pitch.envelope_amount = 0x00; /* none */ 356 357 chan->initial_attenuation = 0x00; /* no attenuation */ 358 chan->volume.current = 0x0000; /* no volume */ 359 chan->volume.target = 0xffff; 360 chan->volume.envelope.current_state = 0x8000; /* 0 msec delay */ 361 chan->volume.envelope.hold_time = 0x7f; /* 0 msec */ 362 chan->volume.envelope.attack_time = 0x7f; /* 5.5msec */ 363 chan->volume.envelope.sustain_level = 0x7f; /* full */ 364 chan->volume.envelope.decay_time = 0x7f; /* 22msec */ 365 366 chan->filter.initial_cutoff_frequency = 0xff; /* no filter */ 367 chan->filter.current_cutoff_frequency = 0xffff; /* no filtering */ 368 chan->filter.target_cutoff_frequency = 0xffff; /* no filtering */ 369 chan->filter.lowpass_resonance_height = 0x0; 370 chan->filter.interpolation_ROM = 0x1; /* full band */ 371 chan->filter.envelope_amount = 0x7f; /* none */ 372 chan->filter.LFO_modulation_depth = 0x00; /* none */ 373 374 chan->loop.start = 0x000000; 375 chan->loop.end = 0x000010; /* Why ? */ 376 377 chan->modulation.envelope.current_state = 0x8000; 378 chan->modulation.envelope.hold_time = 0x00; /* 127 better ? */ 379 chan->modulation.envelope.attack_time = 0x00; /* infinite */ 380 chan->modulation.envelope.sustain_level = 0x00; /* off */ 381 chan->modulation.envelope.decay_time = 0x7f; /* 22 msec */ 382 chan->modulation.LFO_state = 0x8000; 383 384 chan->vibrato_LFO.state = 0x8000; 385 chan->vibrato_LFO.modulation_depth = 0x00; /* none */ 386 chan->vibrato_LFO.vibrato_depth = 0x00; 387 chan->vibrato_LFO.frequency = 0x00; /* Why set to 24 when 388 * initialized ? */ 389 390 chan->tremolo_depth = 0x00; 391 } 392 393 static emuxki_channel * 394 emuxki_channel_new(emuxki_voice *voice, uint8 num) 395 { 396 emuxki_channel *chan; 397 398 chan = (emuxki_channel *) malloc(sizeof(emuxki_channel)); 399 if (chan == NULL) 400 return NULL; 401 chan->voice = voice; 402 chan->num = num; 403 emuxki_chanparms_set_defaults(chan); 404 chan->voice->stream->card->channel[num] = chan; 405 return chan; 406 } 407 408 static void 409 emuxki_channel_delete(emuxki_channel *chan) 410 { 411 chan->voice->stream->card->channel[chan->num] = NULL; 412 free(chan); 413 } 414 415 static void 416 emuxki_channel_set_fxsend(emuxki_channel *chan, 417 emuxki_chanparms_fxsend *fxsend) 418 { 419 /* Could do a memcpy ...*/ 420 chan->fxsend.a.level = fxsend->a.level; 421 chan->fxsend.b.level = fxsend->b.level; 422 chan->fxsend.c.level = fxsend->c.level; 423 chan->fxsend.d.level = fxsend->d.level; 424 chan->fxsend.a.dest = fxsend->a.dest; 425 chan->fxsend.b.dest = fxsend->b.dest; 426 chan->fxsend.c.dest = fxsend->c.dest; 427 chan->fxsend.d.dest = fxsend->d.dest; 428 429 /* for audigy */ 430 chan->fxsend.e.level = fxsend->e.level; 431 chan->fxsend.f.level = fxsend->f.level; 432 chan->fxsend.g.level = fxsend->g.level; 433 chan->fxsend.h.level = fxsend->h.level; 434 chan->fxsend.e.dest = fxsend->e.dest; 435 chan->fxsend.f.dest = fxsend->f.dest; 436 chan->fxsend.g.dest = fxsend->g.dest; 437 chan->fxsend.h.dest = fxsend->h.dest; 438 } 439 440 static void 441 emuxki_channel_set_srate(emuxki_channel *chan, uint32 srate) 442 { 443 chan->pitch.target = (srate << 8) / 375; 444 chan->pitch.target = (chan->pitch.target >> 1) + 445 (chan->pitch.target & 1); 446 chan->pitch.target &= 0xffff; 447 chan->pitch.current = chan->pitch.target; 448 chan->pitch.intial = 449 (emuxki_rate_to_pitch(srate) >> 8) & EMU_CHAN_IP_MASK; 450 } 451 452 /* voice params must be set before calling this */ 453 static void 454 emuxki_channel_set_bufparms(emuxki_channel *chan, 455 uint32 start, uint32 end) 456 { 457 chan->loop.start = start & EMU_CHAN_PSST_LOOPSTARTADDR_MASK; 458 chan->loop.end = end & EMU_CHAN_DSL_LOOPENDADDR_MASK; 459 } 460 461 static void 462 emuxki_channel_commit_fx(emuxki_channel *chan) 463 { 464 emuxki_dev *card = chan->voice->stream->card; 465 uint8 chano = chan->num; 466 467 if(IS_AUDIGY(&card->config)) { 468 emuxki_chan_write(&card->config, chano, EMU_A_CHAN_FXRT1, 469 (chan->fxsend.d.dest << 24) | 470 (chan->fxsend.c.dest << 16) | 471 (chan->fxsend.b.dest << 8) | 472 (chan->fxsend.a.dest)); 473 emuxki_chan_write(&card->config, chano, EMU_A_CHAN_FXRT2, 474 (chan->fxsend.h.dest << 24) | 475 (chan->fxsend.g.dest << 16) | 476 (chan->fxsend.f.dest << 8) | 477 (chan->fxsend.e.dest)); 478 emuxki_chan_write(&card->config, chano, EMU_A_CHAN_SENDAMOUNTS, 479 (chan->fxsend.e.level << 24) | 480 (chan->fxsend.f.level << 16) | 481 (chan->fxsend.g.level << 8) | 482 (chan->fxsend.h.level)); 483 } else { 484 emuxki_chan_write(&card->config, chano, EMU_CHAN_FXRT, 485 (chan->fxsend.d.dest << 28) | 486 (chan->fxsend.c.dest << 24) | 487 (chan->fxsend.b.dest << 20) | 488 (chan->fxsend.a.dest << 16)); 489 } 490 491 emuxki_chan_write(&card->config, chano, 0x10000000 | EMU_CHAN_PTRX, 492 (chan->fxsend.a.level << 8) | chan->fxsend.b.level); 493 emuxki_chan_write(&card->config, chano, EMU_CHAN_DSL, 494 (chan->fxsend.d.level << 24) | chan->loop.end); 495 emuxki_chan_write(&card->config, chano, EMU_CHAN_PSST, 496 (chan->fxsend.c.level << 24) | chan->loop.start); 497 } 498 499 static void 500 emuxki_channel_commit_parms(emuxki_channel *chan) 501 { 502 emuxki_voice *voice = chan->voice; 503 emuxki_dev *card = chan->voice->stream->card; 504 uint32 start, mapval; 505 uint8 chano = chan->num; 506 //int s; 507 508 start = chan->loop.start + 509 (voice->stereo ? 28 : 30) * (voice->b16 + 1); 510 mapval = ((uint32)card->silentpage_phy_base) << 1 | EMU_CHAN_MAP_PTI_MASK; 511 512 //s = splaudio(); 513 emuxki_chan_write(&card->config, chano, EMU_CHAN_CPF_STEREO, voice->stereo); 514 515 emuxki_channel_commit_fx(chan); 516 517 emuxki_chan_write(&card->config, chano, EMU_CHAN_CCCA, 518 (chan->filter.lowpass_resonance_height << 28) | 519 (chan->filter.interpolation_ROM << 25) | 520 (voice->b16 ? 0 : EMU_CHAN_CCCA_8BITSELECT) | start); 521 emuxki_chan_write(&card->config, chano, EMU_CHAN_Z1, 0); 522 emuxki_chan_write(&card->config, chano, EMU_CHAN_Z2, 0); 523 emuxki_chan_write(&card->config, chano, EMU_CHAN_MAPA, mapval); 524 emuxki_chan_write(&card->config, chano, EMU_CHAN_MAPB, mapval); 525 emuxki_chan_write(&card->config, chano, EMU_CHAN_CVCF_CURRFILTER, 526 chan->filter.current_cutoff_frequency); 527 emuxki_chan_write(&card->config, chano, EMU_CHAN_VTFT_FILTERTARGET, 528 chan->filter.target_cutoff_frequency); 529 emuxki_chan_write(&card->config, chano, EMU_CHAN_ATKHLDM, 530 (chan->modulation.envelope.hold_time << 8) | 531 chan->modulation.envelope.attack_time); 532 emuxki_chan_write(&card->config, chano, EMU_CHAN_DCYSUSM, 533 (chan->modulation.envelope.sustain_level << 8) | 534 chan->modulation.envelope.decay_time); 535 emuxki_chan_write(&card->config, chano, EMU_CHAN_LFOVAL1, 536 chan->modulation.LFO_state); 537 emuxki_chan_write(&card->config, chano, EMU_CHAN_LFOVAL2, 538 chan->vibrato_LFO.state); 539 emuxki_chan_write(&card->config, chano, EMU_CHAN_FMMOD, 540 (chan->vibrato_LFO.modulation_depth << 8) | 541 chan->filter.LFO_modulation_depth); 542 emuxki_chan_write(&card->config, chano, EMU_CHAN_TREMFRQ, 543 (chan->tremolo_depth << 8)); 544 emuxki_chan_write(&card->config, chano, EMU_CHAN_FM2FRQ2, 545 (chan->vibrato_LFO.vibrato_depth << 8) | 546 chan->vibrato_LFO.frequency); 547 emuxki_chan_write(&card->config, chano, EMU_CHAN_ENVVAL, 548 chan->modulation.envelope.current_state); 549 emuxki_chan_write(&card->config, chano, EMU_CHAN_ATKHLDV, 550 (chan->volume.envelope.hold_time << 8) | 551 chan->volume.envelope.attack_time); 552 emuxki_chan_write(&card->config, chano, EMU_CHAN_ENVVOL, 553 chan->volume.envelope.current_state); 554 emuxki_chan_write(&card->config, chano, EMU_CHAN_PEFE, 555 (chan->pitch.envelope_amount << 8) | 556 chan->filter.envelope_amount); 557 //splx(s); 558 } 559 560 static void 561 emuxki_channel_start(emuxki_channel *chan) 562 { 563 emuxki_voice *voice = chan->voice; 564 emuxki_dev *card = chan->voice->stream->card; 565 uint8 cache_sample, cache_invalid_size, chano = chan->num; 566 uint32 sample; 567 //int s; 568 569 cache_sample = voice->stereo ? 4 : 2; 570 sample = voice->b16 ? 0x00000000 : 0x80808080; 571 cache_invalid_size = (voice->stereo ? 28 : 30) * (voice->b16 + 1); 572 573 //s = splaudio(); 574 while (cache_sample--) 575 emuxki_chan_write(&card->config, chano, 576 EMU_CHAN_CD0 + cache_sample, sample); 577 emuxki_chan_write(&card->config, chano, EMU_CHAN_CCR_CACHEINVALIDSIZE, 0); 578 emuxki_chan_write(&card->config, chano, EMU_CHAN_CCR_READADDRESS, 64); 579 emuxki_chan_write(&card->config, chano, EMU_CHAN_CCR_CACHEINVALIDSIZE, 580 cache_invalid_size); 581 emuxki_chan_write(&card->config, chano, EMU_CHAN_IFATN, 582 (chan->filter.target_cutoff_frequency << 8) | 583 chan->initial_attenuation); 584 emuxki_chan_write(&card->config, chano, EMU_CHAN_VTFT_VOLUMETARGET, 585 chan->volume.target); 586 emuxki_chan_write(&card->config, chano, EMU_CHAN_CVCF_CURRVOL, 587 chan->volume.current); 588 emuxki_chan_write(&card->config, 0, EMU_MKSUBREG(1, chano, 589 EMU_SOLEL + (chano >> 5)), 590 0); /* Clear stop on loop */ 591 emuxki_chan_write(&card->config, 0, EMU_MKSUBREG(1, chano, 592 EMU_CLIEL + (chano >> 5)), 593 0); /* Clear loop interrupt */ 594 emuxki_chan_write(&card->config, chano, EMU_CHAN_DCYSUSV, 595 (chan->volume.envelope.sustain_level << 8) | 596 chan->volume.envelope.decay_time); 597 emuxki_chan_write(&card->config, chano, EMU_CHAN_PTRX_PITCHTARGET, 598 chan->pitch.target); 599 emuxki_chan_write(&card->config, chano, EMU_CHAN_CPF_PITCH, 600 chan->pitch.current); 601 emuxki_chan_write(&card->config, chano, EMU_CHAN_IP, chan->pitch.intial); 602 603 //splx(s); 604 } 605 606 static void 607 emuxki_channel_stop(emuxki_channel *chan) 608 { 609 emuxki_dev *card = chan->voice->stream->card; 610 //int s; 611 uint8 chano = chan->num; 612 613 //s = splaudio(); 614 615 emuxki_chan_write(&card->config, chano, EMU_CHAN_PTRX_PITCHTARGET, 0); 616 emuxki_chan_write(&card->config, chano, EMU_CHAN_CPF_PITCH, 0); 617 emuxki_chan_write(&card->config, chano, EMU_CHAN_IFATN_ATTENUATION, 0xff); 618 emuxki_chan_write(&card->config, chano, EMU_CHAN_VTFT_VOLUMETARGET, 0); 619 emuxki_chan_write(&card->config, chano, EMU_CHAN_CVCF_CURRVOL, 0); 620 emuxki_chan_write(&card->config, chano, EMU_CHAN_IP, 0); 621 622 //splx(s); 623 } 624 625 /* Emuxki voice functions */ 626 static void 627 emuxki_dump_voice(emuxki_voice *voice) 628 { 629 LOG(("voice->use = %#u\n", voice->use)); 630 LOG(("voice->state = %#u\n", voice->state)); 631 LOG(("voice->stereo = %#u\n", voice->stereo)); 632 LOG(("voice->b16 = %#u\n", voice->b16)); 633 LOG(("voice->sample_rate = %#lu\n", voice->sample_rate)); 634 LOG(("voice->buffer = %#08x\n", voice->buffer)); 635 if(voice->buffer) { 636 LOG(("voice->buffer->ptbidx = %#u\n", voice->buffer->ptbidx)); 637 LOG(("voice->buffer->log_base = %#08x\n", voice->buffer->log_base)); 638 LOG(("voice->buffer->phy_base = %#08x\n", voice->buffer->phy_base)); 639 LOG(("voice->buffer->size = %#08x\n", voice->buffer->size)); 640 LOG(("voice->buffer->area = %#08x\n", voice->buffer->area)); 641 } 642 LOG(("voice->blksize = %#u\n", voice->blksize)); 643 LOG(("voice->trigblk = %#u\n", voice->trigblk)); 644 LOG(("voice->blkmod = %#u\n", voice->blkmod)); 645 LOG(("voice->timerate = %#u\n", voice->timerate)); 646 } 647 648 /* Allocate channels for voice in case of play voice */ 649 static status_t 650 emuxki_voice_channel_create(emuxki_voice *voice) 651 { 652 emuxki_channel **channel = voice->stream->card->channel; 653 uint8 i, stereo = voice->stereo; 654 //int s; 655 656 for (i = 0; i < EMU_NUMCHAN; i += stereo + 1) { 657 if ((stereo && (channel[i + 1] != NULL)) || 658 (channel[i] != NULL)) /* Looking for free channels */ 659 continue; 660 //s = splaudio(); 661 if (stereo) { 662 voice->dataloc.chan[1] = 663 emuxki_channel_new(voice, i + 1); 664 if (voice->dataloc.chan[1] == NULL) { 665 //splx(s); 666 return ENOMEM; 667 } 668 } 669 voice->dataloc.chan[0] = emuxki_channel_new(voice, i); 670 if (voice->dataloc.chan[0] == NULL) { 671 if (stereo) { 672 emuxki_channel_delete(voice->dataloc.chan[1]); 673 voice->dataloc.chan[1] = NULL; 674 } 675 //splx(s); 676 return ENOMEM; 677 } 678 //splx(s); 679 return B_OK; 680 } 681 return EAGAIN; 682 } 683 684 /* When calling this function we assume no one can access the voice */ 685 static void 686 emuxki_voice_channel_destroy(emuxki_voice *voice) 687 { 688 emuxki_channel_delete(voice->dataloc.chan[0]); 689 voice->dataloc.chan[0] = NULL; 690 if (voice->stereo) 691 emuxki_channel_delete(voice->dataloc.chan[1]); 692 voice->dataloc.chan[1] = NULL; 693 } 694 695 static status_t 696 emuxki_voice_dataloc_create(emuxki_voice *voice) 697 { 698 status_t error; 699 700 if (voice->use & EMU_USE_PLAY) { 701 if ((error = emuxki_voice_channel_create(voice))) 702 return (error); 703 } else { 704 705 } 706 return B_OK; 707 } 708 709 static void 710 emuxki_voice_dataloc_destroy(emuxki_voice *voice) 711 { 712 if (voice->use & EMU_USE_PLAY) { 713 if (voice->dataloc.chan[0] != NULL) 714 emuxki_voice_channel_destroy(voice); 715 } else { 716 uint32 buffaddr_reg, buffsize_reg; 717 switch (voice->dataloc.source) { 718 case EMU_RECSRC_MIC: 719 buffaddr_reg = EMU_MICBA; 720 buffsize_reg = EMU_MICBS; 721 break; 722 case EMU_RECSRC_ADC: 723 buffaddr_reg = EMU_ADCBA; 724 buffsize_reg = EMU_ADCBS; 725 break; 726 case EMU_RECSRC_FX: 727 buffaddr_reg = EMU_FXBA; 728 buffsize_reg = EMU_FXBS; 729 break; 730 default: 731 return; 732 } 733 emuxki_chan_write(&voice->stream->card->config, 0, buffaddr_reg, 0); 734 emuxki_chan_write(&voice->stream->card->config, 0, buffsize_reg, EMU_RECBS_BUFSIZE_NONE); 735 } 736 } 737 738 static void 739 emuxki_voice_fxupdate(emuxki_voice *voice) 740 { 741 emuxki_chanparms_fxsend fxsend; 742 743 uint8 maxlevel = 744 IS_AUDIGY(&voice->stream->card->config) ? 0xc0 : 0xff; /* not max */ 745 746 if (voice->use & EMU_USE_PLAY) { 747 fxsend.a.dest = 0x3f; 748 fxsend.b.dest = 0x3f; 749 fxsend.c.dest = 0x3f; 750 fxsend.d.dest = 0x3f; 751 /* for audigy */ 752 fxsend.e.dest = 0x3f; 753 fxsend.f.dest = 0x3f; 754 fxsend.g.dest = 0x3f; 755 fxsend.h.dest = 0x3f; 756 757 fxsend.a.level = fxsend.b.level = fxsend.c.level = fxsend.d.level = 758 fxsend.e.level = fxsend.g.level = fxsend.f.level = fxsend.h.level = 0x00; 759 760 if (voice->stereo) { 761 switch(voice->stream->card->play_mode) { 762 case 2: 763 if(voice->stream->nstereo == 1) { 764 fxsend.a.dest = voice->voicenum * 2; 765 fxsend.a.level = maxlevel; 766 } else if((voice->stream->nstereo == 2) || 767 ((voice->stream->nstereo == 3)&&(voice->voicenum < 2))) { 768 fxsend.a.dest = voice->voicenum * 2; 769 fxsend.a.level = maxlevel; 770 if(voice->voicenum > 1 - 1) 771 fxsend.a.dest-=2; 772 } else if(voice->stream->nstereo == 3 && voice->voicenum > 1) { 773 fxsend.a.dest = 0x0; 774 fxsend.a.level = maxlevel / 2; 775 fxsend.b.dest = 0x1; 776 fxsend.b.level = maxlevel / 2; 777 } else { 778 LOG(("emuxki_voice_set_stereo case 2 badly managed\n")); 779 } 780 break; 781 case 4: 782 if(voice->stream->nstereo == 1) { 783 fxsend.a.dest = voice->voicenum * 2; 784 fxsend.a.level = maxlevel; 785 fxsend.b.dest = voice->voicenum * 2 + 2; 786 fxsend.b.level = maxlevel; 787 } else if((voice->stream->nstereo == 2) || 788 ((voice->stream->nstereo == 3)&&(voice->voicenum < 2))) { 789 fxsend.a.dest = voice->voicenum * 2; 790 fxsend.a.level = maxlevel; 791 } else if(voice->stream->nstereo == 3 && voice->voicenum > 1) { 792 fxsend.a.dest = 0x0; 793 fxsend.a.level = maxlevel / 2; 794 fxsend.b.dest = 0x1; 795 fxsend.b.level = maxlevel / 2; 796 } else { 797 LOG(("emuxki_voice_set_stereo case 4 badly managed\n")); 798 } 799 break; 800 case 6: // only on audigy 801 if(voice->stream->nstereo == 1) { 802 fxsend.a.dest = voice->voicenum * 2; 803 fxsend.a.level = maxlevel; 804 fxsend.b.dest = voice->voicenum * 2 + 2; 805 fxsend.b.level = maxlevel; 806 fxsend.c.dest = 0x4; 807 fxsend.c.level = maxlevel / 2; 808 fxsend.d.dest = 0x5; 809 fxsend.d.level = maxlevel / 2; 810 } else if(voice->stream->nstereo == 2) { 811 fxsend.a.dest = voice->voicenum * 2; 812 fxsend.a.level = maxlevel; 813 if(voice->voicenum < 1) { 814 fxsend.b.dest = 0x4; 815 fxsend.b.level = maxlevel / 2; 816 fxsend.c.dest = 0x5; 817 fxsend.c.level = maxlevel / 2; 818 } 819 } else if(voice->stream->nstereo == 3) { 820 fxsend.a.dest = voice->voicenum * 2; 821 fxsend.a.level = maxlevel; 822 } else { 823 LOG(("emuxki_voice_set_stereo case 6 badly managed\n")); 824 } 825 break; 826 } 827 828 emuxki_channel_set_fxsend(voice->dataloc.chan[0], 829 &fxsend); 830 831 switch(voice->stream->card->play_mode) { 832 case 2: 833 if(voice->stream->nstereo == 1) { 834 fxsend.a.dest = voice->voicenum * 2 + 1; 835 fxsend.a.level = maxlevel; 836 } else if((voice->stream->nstereo == 2) || 837 ((voice->stream->nstereo == 3)&&(voice->voicenum < 2))) { 838 fxsend.a.dest = voice->voicenum * 2 + 1; 839 fxsend.a.level = maxlevel; 840 if(voice->voicenum > 1 - 1) 841 fxsend.a.dest-=2; 842 } else if(voice->stream->nstereo == 3 && voice->voicenum > 1) { 843 fxsend.a.dest = 0x0; 844 fxsend.a.level = maxlevel / 2; 845 fxsend.b.dest = 0x1; 846 fxsend.b.level = maxlevel / 2; 847 } else { 848 LOG(("emuxki_voice_set_stereo case 2 badly managed\n")); 849 } 850 break; 851 case 4: 852 if(voice->stream->nstereo == 1) { 853 fxsend.a.dest = voice->voicenum * 2 + 1; 854 fxsend.a.level = maxlevel; 855 fxsend.b.dest = voice->voicenum * 2 + 3; 856 fxsend.b.level = maxlevel; 857 } else if((voice->stream->nstereo == 2) || 858 ((voice->stream->nstereo == 3)&&(voice->voicenum < 2))) { 859 fxsend.a.dest = voice->voicenum * 2 + 1; 860 fxsend.a.level = maxlevel; 861 } else if(voice->stream->nstereo == 3 && voice->voicenum > 1) { 862 fxsend.a.dest = 0x0; 863 fxsend.a.level = maxlevel / 2; 864 fxsend.b.dest = 0x1; 865 fxsend.b.level = maxlevel / 2; 866 } else { 867 LOG(("emuxki_voice_set_stereo case 4 badly managed\n")); 868 } 869 break; 870 case 6: // only on audigy 871 if(voice->stream->nstereo == 1) { 872 fxsend.a.dest = voice->voicenum * 2 + 1; 873 fxsend.a.level = maxlevel; 874 fxsend.b.dest = voice->voicenum * 2 + 3; 875 fxsend.b.level = maxlevel; 876 fxsend.c.dest = 0x4; 877 fxsend.c.level = maxlevel / 2; 878 fxsend.d.dest = 0x5; 879 fxsend.d.level = maxlevel / 2; 880 } else if(voice->stream->nstereo == 2) { 881 fxsend.a.dest = voice->voicenum * 2 + 1; 882 fxsend.a.level = maxlevel; 883 if(voice->voicenum < 1) { 884 fxsend.b.dest = 0x4; 885 fxsend.b.level = maxlevel / 2; 886 fxsend.c.dest = 0x5; 887 fxsend.c.level = maxlevel / 2; 888 } 889 } else if(voice->stream->nstereo == 3) { 890 fxsend.a.dest = voice->voicenum * 2 + 1; 891 fxsend.a.level = maxlevel; 892 } else { 893 LOG(("emuxki_voice_set_stereo case 6 badly managed\n")); 894 } 895 break; 896 } 897 898 emuxki_channel_set_fxsend(voice->dataloc.chan[1], 899 &fxsend); 900 } else { 901 switch(voice->stream->card->play_mode) { 902 case 2: 903 if(voice->stream->nmono == 1) { 904 fxsend.a.dest = voice->voicenum; 905 fxsend.a.level = maxlevel; 906 fxsend.b.dest = voice->voicenum + 1; 907 fxsend.b.level = maxlevel; 908 } else if(voice->stream->nmono == 2) { 909 fxsend.a.dest = voice->voicenum; 910 fxsend.a.level = maxlevel; 911 } else if((voice->stream->nmono == 4) || 912 ((voice->stream->nmono == 6)&&(voice->voicenum < 4))) { 913 fxsend.a.dest = voice->voicenum; 914 fxsend.a.level = maxlevel; 915 if(voice->voicenum > 2 - 1) 916 fxsend.a.dest-=2; 917 } else if(voice->stream->nmono == 6 && voice->voicenum > 3) { 918 fxsend.a.dest = 0x0; 919 fxsend.a.level = maxlevel / 2; 920 fxsend.b.dest = 0x1; 921 fxsend.b.level = maxlevel / 2; 922 } else { 923 LOG(("emuxki_voice_set_stereo case 2 badly managed\n")); 924 } 925 break; 926 case 4: 927 if(voice->stream->nmono == 1) { 928 fxsend.a.dest = voice->voicenum; 929 fxsend.a.level = maxlevel; 930 fxsend.b.dest = voice->voicenum + 1; 931 fxsend.b.level = maxlevel; 932 fxsend.c.dest = voice->voicenum + 2; 933 fxsend.c.level = maxlevel; 934 fxsend.d.dest = voice->voicenum + 3; 935 fxsend.d.level = maxlevel; 936 } else if(voice->stream->nmono == 2) { 937 fxsend.a.dest = voice->voicenum; 938 fxsend.a.level = maxlevel; 939 fxsend.b.dest = voice->voicenum + 2; 940 fxsend.b.level = maxlevel; 941 } else if((voice->stream->nmono == 4) || 942 ((voice->stream->nmono == 6)&&(voice->voicenum < 4))) { 943 fxsend.a.dest = voice->voicenum; 944 fxsend.a.level = maxlevel; 945 } else if(voice->stream->nmono == 6 && voice->voicenum > 3) { 946 fxsend.a.dest = 0x0; 947 fxsend.a.level = maxlevel / 2; 948 fxsend.b.dest = 0x1; 949 fxsend.b.level = maxlevel / 2; 950 } else { 951 LOG(("emuxki_voice_set_stereo case 4 badly managed\n")); 952 } 953 break; 954 case 6: // only on audigy 955 if(voice->stream->nmono == 1) { 956 fxsend.a.dest = voice->voicenum; 957 fxsend.a.level = maxlevel; 958 fxsend.b.dest = voice->voicenum + 1; 959 fxsend.b.level = maxlevel; 960 fxsend.c.dest = voice->voicenum + 2; 961 fxsend.c.level = maxlevel; 962 fxsend.d.dest = voice->voicenum + 3; 963 fxsend.d.level = maxlevel; 964 fxsend.e.dest = voice->voicenum + 4; 965 fxsend.e.level = maxlevel; 966 fxsend.f.dest = voice->voicenum + 5; 967 fxsend.f.level = maxlevel; 968 } else if(voice->stream->nmono == 2) { 969 fxsend.a.dest = voice->voicenum; 970 fxsend.a.level = maxlevel; 971 fxsend.b.dest = voice->voicenum + 2; 972 fxsend.b.level = maxlevel; 973 fxsend.c.dest = 0x4; 974 fxsend.c.level = maxlevel / 2; 975 fxsend.d.dest = 0x5; 976 fxsend.d.level = maxlevel / 2; 977 } else if(voice->stream->nmono == 4) { 978 fxsend.a.dest = voice->voicenum; 979 fxsend.a.level = maxlevel; 980 if(voice->voicenum < 2) { 981 fxsend.b.dest = 0x4; 982 fxsend.b.level = maxlevel / 2; 983 fxsend.c.dest = 0x5; 984 fxsend.c.level = maxlevel / 2; 985 } 986 } else if(voice->stream->nmono == 6) { 987 fxsend.a.dest = voice->voicenum; 988 fxsend.a.level = maxlevel; 989 } else { 990 LOG(("emuxki_voice_set_stereo case 6 badly managed\n")); 991 } 992 break; 993 } 994 995 emuxki_channel_set_fxsend(voice->dataloc.chan[0], 996 &fxsend); 997 } 998 } 999 } 1000 1001 static status_t 1002 emuxki_voice_set_stereo(emuxki_voice *voice, uint8 stereo) 1003 { 1004 status_t error; 1005 1006 emuxki_voice_dataloc_destroy(voice); 1007 voice->stereo = stereo; 1008 if ((error = emuxki_voice_dataloc_create(voice))) 1009 return error; 1010 emuxki_voice_fxupdate(voice); 1011 return B_OK; 1012 } 1013 1014 static status_t 1015 emuxki_voice_set_srate(emuxki_voice *voice, uint32 srate) 1016 { 1017 voice->sample_rate = srate; 1018 if (voice->use & EMU_USE_PLAY) { 1019 if ((srate < 4000) || (srate > 48000)) 1020 return (EINVAL); 1021 emuxki_channel_set_srate(voice->dataloc.chan[0], srate); 1022 if (voice->stereo) 1023 emuxki_channel_set_srate(voice->dataloc.chan[1], 1024 srate); 1025 } 1026 return B_OK; 1027 } 1028 1029 status_t 1030 emuxki_voice_set_audioparms(emuxki_voice *voice, uint8 stereo, 1031 uint8 b16, uint32 srate) 1032 { 1033 status_t error; 1034 1035 if (voice->stereo == stereo && voice->b16 == b16 && 1036 voice->sample_rate == srate) 1037 return B_OK; 1038 1039 if (voice->stereo != stereo) { 1040 if ((error = emuxki_voice_set_stereo(voice, stereo))) 1041 return error; 1042 } 1043 voice->b16 = b16; 1044 if (voice->sample_rate != srate) 1045 emuxki_voice_set_srate(voice, srate); 1046 return B_OK; 1047 } 1048 1049 status_t 1050 emuxki_voice_set_recparms(emuxki_voice *voice, emuxki_recsrc_t recsrc, 1051 emuxki_recparams *recparams) 1052 { 1053 if(voice->use & EMU_USE_RECORD) { 1054 switch(recsrc) { 1055 case EMU_RECSRC_MIC: 1056 break; 1057 case EMU_RECSRC_ADC: 1058 break; 1059 case EMU_RECSRC_FX: 1060 if(!recparams) 1061 return B_ERROR; 1062 voice->recparams.efx_voices[0] = recparams->efx_voices[0]; 1063 voice->recparams.efx_voices[1] = recparams->efx_voices[1]; 1064 break; 1065 default: 1066 return B_ERROR; 1067 break; 1068 } 1069 voice->dataloc.source = recsrc; 1070 } 1071 return B_OK; 1072 } 1073 1074 /* voice audio parms (see just before) must be set prior to this */ 1075 status_t 1076 emuxki_voice_set_bufparms(emuxki_voice *voice, void *ptr, 1077 uint32 bufsize, uint16 blksize) 1078 { 1079 emuxki_mem *mem; 1080 emuxki_channel **chan; 1081 uint32 start, end; 1082 uint8 sample_size; 1083 status_t error = EFAULT; 1084 1085 LIST_FOREACH(mem, &voice->stream->card->mem, next) { 1086 if (mem->log_base != ptr) 1087 continue; 1088 1089 voice->buffer = mem; 1090 sample_size = (voice->b16 + 1) * (voice->stereo + 1); 1091 voice->trigblk = 0; /* This shouldn't be needed */ 1092 voice->blkmod = bufsize / blksize; 1093 if (bufsize % blksize) /* This should not happen */ 1094 voice->blkmod++; 1095 error = 0; 1096 1097 if (voice->use & EMU_USE_PLAY) { 1098 voice->blksize = blksize / sample_size; 1099 chan = voice->dataloc.chan; 1100 start = (mem->ptbidx << 12) / sample_size; 1101 end = start + bufsize / sample_size; 1102 emuxki_channel_set_bufparms(chan[0], 1103 start, end); 1104 if (voice->stereo) 1105 emuxki_channel_set_bufparms(chan[1], 1106 start, end); 1107 voice->timerate = (uint32) 48000 * 1108 voice->blksize / voice->sample_rate / 2; 1109 if (voice->timerate < 5) 1110 error = EINVAL; 1111 } else { 1112 voice->blksize = blksize; 1113 } 1114 1115 break; 1116 } 1117 1118 return error; 1119 } 1120 1121 status_t 1122 emuxki_voice_commit_parms(emuxki_voice *voice) 1123 { 1124 if (voice->use & EMU_USE_PLAY) { 1125 emuxki_channel_commit_parms(voice->dataloc.chan[0]); 1126 if (voice->stereo) 1127 emuxki_channel_commit_parms(voice->dataloc.chan[1]); 1128 } else { 1129 uint32 buffaddr_reg, buffsize_reg, idx_reg; 1130 switch (voice->dataloc.source) { 1131 case EMU_RECSRC_MIC: 1132 buffaddr_reg = EMU_MICBA; 1133 buffsize_reg = EMU_MICBS; 1134 idx_reg = EMU_MICIDX; 1135 break; 1136 case EMU_RECSRC_ADC: 1137 buffaddr_reg = EMU_ADCBA; 1138 buffsize_reg = EMU_ADCBS; 1139 idx_reg = EMU_ADCIDX; 1140 break; 1141 case EMU_RECSRC_FX: 1142 buffaddr_reg = EMU_FXBA; 1143 buffsize_reg = EMU_FXBS; 1144 idx_reg = EMU_FXIDX; 1145 break; 1146 default: 1147 return B_ERROR; 1148 } 1149 emuxki_chan_write(&voice->stream->card->config, 0, buffaddr_reg, (uint32)voice->buffer->phy_base); 1150 emuxki_chan_write(&voice->stream->card->config, 0, buffsize_reg, EMU_RECBS_BUFSIZE_NONE); 1151 emuxki_chan_write(&voice->stream->card->config, 0, buffsize_reg, EMU_RECBS_BUFSIZE_4096); 1152 1153 LOG(("emuxki_voice_commit_parms idx_reg : %u\n", idx_reg)); 1154 1155 idx_reg = EMU_RECIDX(idx_reg); 1156 while(emuxki_chan_read(&voice->stream->card->config, 0, idx_reg)) 1157 snooze(5); 1158 } 1159 return B_OK; 1160 } 1161 1162 static uint32 1163 emuxki_voice_curaddr(emuxki_voice *voice) 1164 { 1165 if (voice->use & EMU_USE_PLAY) 1166 return (emuxki_chan_read(&voice->stream->card->config, 1167 voice->dataloc.chan[0]->num, 1168 EMU_CHAN_CCCA_CURRADDR) - 1169 voice->dataloc.chan[0]->loop.start); 1170 else { 1171 uint32 idx_reg = 0; 1172 switch (voice->dataloc.source) { 1173 case EMU_RECSRC_MIC: 1174 idx_reg = IS_AUDIGY(&voice->stream->card->config) ? EMU_A_MICIDX : EMU_MICIDX; 1175 break; 1176 case EMU_RECSRC_ADC: 1177 idx_reg = IS_AUDIGY(&voice->stream->card->config) ? EMU_A_ADCIDX : EMU_ADCIDX; 1178 break; 1179 case EMU_RECSRC_FX: 1180 idx_reg = EMU_FXIDX; 1181 break; 1182 default: 1183 TRACE(("emuxki_voice_curaddr : BUG!!\n")); 1184 } 1185 //TRACE(("emuxki_voice_curaddr idx_reg : %u\n", idx_reg)); 1186 //TRACE(("emuxki_voice_curaddr : %lu\n", emuxki_chan_read(&voice->stream->card->config, 0, idx_reg))); 1187 return emuxki_chan_read(&voice->stream->card->config, 1188 0, 1189 idx_reg); 1190 } 1191 } 1192 1193 static void 1194 emuxki_resched_timer(emuxki_dev *card) 1195 { 1196 emuxki_voice *voice; 1197 emuxki_stream *stream; 1198 uint16 timerate = 1024; 1199 uint8 active = 0; 1200 //int s = splaudio(); 1201 1202 LOG(("emuxki_resched_timer begin\n")); 1203 1204 LIST_FOREACH(stream, &card->streams, next) { 1205 LIST_FOREACH(voice, &stream->voices, next) { 1206 if ((voice->use & EMU_USE_PLAY) == 0 || 1207 (voice->state & EMU_STATE_STARTED) == 0) 1208 continue; 1209 active = 1; 1210 if (voice->timerate < timerate) 1211 timerate = voice->timerate; 1212 } 1213 } 1214 if (timerate & ~EMU_TIMER_RATE_MASK) 1215 timerate = 0; 1216 1217 if(card->timerate > timerate) { 1218 LOG(("emuxki_resched_timer written (old %u, new %u)\n", card->timerate, timerate)); 1219 card->timerate = timerate; 1220 emuxki_reg_write_16(&card->config, EMU_TIMER, timerate); 1221 } 1222 if (!active && (card->timerstate & EMU_TIMER_STATE_ENABLED)) { 1223 emuxki_inte_disable(&card->config, EMU_INTE_INTERTIMERENB); 1224 card->timerstate &= ~EMU_TIMER_STATE_ENABLED; 1225 LOG(("emuxki_resched_timer : timer disabled\n")); 1226 } else 1227 if (active && !(card->timerstate & EMU_TIMER_STATE_ENABLED)) { 1228 emuxki_inte_enable(&card->config, EMU_INTE_INTERTIMERENB); 1229 card->timerstate |= EMU_TIMER_STATE_ENABLED; 1230 LOG(("emuxki_resched_timer : timer enabled\n")); 1231 } 1232 LOG(("emuxki_resched_timer state : %x\n", card->timerstate)); 1233 //splx(s); 1234 } 1235 1236 static uint32 1237 emuxki_voice_adc_rate(emuxki_voice *voice) 1238 { 1239 switch(voice->sample_rate) { 1240 case 48000: 1241 return EMU_ADCCR_SAMPLERATE_48; 1242 break; 1243 case 44100: 1244 return EMU_ADCCR_SAMPLERATE_44; 1245 break; 1246 case 32000: 1247 return EMU_ADCCR_SAMPLERATE_32; 1248 break; 1249 case 24000: 1250 return EMU_ADCCR_SAMPLERATE_24; 1251 break; 1252 case 22050: 1253 return EMU_ADCCR_SAMPLERATE_22; 1254 break; 1255 case 16000: 1256 return EMU_ADCCR_SAMPLERATE_16; 1257 break; 1258 case 12000: 1259 if(IS_AUDIGY(&voice->stream->card->config)) 1260 return EMU_A_ADCCR_SAMPLERATE_12; 1261 else 1262 PRINT(("recording sample_rate not supported : %lu\n", voice->sample_rate)); 1263 break; 1264 case 11000: 1265 if(IS_AUDIGY(&voice->stream->card->config)) 1266 return EMU_A_ADCCR_SAMPLERATE_11; 1267 else 1268 return EMU_ADCCR_SAMPLERATE_11; 1269 break; 1270 case 8000: 1271 if(IS_AUDIGY(&voice->stream->card->config)) 1272 return EMU_A_ADCCR_SAMPLERATE_8; 1273 else 1274 return EMU_ADCCR_SAMPLERATE_8; 1275 break; 1276 default: 1277 PRINT(("recording sample_rate not supported : %lu\n", voice->sample_rate)); 1278 } 1279 return 0; 1280 } 1281 1282 void 1283 emuxki_voice_start(emuxki_voice *voice) 1284 { 1285 LOG(("emuxki_voice_start\n")); 1286 1287 if (voice->use & EMU_USE_PLAY) { 1288 voice->trigblk = 1; 1289 emuxki_channel_start(voice->dataloc.chan[0]); 1290 if (voice->stereo) 1291 emuxki_channel_start(voice->dataloc.chan[1]); 1292 } else { 1293 1294 switch (voice->dataloc.source) { 1295 case EMU_RECSRC_MIC: 1296 emuxki_inte_enable(&voice->stream->card->config, EMU_INTE_MICBUFENABLE); 1297 break; 1298 case EMU_RECSRC_ADC: { 1299 uint32 adccr_value = 0; 1300 adccr_value = emuxki_voice_adc_rate(voice); 1301 LOG(("emuxki_voice_start adccr_value : %u\n", adccr_value)); 1302 if(voice->stereo) 1303 adccr_value |= ( (IS_AUDIGY(&voice->stream->card->config) ? EMU_A_ADCCR_LCHANENABLE : EMU_ADCCR_LCHANENABLE ) 1304 | ( IS_AUDIGY(&voice->stream->card->config) ? EMU_A_ADCCR_RCHANENABLE : EMU_ADCCR_RCHANENABLE )); 1305 else 1306 adccr_value |= IS_AUDIGY(&voice->stream->card->config) ? EMU_A_ADCCR_LCHANENABLE : EMU_ADCCR_LCHANENABLE; 1307 1308 LOG(("emuxki_voice_start adccr_value : %u, %u\n", adccr_value, EMU_ADCCR_LCHANENABLE | EMU_ADCCR_RCHANENABLE)); 1309 emuxki_chan_write(&voice->stream->card->config, 0, EMU_ADCCR, adccr_value); 1310 1311 emuxki_inte_enable(&voice->stream->card->config, EMU_INTE_ADCBUFENABLE); 1312 } 1313 break; 1314 case EMU_RECSRC_FX: 1315 if(IS_AUDIGY(&voice->stream->card->config)) { 1316 emuxki_chan_write(&voice->stream->card->config, 0, EMU_A_FXWC1, 1317 voice->recparams.efx_voices[0]); 1318 emuxki_chan_write(&voice->stream->card->config, 0, EMU_A_FXWC2, 1319 voice->recparams.efx_voices[1]); 1320 } else { 1321 emuxki_chan_write(&voice->stream->card->config, 0, EMU_FXWC, 1322 voice->recparams.efx_voices[0]); 1323 } 1324 emuxki_inte_enable(&voice->stream->card->config, EMU_INTE_EFXBUFENABLE); 1325 break; 1326 default: 1327 PRINT(("emuxki_voice_start BUG\n")); 1328 } 1329 } 1330 voice->state |= EMU_STATE_STARTED; 1331 if (voice->use & EMU_USE_PLAY) { 1332 emuxki_resched_timer(voice->stream->card); 1333 } 1334 } 1335 1336 void 1337 emuxki_voice_halt(emuxki_voice *voice) 1338 { 1339 LOG(("emuxki_voice_halt\n")); 1340 1341 if (voice->use & EMU_USE_PLAY) { 1342 emuxki_channel_stop(voice->dataloc.chan[0]); 1343 if (voice->stereo) 1344 emuxki_channel_stop(voice->dataloc.chan[1]); 1345 } else { 1346 1347 switch (voice->dataloc.source) { 1348 case EMU_RECSRC_MIC: 1349 emuxki_inte_disable(&voice->stream->card->config, EMU_INTE_MICBUFENABLE); 1350 break; 1351 case EMU_RECSRC_ADC: 1352 emuxki_chan_write(&voice->stream->card->config, 0, EMU_ADCCR, 0); 1353 emuxki_inte_disable(&voice->stream->card->config, EMU_INTE_ADCBUFENABLE); 1354 break; 1355 case EMU_RECSRC_FX: 1356 if(IS_AUDIGY(&voice->stream->card->config)) { 1357 emuxki_chan_write(&voice->stream->card->config, 0, EMU_A_FXWC1, 0); 1358 emuxki_chan_write(&voice->stream->card->config, 0, EMU_A_FXWC2, 0); 1359 } else 1360 emuxki_chan_write(&voice->stream->card->config, 0, EMU_FXWC, 0); 1361 emuxki_inte_disable(&voice->stream->card->config, EMU_INTE_EFXBUFENABLE); 1362 break; 1363 default: 1364 PRINT(("emuxki_voice_halt BUG\n")); 1365 } 1366 } 1367 voice->state &= ~EMU_STATE_STARTED; 1368 if (voice->use & EMU_USE_PLAY) { 1369 emuxki_resched_timer(voice->stream->card); 1370 } 1371 } 1372 1373 emuxki_voice * 1374 emuxki_voice_new(emuxki_stream *stream, uint8 use, uint8 voicenum) 1375 { 1376 emuxki_voice *voice; 1377 //int s; 1378 1379 LOG(("emuxki_voice_new\n")); 1380 1381 voice = malloc(sizeof(emuxki_voice)); 1382 if (voice == NULL) 1383 return (NULL); 1384 voice->stream = stream; 1385 voice->use = use; 1386 voice->state = !EMU_STATE_STARTED; 1387 voice->stereo = EMU_STEREO_NOTSET; 1388 voice->b16 = 0; 1389 voice->sample_rate = 0; 1390 if (use & EMU_USE_PLAY) 1391 voice->dataloc.chan[0] = voice->dataloc.chan[1] = NULL; 1392 else 1393 voice->dataloc.source = EMU_RECSRC_NOTSET; 1394 voice->buffer = NULL; 1395 voice->blksize = 0; 1396 voice->trigblk = 0; 1397 voice->blkmod = 0; 1398 voice->timerate = 0; 1399 voice->voicenum = voicenum; 1400 return voice; 1401 } 1402 1403 void 1404 emuxki_voice_delete(emuxki_voice *voice) 1405 { 1406 if (voice->state & EMU_STATE_STARTED) 1407 emuxki_voice_halt(voice); 1408 emuxki_voice_dataloc_destroy(voice); 1409 free(voice); 1410 } 1411 1412 /* Emuxki stream functions */ 1413 1414 status_t 1415 emuxki_stream_set_audioparms(emuxki_stream *stream, bool stereo, uint8 channels, 1416 uint8 b16, uint32 sample_rate) 1417 { 1418 status_t error; 1419 emuxki_voice *voice; 1420 uint8 i, nvoices; 1421 char *buffer; 1422 uint8 sample_size, frame_size; 1423 LOG(("emuxki_stream_set_audioparms\n")); 1424 1425 if (stream->stereo == stereo && 1426 ((stream->nmono + 2*stream->nstereo) == channels) && 1427 (stream->b16 == b16) && 1428 (stream->sample_rate == sample_rate)) 1429 return B_OK; 1430 1431 LIST_FOREACH(voice, &stream->voices, next) { 1432 if(voice->buffer) 1433 emuxki_mem_free(stream->card, voice->buffer->log_base); 1434 emuxki_voice_delete(voice); 1435 } 1436 stream->first_voice = NULL; 1437 LIST_INIT(&(stream->voices)); 1438 1439 stream->b16 = b16; 1440 stream->sample_rate = sample_rate; 1441 1442 if(stereo && (channels % 2 == 0)) { 1443 stream->stereo = true; 1444 stream->nstereo = channels / 2; 1445 stream->nmono = 0; 1446 nvoices = stream->nstereo; 1447 } else { 1448 stream->stereo = false; 1449 stream->nstereo = 0; 1450 stream->nmono = channels; 1451 nvoices = stream->nmono; 1452 } 1453 1454 sample_size = stream->b16 + 1; 1455 frame_size = sample_size * (stream->stereo ? 2 : 1); 1456 1457 for(i=0; i<nvoices; i++) { 1458 voice = emuxki_voice_new(stream, stream->use, i); 1459 if(voice) { 1460 if(!stream->first_voice) 1461 stream->first_voice = voice; 1462 LIST_INSERT_HEAD((&stream->voices), voice, next); 1463 if ((error = emuxki_voice_set_audioparms(voice, stream->stereo, stream->b16, stream->sample_rate))) 1464 return error; 1465 1466 if (stream->use & EMU_USE_PLAY) 1467 buffer = emuxki_pmem_alloc(stream->card, stream->bufframes * frame_size * stream->bufcount); 1468 else 1469 buffer = emuxki_rmem_alloc(stream->card, stream->bufframes * frame_size * stream->bufcount); 1470 1471 emuxki_voice_set_bufparms(voice, buffer, 1472 stream->bufframes * frame_size * stream->bufcount, 1473 stream->bufframes * frame_size); 1474 } 1475 } 1476 1477 return B_OK; 1478 } 1479 1480 status_t 1481 emuxki_stream_set_recparms(emuxki_stream *stream, emuxki_recsrc_t recsrc, 1482 emuxki_recparams *recparams) 1483 { 1484 emuxki_voice *voice; 1485 LOG(("emuxki_stream_set_recparms\n")); 1486 1487 if(stream->use & EMU_USE_RECORD) { 1488 switch(recsrc) { 1489 case EMU_RECSRC_MIC: 1490 break; 1491 case EMU_RECSRC_ADC: 1492 break; 1493 case EMU_RECSRC_FX: 1494 if(!recparams) 1495 return B_ERROR; 1496 LIST_FOREACH(voice, &stream->voices, next) { 1497 voice->recparams.efx_voices[0] = recparams->efx_voices[0]; 1498 voice->recparams.efx_voices[1] = recparams->efx_voices[1]; 1499 } 1500 break; 1501 default: 1502 return B_ERROR; 1503 break; 1504 } 1505 LIST_FOREACH(voice, &stream->voices, next) 1506 voice->dataloc.source = recsrc; 1507 } 1508 return B_OK; 1509 } 1510 1511 status_t 1512 emuxki_stream_commit_parms(emuxki_stream *stream) 1513 { 1514 emuxki_voice *voice; 1515 status_t error; 1516 LOG(("emuxki_stream_commit_parms\n")); 1517 1518 LIST_FOREACH(voice, &stream->voices, next) 1519 if ((error = emuxki_voice_commit_parms(voice))) 1520 return error; 1521 1522 return B_OK; 1523 } 1524 1525 status_t 1526 emuxki_stream_get_nth_buffer(emuxki_stream *stream, uint8 chan, uint8 buf, 1527 char** buffer, size_t *stride) 1528 { 1529 emuxki_voice *voice = NULL; 1530 uint8 i, sample_size; 1531 LOG(("emuxki_stream_get_nth_buffer\n")); 1532 1533 sample_size = stream->b16 + 1; 1534 if(buf >= stream->bufcount) 1535 return B_BAD_INDEX; 1536 1537 if(stream->stereo) { 1538 i = stream->nstereo - 1; 1539 if(chan/2 > i) 1540 return B_BAD_INDEX; 1541 LIST_FOREACH(voice, &stream->voices, next) 1542 if(i != chan/2) 1543 i--; 1544 else 1545 break; 1546 if(voice) { 1547 *buffer = (char*)voice->buffer->log_base + (buf * stream->bufframes * sample_size * 2); 1548 if(chan % 2 == 1) 1549 *buffer += sample_size; 1550 *stride = sample_size * 2; 1551 } else 1552 return B_ERROR; 1553 } else { 1554 i = stream->nmono - 1; 1555 if(chan > i) 1556 return B_BAD_INDEX; 1557 LIST_FOREACH(voice, &stream->voices, next) 1558 if(i != chan) 1559 i--; 1560 else 1561 break; 1562 if(voice) { 1563 *buffer = (char*)voice->buffer->log_base + (buf * stream->bufframes * sample_size); 1564 *stride = sample_size; 1565 } else 1566 return B_ERROR; 1567 } 1568 1569 return B_OK; 1570 } 1571 1572 void 1573 emuxki_stream_start(emuxki_stream *stream, void (*inth) (void *), void *inthparam) 1574 { 1575 emuxki_voice *voice; 1576 LOG(("emuxki_stream_start\n")); 1577 1578 stream->inth = inth; 1579 stream->inthparam = inthparam; 1580 1581 LIST_FOREACH(voice, &stream->voices, next) { 1582 emuxki_voice_start(voice); 1583 } 1584 stream->state |= EMU_STATE_STARTED; 1585 } 1586 1587 void 1588 emuxki_stream_halt(emuxki_stream *stream) 1589 { 1590 emuxki_voice *voice; 1591 LOG(("emuxki_stream_halt\n")); 1592 1593 LIST_FOREACH(voice, &stream->voices, next) { 1594 emuxki_voice_halt(voice); 1595 } 1596 stream->state &= ~EMU_STATE_STARTED; 1597 } 1598 1599 emuxki_stream * 1600 emuxki_stream_new(emuxki_dev *card, uint8 use, uint32 bufframes, uint8 bufcount) 1601 { 1602 emuxki_stream *stream; 1603 cpu_status status; 1604 LOG(("emuxki_stream_new\n")); 1605 1606 stream = malloc(sizeof(emuxki_stream)); 1607 if (stream == NULL) 1608 return (NULL); 1609 stream->card = card; 1610 stream->use = use; 1611 stream->state = !EMU_STATE_STARTED; 1612 stream->stereo = EMU_STEREO_NOTSET; 1613 stream->b16 = 0; 1614 stream->sample_rate = 0; 1615 stream->nmono = 0; 1616 stream->nstereo = 0; 1617 stream->bufframes = bufframes; 1618 stream->bufcount = bufcount; 1619 stream->first_voice = NULL; 1620 stream->inth = NULL; 1621 stream->inthparam = NULL; 1622 1623 stream->frames_count = 0; 1624 stream->real_time = 0; 1625 stream->update_needed = false; 1626 1627 /* Init voices list */ 1628 LIST_INIT(&(stream->voices)); 1629 1630 status = lock(); 1631 LIST_INSERT_HEAD((&card->streams), stream, next); 1632 unlock(status); 1633 1634 return stream; 1635 } 1636 1637 void 1638 emuxki_stream_delete(emuxki_stream *stream) 1639 { 1640 emuxki_voice *voice; 1641 cpu_status status; 1642 LOG(("emuxki_stream_delete\n")); 1643 1644 emuxki_stream_halt(stream); 1645 1646 status = lock(); 1647 LIST_REMOVE(stream, next); 1648 unlock(status); 1649 1650 while(!LIST_EMPTY(&stream->voices)) { 1651 voice = LIST_FIRST(&stream->voices); 1652 LIST_REMOVE(voice, next); 1653 if(voice->buffer) 1654 emuxki_mem_free(stream->card, voice->buffer->log_base); 1655 emuxki_voice_delete(voice); 1656 } 1657 1658 free(stream); 1659 } 1660 1661 /* Emuxki gprs */ 1662 // 87 values from 0.0dB to -xdB (-0.75dB each) 1663 static uint32 db_table[] = { 1664 2147483647, 1969835071, 1806882308, 1657409659, 1520301995, 1394536435, 1279174712, 1665 1173356181, 1076291388, 987256190, 905586345, 830672562, 761955951, 698923858, 1666 641106035, 588071138, 539423503, 494800198, 453868315, 416322483, 381882595, 1667 350291714, 321314160, 294733747, 270352173, 247987542, 227473005, 208655513, 1668 191394681, 175561735, 161038555, 147716791, 135497057, 124288190, 114006566, 1669 104575479, 95924570, 87989300, 80710468, 74033770, 67909395, 62291654, 1670 57138635, 52411895, 48076170, 44099114, 40451056, 37104780, 34035322, 1671 31219781, 28637154, 26268172, 24095162, 22101913, 20273552, 18596442, 1672 17058068, 15646956, 14352576, 13165272, 12076188, 11077196, 10160845, 1673 9320299, 8549286, 7842054, 7193328, 6598266, 6052431, 5551749, 1674 5092486, 4671215, 4284793, 3930337, 3605204, 3306967, 3033401, 1675 2782465, 2552289, 2341153, 2147483, 1969835, 1806882, 1657409, 1676 1520301, 1394536, 1279174 1677 }; 1678 1679 void 1680 emuxki_gpr_set(emuxki_dev *card, emuxki_gpr *gpr, int32 type, float *values) 1681 { 1682 uint8 count = gpr->type & EMU_MIX_STEREO ? 2 : 1; 1683 uint8 i; 1684 uint32 index; 1685 1686 LOG(("emuxki_set_gpr\n")); 1687 1688 switch(type) { 1689 case EMU_MIX_MUTE: 1690 gpr->mute = (values[0] == 1.0); 1691 if(gpr->mute) { 1692 for(i=0; i<count; i++) 1693 emuxki_write_gpr(&card->config, gpr->gpr + i, 0); 1694 break; 1695 } 1696 for(i=0; i<count; i++) { 1697 values[i] = gpr->current[i]; 1698 } 1699 case EMU_MIX_GAIN: 1700 for(i=0; i<count; i++) { 1701 if(values[i]>gpr->max_gain || values[i]<gpr->min_gain) 1702 return; 1703 index = (int32)(values[i] / gpr->granularity); 1704 if(index > sizeof(db_table)/sizeof(db_table[0])) 1705 index = sizeof(db_table)/sizeof(db_table[0]); 1706 else if(index < 0) 1707 index = 0; 1708 LOG(("emuxki_set_gpr gpr: %d \n", gpr->gpr + i)); 1709 LOG(("emuxki_set_gpr values[i]: %g \n", values[i])); 1710 LOG(("emuxki_set_gpr index: %u \n", index)); 1711 if(!gpr->mute) 1712 emuxki_write_gpr(&card->config, gpr->gpr + i, db_table[index]); 1713 gpr->current[i] = index * gpr->granularity; 1714 } 1715 break; 1716 } 1717 } 1718 1719 void 1720 emuxki_gpr_get(emuxki_dev *card, emuxki_gpr *gpr, int32 type, float *values) 1721 { 1722 uint8 count = gpr->type & EMU_MIX_STEREO ? 2 : 1; 1723 uint16 i; 1724 1725 LOG(("emuxki_get_gpr\n")); 1726 1727 switch(type) { 1728 case EMU_MIX_GAIN: 1729 for(i=0; i<count; i++) { 1730 values[i] = gpr->current[i]; 1731 } 1732 break; 1733 case EMU_MIX_MUTE: 1734 values[0] = (gpr->mute ? 1.0 : 0.0); 1735 break; 1736 } 1737 } 1738 1739 void 1740 emuxki_gpr_dump(emuxki_dev * card, uint16 count) 1741 { 1742 uint16 pc; 1743 uint32 value; 1744 1745 LOG(("emuxki_dump_gprs\n")); 1746 1747 for(pc = 0; pc < count; pc++) { 1748 value = emuxki_read_gpr(&card->config, pc); 1749 LOG(("dsp_gpr pc=%x, value=%x\n", pc, value)); 1750 } 1751 } 1752 1753 static emuxki_gpr * 1754 emuxki_gpr_new(emuxki_dev *card, const char *name, emuxki_gpr_type type, uint16 *gpr_num, 1755 float default_value, float default_mute, float min_gain, float max_gain, float granularity) 1756 { 1757 emuxki_gpr *gpr; 1758 float values[2]; 1759 1760 LOG(("emuxki_gpr_new\n")); 1761 1762 gpr = &card->gpr[*gpr_num]; 1763 strncpy(gpr->name, name, 32); 1764 gpr->type = type; 1765 gpr->gpr = *gpr_num; 1766 gpr->default_value = default_value; 1767 gpr->min_gain = min_gain; 1768 gpr->max_gain = max_gain; 1769 gpr->granularity = granularity; 1770 gpr->mute = false; 1771 (*gpr_num)++; 1772 if(gpr->type & EMU_MIX_STEREO) 1773 (*gpr_num)++; 1774 1775 if(default_mute == 1.0) { 1776 values[0] = default_mute; 1777 emuxki_gpr_set(card, gpr, EMU_MIX_MUTE, values); 1778 } 1779 1780 values[0] = gpr->default_value; 1781 if(gpr->type & EMU_MIX_STEREO) 1782 values[1] = gpr->default_value; 1783 emuxki_gpr_set(card, gpr, EMU_MIX_GAIN, values); 1784 1785 1786 return gpr; 1787 } 1788 1789 /* Emuxki parameter */ 1790 1791 void 1792 emuxki_parameter_set(emuxki_dev *card, const void* cookie, int32 type, int32 *value) 1793 { 1794 emuxki_stream *stream; 1795 emuxki_voice *voice; 1796 LOG(("emuxki_parameter_set\n")); 1797 1798 switch(type) { 1799 case EMU_DIGITAL_MODE: 1800 card->digital_enabled = *value == 1; 1801 if(IS_AUDIGY(&card->config)) 1802 if(IS_AUDIGY2(&card->config)) { 1803 // this disables analog, not enough 1804 emuxki_reg_write_32(&card->config, EMU_A_IOCFG, 1805 (card->digital_enabled ? 0 : EMU_A_IOCFG_GPOUT0) | 1806 (emuxki_reg_read_32(&card->config, EMU_A_IOCFG) 1807 & ~(EMU_A_IOCFG_GPOUT0 | EMU_A_IOCFG_GPOUT1) ) ); 1808 } else { 1809 // this disables analog, and enables digital 1810 emuxki_reg_write_32(&card->config, EMU_A_IOCFG, 1811 (card->digital_enabled ? EMU_A_IOCFG_GPOUT0 | EMU_A_IOCFG_GPOUT1 : 0) | 1812 (emuxki_reg_read_32(&card->config, EMU_A_IOCFG) 1813 & ~(EMU_A_IOCFG_GPOUT0 | EMU_A_IOCFG_GPOUT1) ) ); 1814 } 1815 else { 1816 // this enables digital, not enough 1817 emuxki_reg_write_32(&card->config, EMU_HCFG, 1818 (card->digital_enabled ? EMU_HCFG_GPOUTPUT0 : 0) | 1819 (emuxki_reg_read_32(&card->config, EMU_HCFG) & ~EMU_HCFG_GPOUTPUT0)); 1820 } 1821 1822 break; 1823 case EMU_AUDIO_MODE: 1824 if(*value!=0 && *value!=1 && *value!=2) { 1825 PRINT(("emuxki_parameter_set error value unexpected\n")); 1826 return; 1827 } 1828 card->play_mode = (*value + 1) * 2; 1829 LIST_FOREACH(stream, &card->streams, next) { 1830 if ((stream->use & EMU_USE_PLAY) == 0 || 1831 (stream->state & EMU_STATE_STARTED) == 0) 1832 continue; 1833 LIST_FOREACH(voice, &stream->voices, next) { 1834 emuxki_voice_fxupdate(voice); 1835 emuxki_channel_commit_fx(voice->dataloc.chan[0]); 1836 if (voice->stereo) 1837 emuxki_channel_commit_fx(voice->dataloc.chan[1]); 1838 } 1839 } 1840 break; 1841 } 1842 } 1843 1844 void 1845 emuxki_parameter_get(emuxki_dev *card, const void* cookie, int32 type, int32 *value) 1846 { 1847 LOG(("emuxki_parameter_get\n")); 1848 1849 switch(type) { 1850 case EMU_DIGITAL_MODE: 1851 *value = card->digital_enabled ? 1 : 0; 1852 break; 1853 case EMU_AUDIO_MODE: 1854 *value = card->play_mode / 2 - 1; 1855 break; 1856 } 1857 } 1858 1859 /* Emuxki interrupt */ 1860 static int32 1861 emuxki_int(void *arg) 1862 { 1863 emuxki_dev *card = arg; 1864 uint32 ipr, curblk; 1865 bool gotone = false; 1866 emuxki_voice *voice; 1867 emuxki_stream *stream; 1868 1869 while ((ipr = emuxki_reg_read_32(&card->config, EMU_IPR))) { 1870 gotone = true; 1871 if (ipr & EMU_IPR_INTERVALTIMER) { 1872 //TRACE(("EMU_IPR_INTERVALTIMER\n")); 1873 LIST_FOREACH(stream, &card->streams, next) { 1874 if ((stream->use & EMU_USE_PLAY) == 0 || 1875 (stream->state & EMU_STATE_STARTED) == 0 || 1876 (stream->inth == NULL)) 1877 continue; 1878 1879 voice = stream->first_voice; 1880 //TRACE(("voice %p\n", voice)); 1881 curblk = emuxki_voice_curaddr(voice) / 1882 voice->blksize; 1883 //TRACE(("EMU_IPR_INTERVALTIMER at trigblk %lu\n", curblk)); 1884 //TRACE(("EMU_IPR_INTERVALTIMER at voice->trigblk %lu\n", voice->trigblk)); 1885 if (curblk == voice->trigblk) { 1886 //TRACE(("EMU_IPR_INTERVALTIMER at trigblk %lu\n", curblk)); 1887 //dump_voice(voice); 1888 //trace_hardware_regs(&card->config); 1889 //TRACE(("voice pointer %p\n", voice)); 1890 1891 if(stream->inth) 1892 stream->inth(stream->inthparam); 1893 1894 voice->trigblk++; 1895 voice->trigblk %= voice->blkmod; 1896 } 1897 } 1898 } 1899 #if MIDI 1900 if (ipr & (/*EMU_IPR_MIDITRANSBUFE | */EMU_IPR_MIDIRECVBUFE)) { 1901 midi_interrupt(card); 1902 } 1903 if (ipr & (EMU_IPR_MIDITRANSBUFE)) { 1904 if(!midi_interrupt(card)) { 1905 emuxki_inte_disable(&card->config, EMU_INTE_MIDITXENABLE); 1906 TRACE(("EMU_INTE_MIDITXENABLE disabled\n")); 1907 } 1908 } 1909 #endif 1910 if (ipr & (EMU_IPR_ADCBUFHALFFULL | EMU_IPR_ADCBUFFULL 1911 | EMU_IPR_MICBUFHALFFULL | EMU_IPR_MICBUFFULL 1912 | EMU_IPR_EFXBUFHALFFULL | EMU_IPR_EFXBUFFULL)) { 1913 //TRACE(("EMU_IPR_ADCBUF\n")); 1914 LIST_FOREACH(stream, &card->streams, next) { 1915 if ((stream->use & EMU_USE_RECORD) == 0 || 1916 (stream->state & EMU_STATE_STARTED) == 0 || 1917 (stream->inth == NULL) || 1918 (stream->first_voice == NULL)) 1919 continue; 1920 voice = stream->first_voice; 1921 curblk = emuxki_voice_curaddr(voice) / 1922 voice->blksize; 1923 //TRACE(("EMU_IPR_ADCBUF at trigblk %lu\n", curblk)); 1924 //TRACE(("EMU_IPR_ADCBUF at voice->trigblk %lu\n", voice->trigblk)); 1925 if (curblk == voice->trigblk) { 1926 //TRACE(("EMU_IPR_ADCBUF at trigblk %lu\n", curblk)); 1927 //dump_voice(voice); 1928 //trace_hardware_regs(&card->config); 1929 1930 if(stream->inth) 1931 stream->inth(stream->inthparam); 1932 1933 voice->trigblk++; 1934 voice->trigblk %= voice->blkmod; 1935 } 1936 } 1937 } 1938 1939 /*if (ipr & (EMU_IPR_CHANNELLOOP)) { 1940 TRACE(("EMU_IPR_CHANNELLOOP pending channel : %u\n", ipr & EMU_IPR_CHNOMASK)); 1941 LIST_FOREACH(stream, &card->streams, next) 1942 LIST_FOREACH(voice, &stream->voices, next) { 1943 if ((voice->use & EMU_USE_PLAY) == 0 || 1944 (voice->state & EMU_STATE_STARTED) == 0) 1945 continue; 1946 TRACE(("EMU_IPR_CHANNELLOOP at trigblk %lu\n", emuxki_voice_curaddr(voice))); 1947 TRACE(("EMU_IPR_CHANNELLOOP read %x\n", emuxki_chan_read(&voice->card->config, 0, EMU_CLIPL))); 1948 emuxki_chan_write(&voice->card->config, 0, EMU_CLIPL, emuxki_chan_read(&voice->card->config, 0, EMU_CLIPL)); 1949 } 1950 }*/ 1951 1952 if (ipr & ~(EMU_IPR_RATETRCHANGE | EMU_IPR_INTERVALTIMER 1953 | EMU_IPR_MIDITRANSBUFE | EMU_IPR_MIDIRECVBUFE 1954 | EMU_IPR_ADCBUFHALFFULL | EMU_IPR_ADCBUFFULL 1955 | EMU_IPR_MICBUFHALFFULL | EMU_IPR_MICBUFFULL 1956 | EMU_IPR_EFXBUFHALFFULL | EMU_IPR_EFXBUFFULL)) 1957 TRACE(("Got interrupt 0x%08x !!!\n", 1958 ipr & ~(EMU_IPR_RATETRCHANGE | 1959 EMU_IPR_INTERVALTIMER))); 1960 1961 emuxki_reg_write_32(&card->config, EMU_IPR, ipr); 1962 } 1963 1964 if(gotone) 1965 return B_HANDLED_INTERRUPT; 1966 1967 TRACE(("Got unhandled interrupt\n")); 1968 return B_UNHANDLED_INTERRUPT; 1969 } 1970 1971 1972 1973 /* Emu10k1 driver functions */ 1974 1975 1976 /* detect presence of our hardware */ 1977 status_t 1978 init_hardware(void) 1979 { 1980 int ix=0; 1981 pci_info info; 1982 status_t err = ENODEV; 1983 1984 LOG_CREATE(); 1985 1986 PRINT(("emuxki: init_hardware()\n")); 1987 1988 if (get_module(pci_name, (module_info **)&pci)) 1989 return ENOSYS; 1990 1991 while ((*pci->get_nth_pci_info)(ix, &info) == B_OK) { 1992 if (info.vendor_id == CREATIVELABS_VENDOR_ID && 1993 (info.device_id == CREATIVELABS_SBLIVE_DEVICE_ID 1994 #if AUDIGY 1995 || info.device_id == CREATIVELABS_AUDIGY_DEVICE_ID 1996 #endif 1997 )) { 1998 err = B_OK; 1999 } 2000 ix++; 2001 } 2002 2003 put_module(pci_name); 2004 2005 return err; 2006 } 2007 2008 static void 2009 make_device_names( 2010 emuxki_dev * card) 2011 { 2012 2013 #if MIDI 2014 sprintf(card->midi.name, "midi/emuxki/%ld", card-cards+1); 2015 names[num_names++] = card->midi.name; 2016 #endif 2017 2018 sprintf(card->name, "audio/multi/emuxki/%ld", card-cards+1); 2019 names[num_names++] = card->name; 2020 2021 names[num_names] = NULL; 2022 } 2023 2024 2025 static status_t 2026 emuxki_setup(emuxki_dev * card) 2027 { 2028 status_t err = B_OK; 2029 unsigned char cmd; 2030 2031 PRINT(("setup_emuxki(%p)\n", card)); 2032 2033 make_device_names(card); 2034 card->config.nabmbar = card->info.u.h0.base_registers[0]; 2035 card->config.irq = card->info.u.h0.interrupt_line; 2036 card->config.type = 0; 2037 if(card->info.device_id == CREATIVELABS_AUDIGY_DEVICE_ID) 2038 card->config.type |= TYPE_AUDIGY; 2039 if(IS_AUDIGY(&card->config) && (card->info.revision == 4 || card->info.revision == 8)) 2040 card->config.type |= TYPE_AUDIGY2; 2041 2042 PRINT(("%s deviceid = %#04x chiprev = %x model = %x enhanced at %lx\n", card->name, card->info.device_id, 2043 card->info.revision, card->info.u.h0.subsystem_id, card->config.nabmbar)); 2044 2045 cmd = (*pci->read_pci_config)(card->info.bus, card->info.device, card->info.function, PCI_command, 2); 2046 PRINT(("PCI command before: %x\n", cmd)); 2047 (*pci->write_pci_config)(card->info.bus, card->info.device, card->info.function, PCI_command, 2, cmd | PCI_command_io); 2048 cmd = (*pci->read_pci_config)(card->info.bus, card->info.device, card->info.function, PCI_command, 2); 2049 PRINT(("PCI command after: %x\n", cmd)); 2050 2051 dump_hardware_regs(&card->config); 2052 2053 emuxki_reg_write_32(&card->config, EMU_HCFG, EMU_HCFG_LOCKSOUNDCACHE | EMU_HCFG_LOCKTANKCACHE_MASK| 2054 EMU_HCFG_MUTEBUTTONENABLE); 2055 2056 dump_hardware_regs(&card->config); 2057 2058 #if MIDI 2059 if ((err = (*mpu401->create_device)(card->config.nabmbar + (IS_AUDIGY(&card->config) ? EMU_A_MUDATA1 : EMU_MUDATA), 2060 &card->midi.driver, 0, midi_interrupt_op, &card->midi)) < B_OK) 2061 return (err); 2062 2063 card->midi.card = card; 2064 #endif 2065 2066 /* reset the codec */ 2067 PRINT(("codec reset\n")); 2068 emuxki_codec_write(&card->config, 0x00, 0x0000); 2069 snooze(50000); // 50 ms 2070 2071 ac97_init(&card->config); 2072 ac97_amp_enable(&card->config, true); 2073 2074 PRINT(("codec vendor id = %#08lx\n",ac97_get_vendor_id(&card->config))); 2075 PRINT(("codec description = %s\n",ac97_get_vendor_id_description(&card->config))); 2076 PRINT(("codec 3d enhancement = %s\n",ac97_get_3d_stereo_enhancement(&card->config))); 2077 2078 if(IS_AUDIGY2(&card->config)) { 2079 emuxki_reg_write_32(&card->config, EMU_A_IOCFG, 2080 EMU_A_IOCFG_GPOUT0 | emuxki_reg_read_32(&card->config, EMU_A_IOCFG)); 2081 } 2082 2083 dump_hardware_regs(&card->config); 2084 2085 /*PRINT(("codec master output = %#04x\n",emuxki_codec_read(&card->config, 0x02))); 2086 PRINT(("codec aux output = %#04x\n",emuxki_codec_read(&card->config, 0x04))); 2087 PRINT(("codec mono output = %#04x\n",emuxki_codec_read(&card->config, 0x06))); 2088 PRINT(("codec pcm output = %#04x\n",emuxki_codec_read(&card->config, 0x18))); 2089 PRINT(("codec line in = %#04x\n",emuxki_codec_read(&card->config, 0x10))); 2090 PRINT(("codec record line in= %#04x\n",emuxki_codec_read(&card->config, 0x1a))); 2091 PRINT(("codec record gain = %#04x\n",emuxki_codec_read(&card->config, 0x1c)));*/ 2092 2093 /*PRINT(("adc index = %#08x\n",emuxki_chan_read(&card->config, EMU_ADCIDX, 0))); 2094 PRINT(("micro index = %#08x\n",emuxki_chan_read(&card->config, EMU_MICIDX, 0))); 2095 PRINT(("fx index = %#08x\n",emuxki_chan_read(&card->config, EMU_FXIDX, 0))); 2096 PRINT(("adc addr = %#08x\n",emuxki_chan_read(&card->config, EMU_ADCBA, 0))); 2097 PRINT(("micro addr = %#08x\n",emuxki_chan_read(&card->config, EMU_MICBA, 0))); 2098 PRINT(("fx addr = %#08x\n",emuxki_chan_read(&card->config, EMU_FXBA, 0))); 2099 PRINT(("adc size = %#08x\n",emuxki_chan_read(&card->config, EMU_ADCBS, 0))); 2100 PRINT(("micro size = %#08x\n",emuxki_chan_read(&card->config, EMU_MICBS, 0))); 2101 PRINT(("fx size = %#08x\n",emuxki_chan_read(&card->config, EMU_FXBS, 0))); 2102 2103 PRINT(("EMU_ADCCR = %#08x\n",emuxki_chan_read(&card->config, EMU_ADCCR, 0))); 2104 PRINT(("EMU_FXWC = %#08x\n",emuxki_chan_read(&card->config, EMU_FXWC, 0))); 2105 PRINT(("EMU_FXWC = %#08x\n",emuxki_reg_read_32(&card->config, EMU_FXWC)));*/ 2106 2107 PRINT(("writing codec registers\n")); 2108 // TODO : to move with AC97 2109 /* enable master output */ 2110 emuxki_codec_write(&card->config, AC97_MASTER_VOLUME, 0x0000); 2111 /* enable aux output */ 2112 emuxki_codec_write(&card->config, AC97_AUX_OUT_VOLUME, 0x0000); 2113 /* enable mono output */ 2114 //emuxki_codec_write(&card->config, AC97_MONO_VOLUME, 0x0004); 2115 /* enable pcm output */ 2116 emuxki_codec_write(&card->config, AC97_PCM_OUT_VOLUME, 0x0808); 2117 /* enable line in */ 2118 //emuxki_codec_write(&card->config, AC97_LINE_IN_VOLUME, 0x8808); 2119 /* set record line in */ 2120 emuxki_codec_write(&card->config, AC97_RECORD_SELECT, 0x0404); 2121 /* set record gain */ 2122 //emuxki_codec_write(&card->config, AC97_RECORD_GAIN, 0x0000); 2123 2124 PRINT(("codec master output = %#04x\n",emuxki_codec_read(&card->config, AC97_MASTER_VOLUME))); 2125 PRINT(("codec aux output = %#04x\n",emuxki_codec_read(&card->config, AC97_AUX_OUT_VOLUME))); 2126 PRINT(("codec mono output = %#04x\n",emuxki_codec_read(&card->config, AC97_MONO_VOLUME))); 2127 PRINT(("codec pcm output = %#04x\n",emuxki_codec_read(&card->config, AC97_PCM_OUT_VOLUME))); 2128 PRINT(("codec line in = %#04x\n",emuxki_codec_read(&card->config, AC97_LINE_IN_VOLUME))); 2129 PRINT(("codec record line in= %#04x\n",emuxki_codec_read(&card->config, AC97_RECORD_SELECT))); 2130 PRINT(("codec record gain = %#04x\n",emuxki_codec_read(&card->config, AC97_RECORD_GAIN))); 2131 2132 if (emuxki_codec_read(&card->config, AC97_EXTENDED_AUDIO_ID) & 0x0080) { 2133 card->config.type |= TYPE_LIVE_5_1; 2134 emuxki_chan_write(&card->config, 0, EMU_AC97SLOT, EMU_AC97SLOT_CENTER | EMU_AC97SLOT_LFE); 2135 emuxki_codec_write(&card->config, AC97_SURROUND_VOLUME, 0x0000); 2136 } 2137 2138 if ((err = emuxki_init(card))) 2139 return (err); 2140 2141 if(IS_AUDIGY(&card->config) || IS_LIVE_5_1(&card->config)) { 2142 card->play_mode = 6; // mode 5.1 2143 } else { 2144 card->play_mode = 4; // mode 4.0 2145 } 2146 2147 emuxki_reg_write_32(&card->config, EMU_INTE, EMU_INTE_SAMPLERATER | EMU_INTE_PCIERRENABLE); 2148 2149 PRINT(("installing interrupt : %lx\n", card->config.irq)); 2150 install_io_interrupt_handler(card->config.irq, emuxki_int, card, 0); 2151 2152 emuxki_inte_enable(&card->config, EMU_INTE_VOLINCRENABLE | EMU_INTE_VOLDECRENABLE 2153 | EMU_INTE_MUTEENABLE | EMU_INTE_FXDSPENABLE); 2154 if(IS_AUDIGY2(&card->config)) { 2155 emuxki_reg_write_32(&card->config, EMU_HCFG, EMU_HCFG_AUDIOENABLE | 2156 EMU_HCFG_AC3ENABLE_CDSPDIF | EMU_HCFG_AC3ENABLE_GPSPDIF| 2157 EMU_HCFG_JOYENABLE | EMU_HCFG_AUTOMUTE); 2158 } else if(IS_AUDIGY(&card->config)) { 2159 emuxki_reg_write_32(&card->config, EMU_HCFG, EMU_HCFG_AUDIOENABLE | 2160 EMU_HCFG_JOYENABLE | EMU_HCFG_AUTOMUTE); 2161 } else { 2162 emuxki_reg_write_32(&card->config, EMU_HCFG, EMU_HCFG_AUDIOENABLE | 2163 EMU_HCFG_LOCKTANKCACHE_MASK | EMU_HCFG_JOYENABLE | EMU_HCFG_AUTOMUTE); 2164 } 2165 2166 PRINT(("init_driver done\n")); 2167 2168 return err; 2169 } 2170 2171 void 2172 emuxki_dump_fx(emuxki_dev * card) 2173 { 2174 uint16 pc = 0; 2175 uint8 op; 2176 uint16 r,a,x,y,zero; 2177 2178 LOG(("emuxki_dump_fx\n")); 2179 2180 zero = IS_AUDIGY(&card->config) ? EMU_A_DSP_CST(0) : EMU_DSP_CST(0); 2181 2182 while (pc < 512) { 2183 emuxki_dsp_getop(&card->config, &pc, &op, &r, &a, &x, &y); 2184 if(op!=EMU_DSP_OP_ACC3 || r!=zero || a!=zero || x!=zero || y!=zero) { 2185 LOG(("dsp_op pc=%u, op=%x, r=%x, a=%x, x=%x, y=%x\n", 2186 pc, op, r, a, x, y)); 2187 } 2188 } 2189 } 2190 2191 static void 2192 emuxki_initfx(emuxki_dev * card) 2193 { 2194 uint16 pc, gpr; 2195 emuxki_gpr *a_front_gpr, *a_rear_gpr, *a_center_sub_gpr = NULL; 2196 emuxki_gpr *p_ac97_in_gpr, *p_cd_in_gpr, *r_ac97_in_gpr, *r_cd_in_gpr, *r_fx_out_gpr; 2197 emuxki_gpr *d_front_gpr, *d_rear_gpr, *d_center_sub_gpr; 2198 2199 /* Set all GPRs to 0 */ 2200 for (pc = 0; pc < 256; pc++) { 2201 emuxki_write_gpr(&card->config, pc, 0); 2202 card->gpr[pc].gpr = -1; 2203 } 2204 2205 for (pc = 0; pc < 160; pc++) { 2206 emuxki_chan_write(&card->config, 0, EMU_TANKMEMDATAREGBASE + pc, 0); 2207 emuxki_chan_write(&card->config, 0, EMU_TANKMEMADDRREGBASE + pc, 0); 2208 } 2209 pc = 0; 2210 gpr = EMU_GPR_FIRST_MIX; // we reserve 16 gprs for processing 2211 #define EMU_DSP_TMPGPR_FRONT_LEFT 0 2212 #define EMU_DSP_TMPGPR_FRONT_RIGHT 1 2213 #define EMU_DSP_TMPGPR_REAR_LEFT 2 2214 #define EMU_DSP_TMPGPR_REAR_RIGHT 3 2215 #define EMU_DSP_TMPGPR_CENTER 4 2216 #define EMU_DSP_TMPGPR_SUB 5 2217 #define EMU_DSP_TMPGPR_DSP_IN_L 6 2218 #define EMU_DSP_TMPGPR_DSP_IN_R 7 2219 2220 a_front_gpr = emuxki_gpr_new(card, "Analog Front", 2221 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_PLAYBACK, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2222 a_rear_gpr = emuxki_gpr_new(card, "Analog Rear", 2223 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_PLAYBACK, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2224 if(IS_AUDIGY(&card->config) || IS_LIVE_5_1(&card->config)) 2225 a_center_sub_gpr = emuxki_gpr_new(card, "Analog Center/Sub", 2226 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_PLAYBACK, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2227 2228 d_front_gpr = emuxki_gpr_new(card, "Digital Front", 2229 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_PLAYBACK, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2230 d_rear_gpr = emuxki_gpr_new(card, "Digital Rear", 2231 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_PLAYBACK, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2232 d_center_sub_gpr = emuxki_gpr_new(card, "Digital Center/Sub", 2233 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_PLAYBACK, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2234 2235 /* playback in gprs */ 2236 p_ac97_in_gpr = emuxki_gpr_new(card, "AC97 Record In", 2237 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_PLAYBACK, &gpr, 0.0, 1.0, -46.5, 0.0, -0.75); 2238 p_cd_in_gpr = emuxki_gpr_new(card, "CD Spdif In", 2239 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_PLAYBACK, &gpr, 0.0, 1.0, -46.5, 0.0, -0.75); 2240 2241 /* record in gprs */ 2242 r_ac97_in_gpr = emuxki_gpr_new(card, "AC97 Record In", 2243 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_RECORD, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2244 r_cd_in_gpr = emuxki_gpr_new(card, "CD Spdif In", 2245 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_RECORD, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2246 r_fx_out_gpr = emuxki_gpr_new(card, "FX 0/1", 2247 EMU_MIX_GAIN|EMU_MIX_STEREO|EMU_MIX_MUTE|EMU_MIX_RECORD, &gpr, 0.0, 0.0, -46.5, 0.0, -0.75); 2248 2249 card->gpr_count = gpr; 2250 2251 if(IS_AUDIGY(&card->config)) { 2252 /* DSP_IN_GPR(l/r) = 0 + AC97In(l/r) * P_AC97_IN_GPR(l/r) */ 2253 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2254 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2255 EMU_A_DSP_CST(0), 2256 EMU_A_DSP_INL(EMU_DSP_IN_AC97), EMU_A_DSP_GPR(p_ac97_in_gpr->gpr)); 2257 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2258 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2259 EMU_A_DSP_CST(0), 2260 EMU_A_DSP_INR(EMU_DSP_IN_AC97), EMU_A_DSP_GPR(p_ac97_in_gpr->gpr + 1)); 2261 2262 /* DSP_IN_GPR(l/r) = DSP_IN_GPR(l/r) + CDIn(l/r) * P_CD_IN_GPR(l/r) */ 2263 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2264 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2265 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2266 EMU_A_DSP_INL(EMU_DSP_IN_CDSPDIF), EMU_A_DSP_GPR(p_cd_in_gpr->gpr)); 2267 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2268 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2269 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2270 EMU_A_DSP_INR(EMU_DSP_IN_CDSPDIF), EMU_A_DSP_GPR(p_cd_in_gpr->gpr + 1)); 2271 2272 /* Front GPR(l/r) = DSP_IN_GPR(l/r) + FX(0/1) * 4 */ 2273 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2274 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_FRONT_LEFT), 2275 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2276 EMU_DSP_FX(0), EMU_A_DSP_CST(4)); 2277 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2278 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_FRONT_RIGHT), 2279 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2280 EMU_DSP_FX(1), EMU_A_DSP_CST(4)); 2281 2282 /* Rear GPR(l/r) = DSP_IN_GPR(l/r) + FX(2/3) * 4 */ 2283 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2284 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_REAR_LEFT), 2285 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2286 EMU_DSP_FX(2), EMU_A_DSP_CST(4)); 2287 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2288 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_REAR_RIGHT), 2289 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2290 EMU_DSP_FX(3), EMU_A_DSP_CST(4)); 2291 2292 /* Center/Sub GPR = 0 + FX(4/5) * 4 */ 2293 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2294 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_CENTER), 2295 EMU_A_DSP_CST(0), 2296 EMU_DSP_FX(4), EMU_A_DSP_CST(4)); 2297 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2298 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_SUB), 2299 EMU_A_DSP_CST(0), 2300 EMU_DSP_FX(5), EMU_A_DSP_CST(4)); 2301 2302 /* Analog Front Output l/r = 0 + Front GPR(l/r) * A_FRONT_GPR(l/r) */ 2303 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2304 EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_FRONT), 2305 EMU_A_DSP_CST(0), 2306 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_FRONT_LEFT), EMU_A_DSP_GPR(a_front_gpr->gpr)); 2307 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2308 EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_FRONT), 2309 EMU_A_DSP_CST(0), 2310 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_FRONT_RIGHT), EMU_A_DSP_GPR(a_front_gpr->gpr+1)); 2311 2312 /* Analog Rear Output l/r = 0 + Rear GPR(l/r) * A_REAR_GPR(l/r) */ 2313 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2314 EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_REAR), 2315 EMU_A_DSP_CST(0), 2316 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_REAR_LEFT), EMU_A_DSP_GPR(a_rear_gpr->gpr)); 2317 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2318 EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_REAR), 2319 EMU_A_DSP_CST(0), 2320 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_REAR_RIGHT), EMU_A_DSP_GPR(a_rear_gpr->gpr+1)); 2321 2322 /* Analog Center/Sub = 0 + Center/Sub GPR(l/r) * A_CENTER_GPR(l/r) */ 2323 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2324 EMU_A_DSP_OUTL(EMU_A_DSP_OUT_A_CENTER), 2325 EMU_A_DSP_CST(0), 2326 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_CENTER), EMU_A_DSP_GPR(a_center_sub_gpr->gpr)); 2327 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2328 EMU_A_DSP_OUTR(EMU_A_DSP_OUT_A_CENTER), 2329 EMU_A_DSP_CST(0), 2330 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_SUB), EMU_A_DSP_GPR(a_center_sub_gpr->gpr+1)); 2331 2332 /* Digital Front Output l/r = 0 + Front GPR(l/r) * D_FRONT_GPR(l/r) */ 2333 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2334 EMU_A_DSP_OUTL(EMU_A_DSP_OUT_D_FRONT), 2335 EMU_A_DSP_CST(0), 2336 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_FRONT_LEFT), EMU_A_DSP_GPR(d_front_gpr->gpr)); 2337 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2338 EMU_A_DSP_OUTR(EMU_A_DSP_OUT_D_FRONT), 2339 EMU_A_DSP_CST(0), 2340 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_FRONT_RIGHT), EMU_A_DSP_GPR(d_front_gpr->gpr+1)); 2341 2342 /* Digital Rear Output l/r = 0 + Rear GPR(l/r) * D_REAR_GPR(l/r) */ 2343 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2344 EMU_A_DSP_OUTL(EMU_A_DSP_OUT_D_REAR), 2345 EMU_A_DSP_CST(0), 2346 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_REAR_LEFT), EMU_A_DSP_GPR(d_rear_gpr->gpr)); 2347 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2348 EMU_A_DSP_OUTR(EMU_A_DSP_OUT_D_REAR), 2349 EMU_A_DSP_CST(0), 2350 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_REAR_RIGHT), EMU_A_DSP_GPR(d_rear_gpr->gpr+1)); 2351 2352 /* Digital Center/Sub = 0 + Center/Sub GPR(l/r) * D_CENTER_GPR(l/r) */ 2353 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2354 EMU_A_DSP_OUTL(EMU_A_DSP_OUT_D_CENTER), 2355 EMU_A_DSP_CST(0), 2356 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_CENTER), EMU_A_DSP_GPR(d_center_sub_gpr->gpr)); 2357 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2358 EMU_A_DSP_OUTR(EMU_A_DSP_OUT_D_CENTER), 2359 EMU_A_DSP_CST(0), 2360 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_SUB), EMU_A_DSP_GPR(d_center_sub_gpr->gpr+1)); 2361 2362 /* DSP_IN_GPR(l/r) = 0 + AC97In(l/r) * R_AC97_IN_GPR(l/r) */ 2363 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2364 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2365 EMU_A_DSP_CST(0), 2366 EMU_A_DSP_INL(EMU_DSP_IN_AC97), EMU_A_DSP_GPR(r_ac97_in_gpr->gpr)); 2367 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2368 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2369 EMU_A_DSP_CST(0), 2370 EMU_A_DSP_INR(EMU_DSP_IN_AC97), EMU_A_DSP_GPR(r_ac97_in_gpr->gpr + 1)); 2371 2372 /* DSP_IN_GPR (l/r) = DSP_IN_GPR(l/r) + FX(0/1) * R_FX_OUT_GPR(l/r) */ 2373 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2374 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2375 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2376 EMU_DSP_FX(0), EMU_A_DSP_GPR(r_fx_out_gpr->gpr)); 2377 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2378 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2379 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2380 EMU_DSP_FX(1), EMU_A_DSP_GPR(r_fx_out_gpr->gpr + 1)); 2381 2382 /* DSP_IN_GPR(l/r) = 0 + DSP_IN_GPR(l/r) * 4 */ 2383 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2384 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2385 EMU_A_DSP_CST(0), 2386 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), EMU_A_DSP_CST(4)); 2387 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2388 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2389 EMU_A_DSP_CST(0), 2390 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), EMU_A_DSP_CST(4)); 2391 2392 /* ADC recording buffer (l/r) = DSP_IN_GPR(l/r) + CDIn(l/r) * R_CD_IN_GPR(l/r) */ 2393 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2394 EMU_A_DSP_OUTL(EMU_A_DSP_OUT_ADC), 2395 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2396 EMU_A_DSP_INL(EMU_DSP_IN_CDSPDIF), EMU_A_DSP_GPR(r_cd_in_gpr->gpr)); 2397 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2398 EMU_A_DSP_OUTR(EMU_A_DSP_OUT_ADC), 2399 EMU_A_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2400 EMU_A_DSP_INR(EMU_DSP_IN_CDSPDIF), EMU_A_DSP_GPR(r_cd_in_gpr->gpr + 1)); 2401 2402 2403 2404 /* zero out the rest of the microcode */ 2405 while (pc < 512) 2406 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_ACC3, 2407 EMU_A_DSP_CST(0), EMU_A_DSP_CST(0), 2408 EMU_A_DSP_CST(0), EMU_A_DSP_CST(0)); 2409 2410 emuxki_chan_write(&card->config, 0, EMU_A_DBG, 0); /* Is it really necessary ? */ 2411 2412 } else { 2413 /* DSP_IN_GPR(l/r) = 0 + AC97In(l/r) * P_AC97_IN_GPR(l/r) */ 2414 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2415 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2416 EMU_DSP_CST(0), 2417 EMU_DSP_INL(EMU_DSP_IN_AC97), EMU_DSP_GPR(p_ac97_in_gpr->gpr)); 2418 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2419 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2420 EMU_DSP_CST(0), 2421 EMU_DSP_INR(EMU_DSP_IN_AC97), EMU_DSP_GPR(p_ac97_in_gpr->gpr + 1)); 2422 2423 /* DSP_IN_GPR(l/r) = DSP_IN_GPR(l/r) + CDIn(l/r) * P_CD_IN_GPR(l/r) */ 2424 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2425 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2426 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2427 EMU_DSP_INL(EMU_DSP_IN_CDSPDIF), EMU_DSP_GPR(p_cd_in_gpr->gpr)); 2428 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2429 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2430 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2431 EMU_DSP_INR(EMU_DSP_IN_CDSPDIF), EMU_DSP_GPR(p_cd_in_gpr->gpr + 1)); 2432 2433 /* Front GPR(l/r) = DSP_IN_GPR(l/r) + FX(0/1) * 4 */ 2434 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2435 EMU_DSP_GPR(EMU_DSP_TMPGPR_FRONT_LEFT), 2436 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2437 EMU_DSP_FX(0), EMU_DSP_CST(4)); 2438 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2439 EMU_DSP_GPR(EMU_DSP_TMPGPR_FRONT_RIGHT), 2440 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2441 EMU_DSP_FX(1), EMU_DSP_CST(4)); 2442 2443 /* Rear GPR(l/r) = DSP_IN_GPR(l/r) + FX(2/3) * 4 */ 2444 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2445 EMU_DSP_GPR(EMU_DSP_TMPGPR_REAR_LEFT), 2446 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2447 EMU_DSP_FX(2), EMU_DSP_CST(4)); 2448 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2449 EMU_DSP_GPR(EMU_DSP_TMPGPR_REAR_RIGHT), 2450 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2451 EMU_DSP_FX(3), EMU_DSP_CST(4)); 2452 2453 /* Center/Sub GPR = 0 + FX(4/5) * 4 */ 2454 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2455 EMU_DSP_GPR(EMU_DSP_TMPGPR_CENTER), 2456 EMU_DSP_CST(0), 2457 EMU_DSP_FX(4), EMU_DSP_CST(4)); 2458 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2459 EMU_DSP_GPR(EMU_DSP_TMPGPR_SUB), 2460 EMU_DSP_CST(0), 2461 EMU_DSP_FX(5), EMU_DSP_CST(4)); 2462 2463 /* Analog Front Output l/r = 0 + Front GPR(l/r) * A_FRONT_GPR(l/r) */ 2464 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2465 EMU_DSP_OUTL(EMU_DSP_OUT_A_FRONT), 2466 EMU_DSP_CST(0), 2467 EMU_DSP_GPR(EMU_DSP_TMPGPR_FRONT_LEFT), EMU_DSP_GPR(a_front_gpr->gpr)); 2468 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2469 EMU_DSP_OUTR(EMU_DSP_OUT_A_FRONT), 2470 EMU_DSP_CST(0), 2471 EMU_DSP_GPR(EMU_DSP_TMPGPR_FRONT_RIGHT), EMU_DSP_GPR(a_front_gpr->gpr+1)); 2472 2473 /* Analog Rear Output l/r = 0 + Rear GPR(l/r) * A_REAR_GPR(l/r) */ 2474 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2475 EMU_DSP_OUTL(EMU_DSP_OUT_AD_REAR), 2476 EMU_DSP_CST(0), 2477 EMU_DSP_GPR(EMU_DSP_TMPGPR_REAR_LEFT), EMU_DSP_GPR(a_rear_gpr->gpr)); 2478 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2479 EMU_DSP_OUTR(EMU_DSP_OUT_AD_REAR), 2480 EMU_DSP_CST(0), 2481 EMU_DSP_GPR(EMU_DSP_TMPGPR_REAR_RIGHT), EMU_DSP_GPR(a_rear_gpr->gpr+1)); 2482 2483 /* Analog Center/Sub = 0 + Center/Sub GPR(l/r) * A_CENTER_GPR(l/r) */ 2484 if(IS_LIVE_5_1(&card->config)) { 2485 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2486 EMU_DSP_OUT_A_CENTER, 2487 EMU_DSP_CST(0), 2488 EMU_DSP_GPR(EMU_DSP_TMPGPR_CENTER), EMU_DSP_GPR(a_center_sub_gpr->gpr)); 2489 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2490 EMU_DSP_OUT_A_SUB, 2491 EMU_DSP_CST(0), 2492 EMU_DSP_GPR(EMU_DSP_TMPGPR_SUB), EMU_DSP_GPR(a_center_sub_gpr->gpr+1)); 2493 } 2494 2495 /* Digital Front Output l/r = 0 + Front GPR(l/r) * D_FRONT_GPR(l/r) */ 2496 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2497 EMU_DSP_OUTL(EMU_DSP_OUT_D_FRONT), 2498 EMU_DSP_CST(0), 2499 EMU_DSP_GPR(EMU_DSP_TMPGPR_FRONT_LEFT), EMU_DSP_GPR(d_front_gpr->gpr)); 2500 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2501 EMU_DSP_OUTR(EMU_DSP_OUT_D_FRONT), 2502 EMU_DSP_CST(0), 2503 EMU_DSP_GPR(EMU_DSP_TMPGPR_FRONT_RIGHT), EMU_DSP_GPR(d_front_gpr->gpr+1)); 2504 2505 /* Digital Rear Output l/r = 0 + Rear GPR(l/r) * D_REAR_GPR(l/r) */ 2506 /*emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2507 EMU_DSP_OUTL(EMU_DSP_OUT_D_REAR), 2508 EMU_DSP_CST(0), 2509 EMU_DSP_GPR(EMU_DSP_TMPGPR_REAR_LEFT), EMU_DSP_GPR(d_rear_gpr->gpr)); 2510 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2511 EMU_DSP_OUTR(EMU_DSP_OUT_D_REAR), 2512 EMU_DSP_CST(0), 2513 EMU_DSP_GPR(EMU_DSP_TMPGPR_REAR_RIGHT), EMU_DSP_GPR(d_rear_gpr->gpr+1));*/ 2514 2515 /* Digital Center/Sub = 0 + Center/Sub GPR(l/r) * D_CENTER_GPR(l/r) */ 2516 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2517 EMU_DSP_OUTL(EMU_DSP_OUT_D_CENTER), 2518 EMU_DSP_CST(0), 2519 EMU_DSP_GPR(EMU_DSP_TMPGPR_CENTER), EMU_DSP_GPR(d_center_sub_gpr->gpr)); 2520 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2521 EMU_DSP_OUTR(EMU_DSP_OUT_D_CENTER), 2522 EMU_DSP_CST(0), 2523 EMU_DSP_GPR(EMU_DSP_TMPGPR_SUB), EMU_DSP_GPR(d_center_sub_gpr->gpr+1)); 2524 2525 /* DSP_IN_GPR(l/r) = 0 + AC97In(l/r) * R_AC97_IN_GPR(l/r) */ 2526 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2527 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2528 EMU_DSP_CST(0), 2529 EMU_DSP_INL(EMU_DSP_IN_AC97), EMU_DSP_GPR(r_ac97_in_gpr->gpr)); 2530 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2531 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2532 EMU_DSP_CST(0), 2533 EMU_DSP_INR(EMU_DSP_IN_AC97), EMU_DSP_GPR(r_ac97_in_gpr->gpr + 1)); 2534 2535 /* DSP_IN_GPR (l/r) = DSP_IN_GPR(l/r) + FX(0/1) * R_FX_OUT_GPR(l/r) */ 2536 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2537 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2538 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2539 EMU_DSP_FX(0), EMU_DSP_GPR(r_fx_out_gpr->gpr)); 2540 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2541 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2542 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2543 EMU_DSP_FX(1), EMU_DSP_GPR(r_fx_out_gpr->gpr + 1)); 2544 2545 /* DSP_IN_GPR(l/r) = 0 + DSP_IN_GPR(l/r) * 4 */ 2546 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2547 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2548 EMU_DSP_CST(0), 2549 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), EMU_DSP_CST(4)); 2550 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACINTS, 2551 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2552 EMU_DSP_CST(0), 2553 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), EMU_DSP_CST(4)); 2554 2555 /* ADC recording buffer (l/r) = DSP_IN_GPR(l/r) + CDIn(l/r) * R_CD_IN_GPR(l/r) */ 2556 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2557 EMU_DSP_OUTL(EMU_DSP_OUT_ADC), 2558 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_L), 2559 EMU_DSP_INL(EMU_DSP_IN_CDSPDIF), EMU_DSP_GPR(r_cd_in_gpr->gpr)); 2560 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_MACS, 2561 EMU_DSP_OUTR(EMU_DSP_OUT_ADC), 2562 EMU_DSP_GPR(EMU_DSP_TMPGPR_DSP_IN_R), 2563 EMU_DSP_INR(EMU_DSP_IN_CDSPDIF), EMU_DSP_GPR(r_cd_in_gpr->gpr + 1)); 2564 2565 /* zero out the rest of the microcode */ 2566 while (pc < 512) 2567 emuxki_dsp_addop(&card->config, &pc, EMU_DSP_OP_ACC3, 2568 EMU_DSP_CST(0), EMU_DSP_CST(0), 2569 EMU_DSP_CST(0), EMU_DSP_CST(0)); 2570 2571 emuxki_chan_write(&card->config, 0, EMU_DBG, 0); /* Is it really necessary ? */ 2572 } 2573 2574 emuxki_dump_fx(card); 2575 } 2576 2577 status_t 2578 emuxki_init(emuxki_dev * card) 2579 { 2580 uint16 i; 2581 uint32 spcs, *ptb; 2582 uint32 silentpage; 2583 2584 /* disable any channel interrupt */ 2585 emuxki_chan_write(&card->config, 0, EMU_CLIEL, 0); 2586 emuxki_chan_write(&card->config, 0, EMU_CLIEH, 0); 2587 emuxki_chan_write(&card->config, 0, EMU_SOLEL, 0); 2588 emuxki_chan_write(&card->config, 0, EMU_SOLEH, 0); 2589 2590 /* Set recording buffers sizes to zero */ 2591 emuxki_chan_write(&card->config, 0, EMU_MICBS, EMU_RECBS_BUFSIZE_NONE); 2592 emuxki_chan_write(&card->config, 0, EMU_MICBA, 0); 2593 emuxki_chan_write(&card->config, 0, EMU_FXBS, EMU_RECBS_BUFSIZE_NONE); 2594 emuxki_chan_write(&card->config, 0, EMU_FXBA, 0); 2595 emuxki_chan_write(&card->config, 0, EMU_ADCBS, EMU_RECBS_BUFSIZE_NONE); 2596 emuxki_chan_write(&card->config, 0, EMU_ADCBA, 0); 2597 2598 if(IS_AUDIGY(&card->config)) { 2599 emuxki_chan_write(&card->config, 0, EMU_SPBYPASS, EMU_SPBYPASS_24_BITS); 2600 emuxki_chan_write(&card->config, 0, EMU_AC97SLOT, EMU_AC97SLOT_CENTER | EMU_AC97SLOT_LFE); 2601 } 2602 2603 /* Initialize all channels to stopped and no effects */ 2604 for (i = 0; i < EMU_NUMCHAN; i++) { 2605 emuxki_chan_write(&card->config, i, EMU_CHAN_DCYSUSV, 0); 2606 emuxki_chan_write(&card->config, i, EMU_CHAN_IP, 0); 2607 emuxki_chan_write(&card->config, i, EMU_CHAN_VTFT, 0xffff); 2608 emuxki_chan_write(&card->config, i, EMU_CHAN_CVCF, 0xffff); 2609 emuxki_chan_write(&card->config, i, EMU_CHAN_PTRX, 0); 2610 emuxki_chan_write(&card->config, i, EMU_CHAN_CPF, 0); 2611 emuxki_chan_write(&card->config, i, EMU_CHAN_CCR, 0); 2612 emuxki_chan_write(&card->config, i, EMU_CHAN_PSST, 0); 2613 emuxki_chan_write(&card->config, i, EMU_CHAN_DSL, 0x10); /* Why 16 ? */ 2614 emuxki_chan_write(&card->config, i, EMU_CHAN_CCCA, 0); 2615 emuxki_chan_write(&card->config, i, EMU_CHAN_Z1, 0); 2616 emuxki_chan_write(&card->config, i, EMU_CHAN_Z2, 0); 2617 emuxki_chan_write(&card->config, i, EMU_CHAN_FXRT, 0x32100000); 2618 emuxki_chan_write(&card->config, i, EMU_CHAN_ATKHLDM, 0); 2619 emuxki_chan_write(&card->config, i, EMU_CHAN_DCYSUSM, 0); 2620 emuxki_chan_write(&card->config, i, EMU_CHAN_IFATN, 0xffff); 2621 emuxki_chan_write(&card->config, i, EMU_CHAN_PEFE, 0); 2622 emuxki_chan_write(&card->config, i, EMU_CHAN_FMMOD, 0); 2623 emuxki_chan_write(&card->config, i, EMU_CHAN_TREMFRQ, 24); 2624 emuxki_chan_write(&card->config, i, EMU_CHAN_FM2FRQ2, 24); 2625 emuxki_chan_write(&card->config, i, EMU_CHAN_TEMPENV, 0); 2626 /*** these are last so OFF prevents writing ***/ 2627 emuxki_chan_write(&card->config, i, EMU_CHAN_LFOVAL2, 0); 2628 emuxki_chan_write(&card->config, i, EMU_CHAN_LFOVAL1, 0); 2629 emuxki_chan_write(&card->config, i, EMU_CHAN_ATKHLDV, 0); 2630 emuxki_chan_write(&card->config, i, EMU_CHAN_ENVVOL, 0); 2631 emuxki_chan_write(&card->config, i, EMU_CHAN_ENVVAL, 0); 2632 } 2633 2634 /* set digital outputs format */ 2635 spcs = (EMU_SPCS_CLKACCY_1000PPM | EMU_SPCS_SAMPLERATE_48 | 2636 EMU_SPCS_CHANNELNUM_LEFT | EMU_SPCS_SOURCENUM_UNSPEC | 2637 EMU_SPCS_GENERATIONSTATUS | 0x00001200 /* Cat code. */ | 2638 0x00000000 /* IEC-958 Mode */ | EMU_SPCS_EMPHASIS_NONE | 2639 EMU_SPCS_COPYRIGHT); 2640 emuxki_chan_write(&card->config, 0, EMU_SPCS0, spcs); 2641 emuxki_chan_write(&card->config, 0, EMU_SPCS1, spcs); 2642 emuxki_chan_write(&card->config, 0, EMU_SPCS2, spcs); 2643 2644 if(IS_AUDIGY2(&card->config)) { 2645 emuxki_chan_write(&card->config, 0, EMU_A2_SPDIF_SAMPLERATE, EMU_A2_SPDIF_UNKNOWN); 2646 2647 emuxki_reg_write_32(&card->config, EMU_A2_PTR, EMU_A2_SRCSEL); 2648 emuxki_reg_write_32(&card->config, EMU_A2_DATA, 2649 EMU_A2_SRCSEL_ENABLE_SPDIF | EMU_A2_SRCSEL_ENABLE_SRCMULTI); 2650 2651 if (card->info.revision == 4) { 2652 emuxki_reg_write_32(&card->config, EMU_A2_PTR, EMU_A2_SRCMULTI); 2653 emuxki_reg_write_32(&card->config, EMU_A2_DATA, EMU_A2_SRCMULTI_ENABLE_INPUT); 2654 } else { 2655 emuxki_reg_write_32(&card->config, EMU_A2_PTR, EMU_A2_SRCMULTI2); 2656 emuxki_reg_write_32(&card->config, EMU_A2_DATA, EMU_A2_SRCMULTI2_ENABLE_INPUT); 2657 } 2658 } 2659 2660 /* Let's play with sound processor */ 2661 emuxki_initfx(card); 2662 2663 /* allocate memory for our Page Table */ 2664 card->ptb_area = alloc_mem(&card->ptb_phy_base, &card->ptb_log_base, 2665 EMU_MAXPTE * sizeof(uint32), "emuxki ptb"); 2666 2667 /* This is necessary unless you like Metallic noise... */ 2668 card->silentpage_area = alloc_mem(&card->silentpage_phy_base, &card->silentpage_log_base, 2669 EMU_PTESIZE, "emuxki sp"); 2670 2671 if (card->ptb_area < B_OK || card->silentpage_area < B_OK) { 2672 PRINT(("couldn't allocate memory\n")); 2673 if (card->ptb_area > B_OK) 2674 delete_area(card->ptb_area); 2675 if (card->silentpage_area > B_OK) 2676 delete_area(card->silentpage_area); 2677 return B_ERROR; 2678 } 2679 2680 /* Zero out the silent page */ 2681 /* This might not be always true, it might be 128 for 8bit channels */ 2682 memset(card->ptb_log_base, 0, EMU_PTESIZE); 2683 2684 /* 2685 * Set all the PTB Entries to the silent page We shift the physical 2686 * address by one and OR it with the page number. I don't know what 2687 * the ORed index is for, might be a very useful unused feature... 2688 */ 2689 silentpage = ((uint32)card->silentpage_phy_base) << 1; 2690 ptb = card->ptb_log_base; 2691 for (i = 0; i < EMU_MAXPTE; i++) 2692 ptb[i] = silentpage | i; 2693 2694 /* Write PTB address and set TCB to none */ 2695 emuxki_chan_write(&card->config, 0, EMU_PTB, (uint32)card->ptb_phy_base); 2696 emuxki_chan_write(&card->config, 0, EMU_TCBS, 0); /* This means 16K TCB */ 2697 emuxki_chan_write(&card->config, 0, EMU_TCB, 0); /* No TCB use for now */ 2698 2699 /* 2700 * Set channels MAPs to the silent page. 2701 * I don't know what MAPs are for. 2702 */ 2703 silentpage |= EMU_CHAN_MAP_PTI_MASK; 2704 for (i = 0; i < EMU_NUMCHAN; i++) { 2705 emuxki_chan_write(&card->config, i, EMU_CHAN_MAPA, silentpage); 2706 emuxki_chan_write(&card->config, i, EMU_CHAN_MAPB, silentpage); 2707 card->channel[i] = NULL; 2708 } 2709 2710 /* Init streams list */ 2711 LIST_INIT(&(card->streams)); 2712 2713 /* Init mems list */ 2714 LIST_INIT(&(card->mem)); 2715 2716 /* Timer is stopped */ 2717 card->timerstate &= ~EMU_TIMER_STATE_ENABLED; 2718 card->timerate = 0xffff; 2719 2720 return B_OK; 2721 } 2722 2723 2724 2725 status_t 2726 init_driver(void) 2727 { 2728 int ix=0; 2729 2730 pci_info info; 2731 num_cards = 0; 2732 2733 PRINT(("init_driver()\n")); 2734 load_driver_symbols("emuxki"); 2735 2736 if (get_module(pci_name, (module_info **) &pci)) 2737 return ENOSYS; 2738 2739 if (get_module(mpu401_name, (module_info **) &mpu401)) { 2740 put_module(pci_name); 2741 return ENOSYS; 2742 } 2743 2744 while ((*pci->get_nth_pci_info)(ix, &info) == B_OK) { 2745 if (info.vendor_id == CREATIVELABS_VENDOR_ID && 2746 (info.device_id == CREATIVELABS_SBLIVE_DEVICE_ID 2747 #if AUDIGY 2748 || info.device_id == CREATIVELABS_AUDIGY_DEVICE_ID 2749 #endif 2750 )) { 2751 if (num_cards == NUM_CARDS) { 2752 PRINT(("Too many emuxki cards installed!\n")); 2753 break; 2754 } 2755 memset(&cards[num_cards], 0, sizeof(emuxki_dev)); 2756 cards[num_cards].info = info; 2757 if (emuxki_setup(&cards[num_cards])) { 2758 PRINT(("Setup of emuxki %ld failed\n", num_cards+1)); 2759 } 2760 else { 2761 num_cards++; 2762 } 2763 } 2764 ix++; 2765 } 2766 if (!num_cards) { 2767 put_module(mpu401_name); 2768 put_module(pci_name); 2769 PRINT(("emuxki: no suitable cards found\n")); 2770 return ENODEV; 2771 } 2772 2773 return B_OK; 2774 } 2775 2776 2777 static void 2778 emuxki_shutdown(emuxki_dev *card) 2779 { 2780 uint32 i; 2781 2782 PRINT(("shutdown(%p)\n", card)); 2783 2784 emuxki_reg_write_32(&card->config, EMU_HCFG, EMU_HCFG_LOCKSOUNDCACHE | 2785 EMU_HCFG_LOCKTANKCACHE_MASK | EMU_HCFG_MUTEBUTTONENABLE); 2786 emuxki_reg_write_32(&card->config, EMU_INTE, 0); 2787 2788 dump_hardware_regs(&card->config); 2789 2790 /* Disable any Channels interrupts */ 2791 emuxki_chan_write(&card->config, 0, EMU_CLIEL, 0); 2792 emuxki_chan_write(&card->config, 0, EMU_CLIEH, 0); 2793 emuxki_chan_write(&card->config, 0, EMU_SOLEL, 0); 2794 emuxki_chan_write(&card->config, 0, EMU_SOLEH, 0); 2795 2796 /* Stop all channels */ 2797 /* This shouldn't be necessary, i'll remove once everything works */ 2798 for (i = 0; i < EMU_NUMCHAN; i++) 2799 emuxki_chan_write(&card->config, i, EMU_CHAN_DCYSUSV, 0); 2800 for (i = 0; i < EMU_NUMCHAN; i++) { 2801 emuxki_chan_write(&card->config, i, EMU_CHAN_VTFT, 0); 2802 emuxki_chan_write(&card->config, i, EMU_CHAN_CVCF, 0); 2803 emuxki_chan_write(&card->config, i, EMU_CHAN_PTRX, 0); 2804 emuxki_chan_write(&card->config, i, EMU_CHAN_CPF, 0); 2805 } 2806 2807 remove_io_interrupt_handler(card->config.irq, emuxki_int, card); 2808 2809 /* 2810 * deallocate Emu10k1 caches and recording buffers Again it will be 2811 * removed because it will be done in voice shutdown. 2812 */ 2813 emuxki_chan_write(&card->config, 0, EMU_MICBS, EMU_RECBS_BUFSIZE_NONE); 2814 emuxki_chan_write(&card->config, 0, EMU_MICBA, 0); 2815 emuxki_chan_write(&card->config, 0, EMU_FXBS, EMU_RECBS_BUFSIZE_NONE); 2816 emuxki_chan_write(&card->config, 0, EMU_FXBA, 0); 2817 if(IS_AUDIGY(&card->config)) { 2818 emuxki_chan_write(&card->config, 0, EMU_A_FXWC1, 0); 2819 emuxki_chan_write(&card->config, 0, EMU_A_FXWC2, 0); 2820 } else { 2821 emuxki_chan_write(&card->config, 0, EMU_FXWC, 0); 2822 } 2823 emuxki_chan_write(&card->config, 0, EMU_ADCBS, EMU_RECBS_BUFSIZE_NONE); 2824 emuxki_chan_write(&card->config, 0, EMU_ADCBA, 0); 2825 2826 /* 2827 * I don't know yet how i will handle tank cache buffer, 2828 * I don't even clearly know what it is for 2829 */ 2830 emuxki_chan_write(&card->config, 0, EMU_TCB, 0); /* 16K again */ 2831 emuxki_chan_write(&card->config, 0, EMU_TCBS, 0); 2832 2833 emuxki_chan_write(&card->config, 0, EMU_DBG, 0x8000); /* necessary ? */ 2834 2835 PRINT(("freeing ptb_area\n")); 2836 if (card->ptb_area > B_OK) 2837 delete_area(card->ptb_area); 2838 PRINT(("freeing silentpage_area\n")); 2839 if (card->silentpage_area > B_OK) 2840 delete_area(card->silentpage_area); 2841 } 2842 2843 2844 void 2845 uninit_driver(void) 2846 { 2847 int ix, cnt = num_cards; 2848 2849 PRINT(("uninit_driver()\n")); 2850 2851 for (ix=0; ix<cnt; ix++) { 2852 emuxki_shutdown(&cards[ix]); 2853 } 2854 memset(&cards, 0, sizeof(cards)); 2855 put_module(mpu401_name); 2856 put_module(pci_name); 2857 num_cards = 0; 2858 } 2859 2860 2861 const char ** 2862 publish_devices(void) 2863 { 2864 int ix = 0; 2865 PRINT(("publish_devices()\n")); 2866 2867 for (ix=0; names[ix]; ix++) { 2868 PRINT(("publish %s\n", names[ix])); 2869 } 2870 return (const char **)names; 2871 } 2872 2873 2874 device_hooks * 2875 find_device(const char * name) 2876 { 2877 int ix; 2878 2879 PRINT(("emuxki: find_device(%s)\n", name)); 2880 2881 for (ix=0; ix<num_cards; ix++) { 2882 #if MIDI 2883 if (!strcmp(cards[ix].midi.name, name)) { 2884 return &midi_hooks; 2885 } 2886 #endif 2887 if (!strcmp(cards[ix].name, name)) { 2888 return &multi_hooks; 2889 } 2890 } 2891 PRINT(("emuxki: find_device(%s) failed\n", name)); 2892 return NULL; 2893 } 2894 2895 int32 api_version = B_CUR_DRIVER_API_VERSION; 2896 2897 2898 2899