1 /*- 2 * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk> 3 * Copyright (c) 2003-2007 Yuriy Tsibizov <yuriy.tsibizov@gfk.ru> 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: head/sys/dev/sound/pci/emu10kx-pcm.c 246128 2013-01-30 18:01:20Z sbz $ 28 */ 29 30 #include <sys/param.h> 31 #include <sys/types.h> 32 #include <sys/bus.h> 33 #include <sys/rman.h> 34 #include <sys/systm.h> 35 #include <sys/sbuf.h> 36 #include <sys/queue.h> 37 #include <sys/lock.h> 38 #include <sys/mutex.h> 39 40 #ifdef HAVE_KERNEL_OPTION_HEADERS 41 #include "opt_snd.h" 42 #endif 43 44 #include <dev/sound/chip.h> 45 #include <dev/sound/pcm/sound.h> 46 #include <dev/sound/pcm/ac97.h> 47 48 #include "mixer_if.h" 49 50 #include <dev/sound/pci/emuxkireg.h> 51 #include <dev/sound/pci/emu10kx.h> 52 53 struct emu_pcm_pchinfo { 54 int spd; 55 int fmt; 56 unsigned int blksz; 57 int run; 58 struct emu_voice *master; 59 struct emu_voice *slave; 60 struct snd_dbuf *buffer; 61 struct pcm_channel *channel; 62 struct emu_pcm_info *pcm; 63 int timer; 64 }; 65 66 struct emu_pcm_rchinfo { 67 int spd; 68 int fmt; 69 unsigned int blksz; 70 int run; 71 uint32_t idxreg; 72 uint32_t basereg; 73 uint32_t sizereg; 74 uint32_t setupreg; 75 uint32_t irqmask; 76 uint32_t iprmask; 77 int ihandle; 78 struct snd_dbuf *buffer; 79 struct pcm_channel *channel; 80 struct emu_pcm_info *pcm; 81 int timer; 82 }; 83 84 /* XXX Hardware playback channels */ 85 #define MAX_CHANNELS 4 86 87 #if MAX_CHANNELS > 13 88 #error Too many hardware channels defined. 13 is the maximum 89 #endif 90 91 struct emu_pcm_info { 92 struct lock *lock; 93 device_t dev; /* device information */ 94 struct emu_sc_info *card; 95 struct emu_pcm_pchinfo pch[MAX_CHANNELS]; /* hardware channels */ 96 int pnum; /* next free channel number */ 97 struct emu_pcm_rchinfo rch_adc; 98 struct emu_pcm_rchinfo rch_efx; 99 struct emu_route rt; 100 struct emu_route rt_mono; 101 int route; 102 int ihandle; /* interrupt handler */ 103 unsigned int bufsz; 104 int is_emu10k1; 105 struct ac97_info *codec; 106 uint32_t ac97_state[0x7F]; 107 kobj_class_t ac97_mixerclass; 108 uint32_t ac97_recdevs; 109 uint32_t ac97_playdevs; 110 struct snd_mixer *sm; 111 int mch_disabled; 112 unsigned int emu10k1_volcache[2][2]; 113 }; 114 115 116 static uint32_t emu_rfmt_adc[] = { 117 SND_FORMAT(AFMT_S16_LE, 1, 0), 118 SND_FORMAT(AFMT_S16_LE, 2, 0), 119 0 120 }; 121 static struct pcmchan_caps emu_reccaps_adc = { 122 8000, 48000, emu_rfmt_adc, 0 123 }; 124 125 static uint32_t emu_rfmt_efx[] = { 126 SND_FORMAT(AFMT_S16_LE, 1, 0), 127 0 128 }; 129 130 static struct pcmchan_caps emu_reccaps_efx_live = { 131 48000*32, 48000*32, emu_rfmt_efx, 0 132 }; 133 134 static struct pcmchan_caps emu_reccaps_efx_audigy = { 135 48000*64, 48000*64, emu_rfmt_efx, 0 136 }; 137 138 static int emu_rates_live[] = { 139 48000*32 140 }; 141 142 static int emu_rates_audigy[] = { 143 48000*64 144 }; 145 146 static uint32_t emu_pfmt[] = { 147 SND_FORMAT(AFMT_U8, 1, 0), 148 SND_FORMAT(AFMT_U8, 2, 0), 149 SND_FORMAT(AFMT_S16_LE, 1, 0), 150 SND_FORMAT(AFMT_S16_LE, 2, 0), 151 0 152 }; 153 static uint32_t emu_pfmt_mono[] = { 154 SND_FORMAT(AFMT_U8, 1, 0), 155 SND_FORMAT(AFMT_S16_LE, 1, 0), 156 0 157 }; 158 159 static struct pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0}; 160 static struct pcmchan_caps emu_playcaps_mono = {4000, 48000, emu_pfmt_mono, 0}; 161 162 static int emu10k1_adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000}; 163 /* audigy supports 12kHz. */ 164 static int emu10k2_adcspeed[9] = {48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000}; 165 166 static uint32_t emu_pcm_intr(void *pcm, uint32_t stat); 167 168 static const struct emu_dspmix_props_k1 { 169 uint8_t present; 170 uint8_t recdev; 171 int8_t input; 172 } dspmix_k1 [SOUND_MIXER_NRDEVICES] = { 173 /* no mixer device for ac97 */ /* in0 AC97 */ 174 [SOUND_MIXER_DIGITAL1] = {1, 1, 1}, /* in1 CD SPDIF */ 175 /* not connected */ /* in2 (zoom) */ 176 [SOUND_MIXER_DIGITAL2] = {1, 1, 3}, /* in3 toslink */ 177 [SOUND_MIXER_LINE2] = {1, 1, 4}, /* in4 Line-In2 */ 178 [SOUND_MIXER_DIGITAL3] = {1, 1, 5}, /* in5 on-card SPDIF */ 179 [SOUND_MIXER_LINE3] = {1, 1, 6}, /* in6 AUX2 */ 180 /* not connected */ /* in7 */ 181 }; 182 static const struct emu_dspmix_props_k2 { 183 uint8_t present; 184 uint8_t recdev; 185 int8_t input; 186 } dspmix_k2 [SOUND_MIXER_NRDEVICES] = { 187 [SOUND_MIXER_VOLUME] = {1, 0, (-1)}, 188 [SOUND_MIXER_PCM] = {1, 0, (-1)}, 189 190 /* no mixer device */ /* in0 AC97 */ 191 [SOUND_MIXER_DIGITAL1] = {1, 1, 1}, /* in1 CD SPDIF */ 192 [SOUND_MIXER_DIGITAL2] = {1, 1, 2}, /* in2 COAX SPDIF */ 193 /* not connected */ /* in3 */ 194 [SOUND_MIXER_LINE2] = {1, 1, 4}, /* in4 Line-In2 */ 195 [SOUND_MIXER_DIGITAL3] = {1, 1, 5}, /* in5 on-card SPDIF */ 196 [SOUND_MIXER_LINE3] = {1, 1, 6}, /* in6 AUX2 */ 197 /* not connected */ /* in7 */ 198 }; 199 200 static int 201 emu_dspmixer_init(struct snd_mixer *m) 202 { 203 struct emu_pcm_info *sc; 204 int i; 205 int p, r; 206 207 p = 0; 208 r = 0; 209 210 sc = mix_getdevinfo(m); 211 212 if (sc->route == RT_FRONT) { 213 /* create submixer for AC97 codec */ 214 if ((sc->ac97_mixerclass != NULL) && (sc->codec != NULL)) { 215 sc->sm = mixer_create(sc->dev, sc->ac97_mixerclass, sc->codec, "ac97"); 216 if (sc->sm != NULL) { 217 p = mix_getdevs(sc->sm); 218 r = mix_getrecdevs(sc->sm); 219 } 220 } 221 222 sc->ac97_playdevs = p; 223 sc->ac97_recdevs = r; 224 } 225 226 /* This two are always here */ 227 p |= (1 << SOUND_MIXER_PCM); 228 p |= (1 << SOUND_MIXER_VOLUME); 229 230 if (sc->route == RT_FRONT) { 231 if (sc->is_emu10k1) { 232 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 233 if (dspmix_k1[i].present) 234 p |= (1 << i); 235 if (dspmix_k1[i].recdev) 236 r |= (1 << i); 237 } 238 } else { 239 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 240 if (dspmix_k2[i].present) 241 p |= (1 << i); 242 if (dspmix_k2[i].recdev) 243 r |= (1 << i); 244 } 245 } 246 } 247 248 mix_setdevs(m, p); 249 mix_setrecdevs(m, r); 250 251 return (0); 252 } 253 254 static int 255 emu_dspmixer_uninit(struct snd_mixer *m) 256 { 257 struct emu_pcm_info *sc; 258 int err = 0; 259 260 /* drop submixer for AC97 codec */ 261 sc = mix_getdevinfo(m); 262 if (sc->sm != NULL) { 263 err = mixer_delete(sc->sm); 264 if (err) 265 return (err); 266 sc->sm = NULL; 267 } 268 return (0); 269 } 270 271 static int 272 emu_dspmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 273 { 274 struct emu_pcm_info *sc; 275 276 sc = mix_getdevinfo(m); 277 278 switch (dev) { 279 case SOUND_MIXER_VOLUME: 280 switch (sc->route) { 281 case RT_FRONT: 282 if (sc->sm != NULL) 283 mix_set(sc->sm, dev, left, right); 284 if (sc->mch_disabled) { 285 /* In emu10k1 case PCM volume does not affect 286 sound routed to rear & center/sub (it is connected 287 to AC97 codec). Calculate it manually. */ 288 /* This really should belong to emu10kx.c */ 289 if (sc->is_emu10k1) { 290 sc->emu10k1_volcache[0][0] = left; 291 left = left * sc->emu10k1_volcache[1][0] / 100; 292 sc->emu10k1_volcache[0][1] = right; 293 right = right * sc->emu10k1_volcache[1][1] / 100; 294 } 295 296 emumix_set_volume(sc->card, M_MASTER_REAR_L, left); 297 emumix_set_volume(sc->card, M_MASTER_REAR_R, right); 298 if (!sc->is_emu10k1) { 299 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2); 300 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2); 301 /* XXX side */ 302 } 303 } /* mch disabled */ 304 break; 305 case RT_REAR: 306 emumix_set_volume(sc->card, M_MASTER_REAR_L, left); 307 emumix_set_volume(sc->card, M_MASTER_REAR_R, right); 308 break; 309 case RT_CENTER: 310 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2); 311 break; 312 case RT_SUB: 313 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2); 314 break; 315 } 316 break; 317 case SOUND_MIXER_PCM: 318 switch (sc->route) { 319 case RT_FRONT: 320 if (sc->sm != NULL) 321 mix_set(sc->sm, dev, left, right); 322 if (sc->mch_disabled) { 323 /* See SOUND_MIXER_VOLUME case */ 324 if (sc->is_emu10k1) { 325 sc->emu10k1_volcache[1][0] = left; 326 left = left * sc->emu10k1_volcache[0][0] / 100; 327 sc->emu10k1_volcache[1][1] = right; 328 right = right * sc->emu10k1_volcache[0][1] / 100; 329 } 330 emumix_set_volume(sc->card, M_MASTER_REAR_L, left); 331 emumix_set_volume(sc->card, M_MASTER_REAR_R, right); 332 333 if (!sc->is_emu10k1) { 334 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2); 335 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2); 336 /* XXX side */ 337 } 338 } /* mch_disabled */ 339 break; 340 case RT_REAR: 341 emumix_set_volume(sc->card, M_FX2_REAR_L, left); 342 emumix_set_volume(sc->card, M_FX3_REAR_R, right); 343 break; 344 case RT_CENTER: 345 emumix_set_volume(sc->card, M_FX4_CENTER, (left+right)/2); 346 break; 347 case RT_SUB: 348 emumix_set_volume(sc->card, M_FX5_SUBWOOFER, (left+right)/2); 349 break; 350 } 351 break; 352 case SOUND_MIXER_DIGITAL1: /* CD SPDIF, in1 */ 353 emumix_set_volume(sc->card, M_IN1_FRONT_L, left); 354 emumix_set_volume(sc->card, M_IN1_FRONT_R, right); 355 break; 356 case SOUND_MIXER_DIGITAL2: 357 if (sc->is_emu10k1) { 358 /* TOSLink, in3 */ 359 emumix_set_volume(sc->card, M_IN3_FRONT_L, left); 360 emumix_set_volume(sc->card, M_IN3_FRONT_R, right); 361 } else { 362 /* COAX SPDIF, in2 */ 363 emumix_set_volume(sc->card, M_IN2_FRONT_L, left); 364 emumix_set_volume(sc->card, M_IN2_FRONT_R, right); 365 } 366 break; 367 case SOUND_MIXER_LINE2: /* Line-In2, in4 */ 368 emumix_set_volume(sc->card, M_IN4_FRONT_L, left); 369 emumix_set_volume(sc->card, M_IN4_FRONT_R, right); 370 break; 371 case SOUND_MIXER_DIGITAL3: /* on-card SPDIF, in5 */ 372 emumix_set_volume(sc->card, M_IN5_FRONT_L, left); 373 emumix_set_volume(sc->card, M_IN5_FRONT_R, right); 374 break; 375 case SOUND_MIXER_LINE3: /* AUX2, in6 */ 376 emumix_set_volume(sc->card, M_IN6_FRONT_L, left); 377 emumix_set_volume(sc->card, M_IN6_FRONT_R, right); 378 break; 379 default: 380 if (sc->sm != NULL) { 381 /* XXX emumix_set_volume is not required here */ 382 emumix_set_volume(sc->card, M_IN0_FRONT_L, 100); 383 emumix_set_volume(sc->card, M_IN0_FRONT_R, 100); 384 mix_set(sc->sm, dev, left, right); 385 } else 386 device_printf(sc->dev, "mixer error: unknown device %d\n", dev); 387 } 388 return (0); 389 } 390 391 static u_int32_t 392 emu_dspmixer_setrecsrc(struct snd_mixer *m, u_int32_t src) 393 { 394 struct emu_pcm_info *sc; 395 int i; 396 u_int32_t recmask; 397 int input[8]; 398 399 sc = mix_getdevinfo(m); 400 recmask = 0; 401 for (i=0; i < 8; i++) 402 input[i]=0; 403 404 if (sc->sm != NULL) 405 if ((src & sc->ac97_recdevs) !=0) 406 if (mix_setrecsrc(sc->sm, src & sc->ac97_recdevs) == 0) { 407 recmask |= (src & sc->ac97_recdevs); 408 /* Recording from AC97 codec. 409 Enable AC97 route to rec on DSP */ 410 input[0] = 1; 411 } 412 if (sc->is_emu10k1) { 413 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 414 if (dspmix_k1[i].recdev) 415 if ((src & (1 << i)) == ((uint32_t)1 << i)) { 416 recmask |= (1 << i); 417 /* enable device i */ 418 input[dspmix_k1[i].input] = 1; 419 } 420 } 421 } else { 422 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 423 if (dspmix_k2[i].recdev) 424 if ((src & (1 << i)) == ((uint32_t)1 << i)) { 425 recmask |= (1 << i); 426 /* enable device i */ 427 input[dspmix_k2[i].input] = 1; 428 } 429 } 430 } 431 emumix_set_volume(sc->card, M_IN0_REC_L, input[0] == 1 ? 100 : 0); 432 emumix_set_volume(sc->card, M_IN0_REC_R, input[0] == 1 ? 100 : 0); 433 434 emumix_set_volume(sc->card, M_IN1_REC_L, input[1] == 1 ? 100 : 0); 435 emumix_set_volume(sc->card, M_IN1_REC_R, input[1] == 1 ? 100 : 0); 436 437 if (!sc->is_emu10k1) { 438 emumix_set_volume(sc->card, M_IN2_REC_L, input[2] == 1 ? 100 : 0); 439 emumix_set_volume(sc->card, M_IN2_REC_R, input[2] == 1 ? 100 : 0); 440 } 441 442 if (sc->is_emu10k1) { 443 emumix_set_volume(sc->card, M_IN3_REC_L, input[3] == 1 ? 100 : 0); 444 emumix_set_volume(sc->card, M_IN3_REC_R, input[3] == 1 ? 100 : 0); 445 } 446 447 emumix_set_volume(sc->card, M_IN4_REC_L, input[4] == 1 ? 100 : 0); 448 emumix_set_volume(sc->card, M_IN4_REC_R, input[4] == 1 ? 100 : 0); 449 450 emumix_set_volume(sc->card, M_IN5_REC_L, input[5] == 1 ? 100 : 0); 451 emumix_set_volume(sc->card, M_IN5_REC_R, input[5] == 1 ? 100 : 0); 452 453 emumix_set_volume(sc->card, M_IN6_REC_L, input[6] == 1 ? 100 : 0); 454 emumix_set_volume(sc->card, M_IN6_REC_R, input[6] == 1 ? 100 : 0); 455 456 /* XXX check for K1/k2 differences? */ 457 if ((src & (1 << SOUND_MIXER_PCM)) == (1 << SOUND_MIXER_PCM)) { 458 emumix_set_volume(sc->card, M_FX0_REC_L, emumix_get_volume(sc->card, M_FX0_FRONT_L)); 459 emumix_set_volume(sc->card, M_FX1_REC_R, emumix_get_volume(sc->card, M_FX1_FRONT_R)); 460 } else { 461 emumix_set_volume(sc->card, M_FX0_REC_L, 0); 462 emumix_set_volume(sc->card, M_FX1_REC_R, 0); 463 } 464 465 return (recmask); 466 } 467 468 static kobj_method_t emudspmixer_methods[] = { 469 KOBJMETHOD(mixer_init, emu_dspmixer_init), 470 KOBJMETHOD(mixer_uninit, emu_dspmixer_uninit), 471 KOBJMETHOD(mixer_set, emu_dspmixer_set), 472 KOBJMETHOD(mixer_setrecsrc, emu_dspmixer_setrecsrc), 473 KOBJMETHOD_END 474 }; 475 MIXER_DECLARE(emudspmixer); 476 477 static int 478 emu_efxmixer_init(struct snd_mixer *m) 479 { 480 mix_setdevs(m, SOUND_MASK_VOLUME); 481 mix_setrecdevs(m, SOUND_MASK_MONITOR); 482 return (0); 483 } 484 485 static int 486 emu_efxmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 487 { 488 if (left + right == 200) return (0); 489 return (0); 490 } 491 492 static u_int32_t 493 emu_efxmixer_setrecsrc(struct snd_mixer *m __unused, u_int32_t src __unused) 494 { 495 return (SOUND_MASK_MONITOR); 496 } 497 498 static kobj_method_t emuefxmixer_methods[] = { 499 KOBJMETHOD(mixer_init, emu_efxmixer_init), 500 KOBJMETHOD(mixer_set, emu_efxmixer_set), 501 KOBJMETHOD(mixer_setrecsrc, emu_efxmixer_setrecsrc), 502 KOBJMETHOD_END 503 }; 504 MIXER_DECLARE(emuefxmixer); 505 506 /* 507 * AC97 emulation code for Audigy and later cards. 508 * Some parts of AC97 codec are not used by hardware, but can be used 509 * to change some DSP controls via AC97 mixer interface. This includes: 510 * - master volume controls MASTER_FRONT_[R|L] 511 * - pcm volume controls FX[0|1]_FRONT_[R|L] 512 * - rec volume controls MASTER_REC_[R|L] 513 * We do it because we need to put it under user control.... 514 * We also keep some parts of AC97 disabled to get better sound quality 515 */ 516 517 #define AC97LEFT(x) ((x & 0x7F00)>>8) 518 #define AC97RIGHT(x) (x & 0x007F) 519 #define AC97MUTE(x) ((x & 0x8000)>>15) 520 #define BIT4_TO100(x) (100-(x)*100/(0x0f)) 521 #define BIT6_TO100(x) (100-(x)*100/(0x3f)) 522 #define BIT4_TO255(x) (255-(x)*255/(0x0f)) 523 #define BIT6_TO255(x) (255-(x)*255/(0x3f)) 524 #define V100_TOBIT6(x) (0x3f*(100-x)/100) 525 #define V100_TOBIT4(x) (0x0f*(100-x)/100) 526 #define AC97ENCODE(x_muted, x_left, x_right) (((x_muted & 1)<<15) | ((x_left & 0x3f)<<8) | (x_right & 0x3f)) 527 528 static int 529 emu_ac97_read_emulation(struct emu_pcm_info *sc, int regno) 530 { 531 int use_ac97; 532 int emulated; 533 int tmp; 534 535 use_ac97 = 1; 536 emulated = 0; 537 538 switch (regno) { 539 case AC97_MIX_MASTER: 540 emulated = sc->ac97_state[AC97_MIX_MASTER]; 541 use_ac97 = 0; 542 break; 543 case AC97_MIX_PCM: 544 emulated = sc->ac97_state[AC97_MIX_PCM]; 545 use_ac97 = 0; 546 break; 547 case AC97_REG_RECSEL: 548 emulated = 0x0505; 549 use_ac97 = 0; 550 break; 551 case AC97_MIX_RGAIN: 552 emulated = sc->ac97_state[AC97_MIX_RGAIN]; 553 use_ac97 = 0; 554 break; 555 } 556 557 emu_wr(sc->card, EMU_AC97ADDR, regno, 1); 558 tmp = emu_rd(sc->card, EMU_AC97DATA, 2); 559 560 if (use_ac97) 561 emulated = tmp; 562 563 return (emulated); 564 } 565 566 static void 567 emu_ac97_write_emulation(struct emu_pcm_info *sc, int regno, uint32_t data) 568 { 569 int write_ac97; 570 int left, right; 571 uint32_t emu_left, emu_right; 572 int is_mute; 573 574 write_ac97 = 1; 575 576 left = AC97LEFT(data); 577 emu_left = BIT6_TO100(left); /* We show us as 6-bit AC97 mixer */ 578 right = AC97RIGHT(data); 579 emu_right = BIT6_TO100(right); 580 is_mute = AC97MUTE(data); 581 if (is_mute) 582 emu_left = emu_right = 0; 583 584 switch (regno) { 585 /* TODO: reset emulator on AC97_RESET */ 586 case AC97_MIX_MASTER: 587 emumix_set_volume(sc->card, M_MASTER_FRONT_L, emu_left); 588 emumix_set_volume(sc->card, M_MASTER_FRONT_R, emu_right); 589 sc->ac97_state[AC97_MIX_MASTER] = data & (0x8000 | 0x3f3f); 590 data = 0x8000; /* Mute AC97 main out */ 591 break; 592 case AC97_MIX_PCM: /* PCM OUT VOL */ 593 emumix_set_volume(sc->card, M_FX0_FRONT_L, emu_left); 594 emumix_set_volume(sc->card, M_FX1_FRONT_R, emu_right); 595 sc->ac97_state[AC97_MIX_PCM] = data & (0x8000 | 0x3f3f); 596 data = 0x8000; /* Mute AC97 PCM out */ 597 break; 598 case AC97_REG_RECSEL: 599 /* 600 * PCM recording source is set to "stereo mix" (labeled "vol" 601 * in mixer). There is no 'playback' from AC97 codec - 602 * if you want to hear anything from AC97 you have to _record_ 603 * it. Keep things simple and record "stereo mix". 604 */ 605 data = 0x0505; 606 break; 607 case AC97_MIX_RGAIN: /* RECORD GAIN */ 608 emu_left = BIT4_TO100(left); /* rgain is 4-bit */ 609 emu_right = BIT4_TO100(right); 610 emumix_set_volume(sc->card, M_MASTER_REC_L, 100-emu_left); 611 emumix_set_volume(sc->card, M_MASTER_REC_R, 100-emu_right); 612 /* 613 * Record gain on AC97 should stay zero to get AC97 sound on 614 * AC97_[RL] connectors on EMU10K2 chip. AC97 on Audigy is not 615 * directly connected to any output, only to EMU10K2 chip Use 616 * this control to set AC97 mix volume inside EMU10K2 chip 617 */ 618 sc->ac97_state[AC97_MIX_RGAIN] = data & (0x8000 | 0x0f0f); 619 data = 0x0000; 620 break; 621 } 622 if (write_ac97) { 623 emu_wr(sc->card, EMU_AC97ADDR, regno, 1); 624 emu_wr(sc->card, EMU_AC97DATA, data, 2); 625 } 626 } 627 628 static int 629 emu_erdcd(kobj_t obj __unused, void *devinfo, int regno) 630 { 631 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 632 633 return (emu_ac97_read_emulation(sc, regno)); 634 } 635 636 static int 637 emu_ewrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data) 638 { 639 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 640 641 emu_ac97_write_emulation(sc, regno, data); 642 return (0); 643 } 644 645 static kobj_method_t emu_eac97_methods[] = { 646 KOBJMETHOD(ac97_read, emu_erdcd), 647 KOBJMETHOD(ac97_write, emu_ewrcd), 648 KOBJMETHOD_END 649 }; 650 AC97_DECLARE(emu_eac97); 651 652 /* real ac97 codec */ 653 static int 654 emu_rdcd(kobj_t obj __unused, void *devinfo, int regno) 655 { 656 int rd; 657 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 658 659 KASSERT(sc->card != NULL, ("emu_rdcd: no soundcard")); 660 emu_wr(sc->card, EMU_AC97ADDR, regno, 1); 661 rd = emu_rd(sc->card, EMU_AC97DATA, 2); 662 return (rd); 663 } 664 665 static int 666 emu_wrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data) 667 { 668 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 669 670 KASSERT(sc->card != NULL, ("emu_wrcd: no soundcard")); 671 emu_wr(sc->card, EMU_AC97ADDR, regno, 1); 672 emu_wr(sc->card, EMU_AC97DATA, data, 2); 673 return (0); 674 } 675 676 static kobj_method_t emu_ac97_methods[] = { 677 KOBJMETHOD(ac97_read, emu_rdcd), 678 KOBJMETHOD(ac97_write, emu_wrcd), 679 KOBJMETHOD_END 680 }; 681 AC97_DECLARE(emu_ac97); 682 683 684 static int 685 emu_k1_recval(int speed) 686 { 687 int val; 688 689 val = 0; 690 while ((val < 7) && (speed < emu10k1_adcspeed[val])) 691 val++; 692 return (val); 693 } 694 695 static int 696 emu_k2_recval(int speed) 697 { 698 int val; 699 700 val = 0; 701 while ((val < 8) && (speed < emu10k2_adcspeed[val])) 702 val++; 703 return (val); 704 } 705 706 static void * 707 emupchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 708 { 709 struct emu_pcm_info *sc = devinfo; 710 struct emu_pcm_pchinfo *ch; 711 void *r; 712 713 KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction")); 714 KASSERT(sc->card != NULL, ("empchan_init: no soundcard")); 715 716 717 if (sc->pnum >= MAX_CHANNELS) 718 return (NULL); 719 ch = &(sc->pch[sc->pnum++]); 720 ch->buffer = b; 721 ch->pcm = sc; 722 ch->channel = c; 723 ch->blksz = sc->bufsz; 724 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0); 725 ch->spd = 8000; 726 ch->master = emu_valloc(sc->card); 727 /* 728 * XXX we have to allocate slave even for mono channel until we 729 * fix emu_vfree to handle this case. 730 */ 731 ch->slave = emu_valloc(sc->card); 732 ch->timer = emu_timer_create(sc->card); 733 r = (emu_vinit(sc->card, ch->master, ch->slave, EMU_PLAY_BUFSZ, ch->buffer)) ? NULL : ch; 734 return (r); 735 } 736 737 static int 738 emupchan_free(kobj_t obj __unused, void *c_devinfo) 739 { 740 struct emu_pcm_pchinfo *ch = c_devinfo; 741 struct emu_pcm_info *sc = ch->pcm; 742 743 emu_timer_clear(sc->card, ch->timer); 744 if (ch->slave != NULL) 745 emu_vfree(sc->card, ch->slave); 746 emu_vfree(sc->card, ch->master); 747 return (0); 748 } 749 750 static int 751 emupchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format) 752 { 753 struct emu_pcm_pchinfo *ch = c_devinfo; 754 755 ch->fmt = format; 756 return (0); 757 } 758 759 static uint32_t 760 emupchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 761 { 762 struct emu_pcm_pchinfo *ch = c_devinfo; 763 764 ch->spd = speed; 765 return (ch->spd); 766 } 767 768 static uint32_t 769 emupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 770 { 771 struct emu_pcm_pchinfo *ch = c_devinfo; 772 struct emu_pcm_info *sc = ch->pcm; 773 774 if (blocksize > ch->pcm->bufsz) 775 blocksize = ch->pcm->bufsz; 776 snd_mtxlock(sc->lock); 777 ch->blksz = blocksize; 778 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer)); 779 snd_mtxunlock(sc->lock); 780 return (ch->blksz); 781 } 782 783 static int 784 emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 785 { 786 struct emu_pcm_pchinfo *ch = c_devinfo; 787 struct emu_pcm_info *sc = ch->pcm; 788 789 if (!PCMTRIG_COMMON(go)) 790 return (0); 791 792 snd_mtxlock(sc->lock); /* XXX can we trigger on parallel threads ? */ 793 if (go == PCMTRIG_START) { 794 emu_vsetup(ch->master, ch->fmt, ch->spd); 795 if (AFMT_CHANNEL(ch->fmt) > 1) 796 emu_vroute(sc->card, &(sc->rt), ch->master); 797 else 798 emu_vroute(sc->card, &(sc->rt_mono), ch->master); 799 emu_vwrite(sc->card, ch->master); 800 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer)); 801 emu_timer_enable(sc->card, ch->timer, 1); 802 } 803 /* PCM interrupt handler will handle PCMTRIG_STOP event */ 804 ch->run = (go == PCMTRIG_START) ? 1 : 0; 805 emu_vtrigger(sc->card, ch->master, ch->run); 806 snd_mtxunlock(sc->lock); 807 return (0); 808 } 809 810 static uint32_t 811 emupchan_getptr(kobj_t obj __unused, void *c_devinfo) 812 { 813 struct emu_pcm_pchinfo *ch = c_devinfo; 814 struct emu_pcm_info *sc = ch->pcm; 815 int r; 816 817 r = emu_vpos(sc->card, ch->master); 818 819 return (r); 820 } 821 822 static struct pcmchan_caps * 823 emupchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused) 824 { 825 struct emu_pcm_pchinfo *ch = c_devinfo; 826 struct emu_pcm_info *sc = ch->pcm; 827 828 switch (sc->route) { 829 case RT_FRONT: 830 /* FALLTHROUGH */ 831 case RT_REAR: 832 /* FALLTHROUGH */ 833 case RT_SIDE: 834 return (&emu_playcaps); 835 break; 836 case RT_CENTER: 837 /* FALLTHROUGH */ 838 case RT_SUB: 839 return (&emu_playcaps_mono); 840 break; 841 } 842 return (NULL); 843 } 844 845 static kobj_method_t emupchan_methods[] = { 846 KOBJMETHOD(channel_init, emupchan_init), 847 KOBJMETHOD(channel_free, emupchan_free), 848 KOBJMETHOD(channel_setformat, emupchan_setformat), 849 KOBJMETHOD(channel_setspeed, emupchan_setspeed), 850 KOBJMETHOD(channel_setblocksize, emupchan_setblocksize), 851 KOBJMETHOD(channel_trigger, emupchan_trigger), 852 KOBJMETHOD(channel_getptr, emupchan_getptr), 853 KOBJMETHOD(channel_getcaps, emupchan_getcaps), 854 KOBJMETHOD_END 855 }; 856 CHANNEL_DECLARE(emupchan); 857 858 static void * 859 emurchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 860 { 861 struct emu_pcm_info *sc = devinfo; 862 struct emu_pcm_rchinfo *ch; 863 864 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction")); 865 ch = &sc->rch_adc; 866 ch->buffer = b; 867 ch->pcm = sc; 868 ch->channel = c; 869 ch->blksz = sc->bufsz / 2; /* We rise interrupt for half-full buffer */ 870 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0); 871 ch->spd = 8000; 872 ch->idxreg = sc->is_emu10k1 ? EMU_ADCIDX : EMU_A_ADCIDX; 873 ch->basereg = EMU_ADCBA; 874 ch->sizereg = EMU_ADCBS; 875 ch->setupreg = EMU_ADCCR; 876 ch->irqmask = EMU_INTE_ADCBUFENABLE; 877 ch->iprmask = EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL; 878 879 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0) 880 return (NULL); 881 else { 882 ch->timer = emu_timer_create(sc->card); 883 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer)); 884 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */ 885 return (ch); 886 } 887 } 888 889 static int 890 emurchan_free(kobj_t obj __unused, void *c_devinfo) 891 { 892 struct emu_pcm_rchinfo *ch = c_devinfo; 893 struct emu_pcm_info *sc = ch->pcm; 894 895 emu_timer_clear(sc->card, ch->timer); 896 return (0); 897 } 898 899 static int 900 emurchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format) 901 { 902 struct emu_pcm_rchinfo *ch = c_devinfo; 903 904 ch->fmt = format; 905 return (0); 906 } 907 908 static uint32_t 909 emurchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 910 { 911 struct emu_pcm_rchinfo *ch = c_devinfo; 912 913 if (ch->pcm->is_emu10k1) { 914 speed = emu10k1_adcspeed[emu_k1_recval(speed)]; 915 } else { 916 speed = emu10k2_adcspeed[emu_k2_recval(speed)]; 917 } 918 ch->spd = speed; 919 return (ch->spd); 920 } 921 922 static uint32_t 923 emurchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 924 { 925 struct emu_pcm_rchinfo *ch = c_devinfo; 926 struct emu_pcm_info *sc = ch->pcm; 927 928 ch->blksz = blocksize; 929 /* 930 * If blocksize is less than half of buffer size we will not get 931 * BUFHALFFULL interrupt in time and channel will need to generate 932 * (and use) timer interrupts. Otherwise channel will be marked dead. 933 */ 934 if (ch->blksz < (ch->pcm->bufsz / 2)) { 935 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer)); 936 emu_timer_enable(sc->card, ch->timer, 1); 937 } else { 938 emu_timer_enable(sc->card, ch->timer, 0); 939 } 940 return (ch->blksz); 941 } 942 943 static int 944 emurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 945 { 946 struct emu_pcm_rchinfo *ch = c_devinfo; 947 struct emu_pcm_info *sc = ch->pcm; 948 uint32_t val, sz; 949 950 if (!PCMTRIG_COMMON(go)) 951 return (0); 952 953 switch (sc->bufsz) { 954 case 4096: 955 sz = EMU_RECBS_BUFSIZE_4096; 956 break; 957 case 8192: 958 sz = EMU_RECBS_BUFSIZE_8192; 959 break; 960 case 16384: 961 sz = EMU_RECBS_BUFSIZE_16384; 962 break; 963 case 32768: 964 sz = EMU_RECBS_BUFSIZE_32768; 965 break; 966 case 65536: 967 sz = EMU_RECBS_BUFSIZE_65536; 968 break; 969 default: 970 sz = EMU_RECBS_BUFSIZE_4096; 971 } 972 973 snd_mtxlock(sc->lock); 974 switch (go) { 975 case PCMTRIG_START: 976 ch->run = 1; 977 emu_wrptr(sc->card, 0, ch->sizereg, sz); 978 val = sc->is_emu10k1 ? EMU_ADCCR_LCHANENABLE : EMU_A_ADCCR_LCHANENABLE; 979 if (AFMT_CHANNEL(ch->fmt) > 1) 980 val |= sc->is_emu10k1 ? EMU_ADCCR_RCHANENABLE : EMU_A_ADCCR_RCHANENABLE; 981 val |= sc->is_emu10k1 ? emu_k1_recval(ch->spd) : emu_k2_recval(ch->spd); 982 emu_wrptr(sc->card, 0, ch->setupreg, 0); 983 emu_wrptr(sc->card, 0, ch->setupreg, val); 984 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc); 985 break; 986 case PCMTRIG_STOP: 987 /* FALLTHROUGH */ 988 case PCMTRIG_ABORT: 989 ch->run = 0; 990 emu_wrptr(sc->card, 0, ch->sizereg, 0); 991 if (ch->setupreg) 992 emu_wrptr(sc->card, 0, ch->setupreg, 0); 993 (void)emu_intr_unregister(sc->card, ch->ihandle); 994 break; 995 case PCMTRIG_EMLDMAWR: 996 /* FALLTHROUGH */ 997 case PCMTRIG_EMLDMARD: 998 /* FALLTHROUGH */ 999 default: 1000 break; 1001 } 1002 snd_mtxunlock(sc->lock); 1003 1004 return (0); 1005 } 1006 1007 static uint32_t 1008 emurchan_getptr(kobj_t obj __unused, void *c_devinfo) 1009 { 1010 struct emu_pcm_rchinfo *ch = c_devinfo; 1011 struct emu_pcm_info *sc = ch->pcm; 1012 int r; 1013 1014 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff; 1015 1016 return (r); 1017 } 1018 1019 static struct pcmchan_caps * 1020 emurchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused) 1021 { 1022 return (&emu_reccaps_adc); 1023 } 1024 1025 static kobj_method_t emurchan_methods[] = { 1026 KOBJMETHOD(channel_init, emurchan_init), 1027 KOBJMETHOD(channel_free, emurchan_free), 1028 KOBJMETHOD(channel_setformat, emurchan_setformat), 1029 KOBJMETHOD(channel_setspeed, emurchan_setspeed), 1030 KOBJMETHOD(channel_setblocksize, emurchan_setblocksize), 1031 KOBJMETHOD(channel_trigger, emurchan_trigger), 1032 KOBJMETHOD(channel_getptr, emurchan_getptr), 1033 KOBJMETHOD(channel_getcaps, emurchan_getcaps), 1034 KOBJMETHOD_END 1035 }; 1036 CHANNEL_DECLARE(emurchan); 1037 1038 static void * 1039 emufxrchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 1040 { 1041 struct emu_pcm_info *sc = devinfo; 1042 struct emu_pcm_rchinfo *ch; 1043 1044 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction")); 1045 1046 if (sc == NULL) return (NULL); 1047 1048 ch = &(sc->rch_efx); 1049 ch->fmt = SND_FORMAT(AFMT_S16_LE, 1, 0); 1050 ch->spd = sc->is_emu10k1 ? 48000*32 : 48000 * 64; 1051 ch->idxreg = EMU_FXIDX; 1052 ch->basereg = EMU_FXBA; 1053 ch->sizereg = EMU_FXBS; 1054 ch->irqmask = EMU_INTE_EFXBUFENABLE; 1055 ch->iprmask = EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL; 1056 ch->buffer = b; 1057 ch->pcm = sc; 1058 ch->channel = c; 1059 ch->blksz = sc->bufsz / 2; 1060 1061 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0) 1062 return (NULL); 1063 else { 1064 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer)); 1065 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */ 1066 return (ch); 1067 } 1068 } 1069 1070 static int 1071 emufxrchan_setformat(kobj_t obj __unused, void *c_devinfo __unused, uint32_t format) 1072 { 1073 if (format == SND_FORMAT(AFMT_S16_LE, 1, 0)) return (0); 1074 return (EINVAL); 1075 } 1076 1077 static uint32_t 1078 emufxrchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 1079 { 1080 struct emu_pcm_rchinfo *ch = c_devinfo; 1081 1082 /* FIXED RATE CHANNEL */ 1083 return (ch->spd); 1084 } 1085 1086 static uint32_t 1087 emufxrchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 1088 { 1089 struct emu_pcm_rchinfo *ch = c_devinfo; 1090 1091 ch->blksz = blocksize; 1092 /* 1093 * XXX If blocksize is less than half of buffer size we will not get 1094 * interrupt in time and channel will die due to interrupt timeout. 1095 * This should not happen with FX rchan, because it will fill buffer 1096 * very fast (64K buffer is 0.021seconds on Audigy). 1097 */ 1098 if (ch->blksz < (ch->pcm->bufsz / 2)) 1099 ch->blksz = ch->pcm->bufsz / 2; 1100 return (ch->blksz); 1101 } 1102 1103 static int 1104 emufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 1105 { 1106 struct emu_pcm_rchinfo *ch = c_devinfo; 1107 struct emu_pcm_info *sc = ch->pcm; 1108 uint32_t sz; 1109 1110 if (!PCMTRIG_COMMON(go)) 1111 return (0); 1112 1113 switch (sc->bufsz) { 1114 case 4096: 1115 sz = EMU_RECBS_BUFSIZE_4096; 1116 break; 1117 case 8192: 1118 sz = EMU_RECBS_BUFSIZE_8192; 1119 break; 1120 case 16384: 1121 sz = EMU_RECBS_BUFSIZE_16384; 1122 break; 1123 case 32768: 1124 sz = EMU_RECBS_BUFSIZE_32768; 1125 break; 1126 case 65536: 1127 sz = EMU_RECBS_BUFSIZE_65536; 1128 break; 1129 default: 1130 sz = EMU_RECBS_BUFSIZE_4096; 1131 } 1132 1133 snd_mtxlock(sc->lock); 1134 switch (go) { 1135 case PCMTRIG_START: 1136 ch->run = 1; 1137 emu_wrptr(sc->card, 0, ch->sizereg, sz); 1138 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc); 1139 /* 1140 * SB Live! is limited to 32 mono channels. Audigy 1141 * has 64 mono channels. Channels are enabled 1142 * by setting a bit in EMU_A_FXWC[1|2] registers. 1143 */ 1144 /* XXX there is no way to demultiplex this streams for now */ 1145 if (sc->is_emu10k1) { 1146 emu_wrptr(sc->card, 0, EMU_FXWC, 0xffffffff); 1147 } else { 1148 emu_wrptr(sc->card, 0, EMU_A_FXWC1, 0xffffffff); 1149 emu_wrptr(sc->card, 0, EMU_A_FXWC2, 0xffffffff); 1150 } 1151 break; 1152 case PCMTRIG_STOP: 1153 /* FALLTHROUGH */ 1154 case PCMTRIG_ABORT: 1155 ch->run = 0; 1156 if (sc->is_emu10k1) { 1157 emu_wrptr(sc->card, 0, EMU_FXWC, 0x0); 1158 } else { 1159 emu_wrptr(sc->card, 0, EMU_A_FXWC1, 0x0); 1160 emu_wrptr(sc->card, 0, EMU_A_FXWC2, 0x0); 1161 } 1162 emu_wrptr(sc->card, 0, ch->sizereg, 0); 1163 (void)emu_intr_unregister(sc->card, ch->ihandle); 1164 break; 1165 case PCMTRIG_EMLDMAWR: 1166 /* FALLTHROUGH */ 1167 case PCMTRIG_EMLDMARD: 1168 /* FALLTHROUGH */ 1169 default: 1170 break; 1171 } 1172 snd_mtxunlock(sc->lock); 1173 1174 return (0); 1175 } 1176 1177 static uint32_t 1178 emufxrchan_getptr(kobj_t obj __unused, void *c_devinfo) 1179 { 1180 struct emu_pcm_rchinfo *ch = c_devinfo; 1181 struct emu_pcm_info *sc = ch->pcm; 1182 int r; 1183 1184 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff; 1185 1186 return (r); 1187 } 1188 1189 static struct pcmchan_caps * 1190 emufxrchan_getcaps(kobj_t obj __unused, void *c_devinfo) 1191 { 1192 struct emu_pcm_rchinfo *ch = c_devinfo; 1193 struct emu_pcm_info *sc = ch->pcm; 1194 1195 if (sc->is_emu10k1) 1196 return (&emu_reccaps_efx_live); 1197 return (&emu_reccaps_efx_audigy); 1198 1199 } 1200 1201 static int 1202 emufxrchan_getrates(kobj_t obj __unused, void *c_devinfo, int **rates) 1203 { 1204 struct emu_pcm_rchinfo *ch = c_devinfo; 1205 struct emu_pcm_info *sc = ch->pcm; 1206 1207 if (sc->is_emu10k1) 1208 *rates = emu_rates_live; 1209 else 1210 *rates = emu_rates_audigy; 1211 1212 return 1; 1213 } 1214 1215 static kobj_method_t emufxrchan_methods[] = { 1216 KOBJMETHOD(channel_init, emufxrchan_init), 1217 KOBJMETHOD(channel_setformat, emufxrchan_setformat), 1218 KOBJMETHOD(channel_setspeed, emufxrchan_setspeed), 1219 KOBJMETHOD(channel_setblocksize, emufxrchan_setblocksize), 1220 KOBJMETHOD(channel_trigger, emufxrchan_trigger), 1221 KOBJMETHOD(channel_getptr, emufxrchan_getptr), 1222 KOBJMETHOD(channel_getcaps, emufxrchan_getcaps), 1223 KOBJMETHOD(channel_getrates, emufxrchan_getrates), 1224 KOBJMETHOD_END 1225 }; 1226 CHANNEL_DECLARE(emufxrchan); 1227 1228 1229 static uint32_t 1230 emu_pcm_intr(void *pcm, uint32_t stat) 1231 { 1232 struct emu_pcm_info *sc = (struct emu_pcm_info *)pcm; 1233 uint32_t ack; 1234 int i; 1235 1236 ack = 0; 1237 1238 snd_mtxlock(sc->lock); 1239 1240 if (stat & EMU_IPR_INTERVALTIMER) { 1241 ack |= EMU_IPR_INTERVALTIMER; 1242 for (i = 0; i < MAX_CHANNELS; i++) 1243 if (sc->pch[i].channel) { 1244 if (sc->pch[i].run == 1) { 1245 snd_mtxunlock(sc->lock); 1246 chn_intr(sc->pch[i].channel); 1247 snd_mtxlock(sc->lock); 1248 } else 1249 emu_timer_enable(sc->card, sc->pch[i].timer, 0); 1250 } 1251 /* ADC may install timer to get low-latency interrupts */ 1252 if ((sc->rch_adc.channel) && (sc->rch_adc.run)) { 1253 snd_mtxunlock(sc->lock); 1254 chn_intr(sc->rch_adc.channel); 1255 snd_mtxlock(sc->lock); 1256 } 1257 /* 1258 * EFX does not use timer, because it will fill 1259 * buffer at least 32x times faster than ADC. 1260 */ 1261 } 1262 1263 1264 if (stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL)) { 1265 ack |= stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL); 1266 if (sc->rch_adc.channel) { 1267 snd_mtxunlock(sc->lock); 1268 chn_intr(sc->rch_adc.channel); 1269 snd_mtxlock(sc->lock); 1270 } 1271 } 1272 1273 if (stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL)) { 1274 ack |= stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL); 1275 if (sc->rch_efx.channel) { 1276 snd_mtxunlock(sc->lock); 1277 chn_intr(sc->rch_efx.channel); 1278 snd_mtxlock(sc->lock); 1279 } 1280 } 1281 snd_mtxunlock(sc->lock); 1282 1283 return (ack); 1284 } 1285 1286 static int 1287 emu_pcm_init(struct emu_pcm_info *sc) 1288 { 1289 sc->bufsz = pcm_getbuffersize(sc->dev, EMUPAGESIZE, EMU_REC_BUFSZ, EMU_MAX_BUFSZ); 1290 return (0); 1291 } 1292 1293 static int 1294 emu_pcm_uninit(struct emu_pcm_info *sc __unused) 1295 { 1296 return (0); 1297 } 1298 1299 static int 1300 emu_pcm_probe(device_t dev) 1301 { 1302 uintptr_t func, route, r; 1303 const char *rt; 1304 char buffer[255]; 1305 1306 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_FUNC, &func); 1307 1308 if (func != SCF_PCM) 1309 return (ENXIO); 1310 1311 rt = "UNKNOWN"; 1312 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route); 1313 switch (route) { 1314 case RT_FRONT: 1315 rt = "front"; 1316 break; 1317 case RT_REAR: 1318 rt = "rear"; 1319 break; 1320 case RT_CENTER: 1321 rt = "center"; 1322 break; 1323 case RT_SUB: 1324 rt = "subwoofer"; 1325 break; 1326 case RT_SIDE: 1327 rt = "side"; 1328 break; 1329 case RT_MCHRECORD: 1330 rt = "multichannel recording"; 1331 break; 1332 } 1333 1334 ksnprintf(buffer, 255, "EMU10Kx DSP %s PCM interface", rt); 1335 device_set_desc_copy(dev, buffer); 1336 return (0); 1337 } 1338 1339 static int 1340 emu_pcm_attach(device_t dev) 1341 { 1342 struct emu_pcm_info *sc; 1343 unsigned int i; 1344 char status[SND_STATUSLEN]; 1345 uint32_t inte, ipr; 1346 uintptr_t route, r, ivar; 1347 1348 sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO); 1349 sc->card = (struct emu_sc_info *)(device_get_softc(device_get_parent(dev))); 1350 if (sc->card == NULL) { 1351 device_printf(dev, "cannot get bridge conf\n"); 1352 kfree(sc, M_DEVBUF); 1353 return (ENXIO); 1354 } 1355 1356 sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10kx pcm softc"); 1357 sc->dev = dev; 1358 1359 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ISEMU10K1, &ivar); 1360 sc->is_emu10k1 = ivar ? 1 : 0; 1361 1362 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_MCH_DISABLED, &ivar); 1363 sc->mch_disabled = ivar ? 1 : 0; 1364 1365 sc->codec = NULL; 1366 1367 for (i = 0; i < 8; i++) { 1368 sc->rt.routing_left[i] = i; 1369 sc->rt.amounts_left[i] = 0x00; 1370 sc->rt.routing_right[i] = i; 1371 sc->rt.amounts_right[i] = 0x00; 1372 } 1373 1374 for (i = 0; i < 8; i++) { 1375 sc->rt_mono.routing_left[i] = i; 1376 sc->rt_mono.amounts_left[i] = 0x00; 1377 sc->rt_mono.routing_right[i] = i; 1378 sc->rt_mono.amounts_right[i] = 0x00; 1379 } 1380 1381 sc->emu10k1_volcache[0][0] = 75; 1382 sc->emu10k1_volcache[1][0] = 75; 1383 sc->emu10k1_volcache[0][1] = 75; 1384 sc->emu10k1_volcache[1][1] = 75; 1385 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route); 1386 sc->route = route; 1387 switch (route) { 1388 case RT_FRONT: 1389 sc->rt.amounts_left[0] = 0xff; 1390 sc->rt.amounts_right[1] = 0xff; 1391 sc->rt_mono.amounts_left[0] = 0xff; 1392 sc->rt_mono.amounts_left[1] = 0xff; 1393 if (sc->is_emu10k1) 1394 sc->codec = AC97_CREATE(dev, sc, emu_ac97); 1395 else 1396 sc->codec = AC97_CREATE(dev, sc, emu_eac97); 1397 sc->ac97_mixerclass = NULL; 1398 if (sc->codec != NULL) 1399 sc->ac97_mixerclass = ac97_getmixerclass(); 1400 if (mixer_init(dev, &emudspmixer_class, sc)) { 1401 device_printf(dev, "failed to initialize DSP mixer\n"); 1402 goto bad; 1403 } 1404 break; 1405 case RT_REAR: 1406 sc->rt.amounts_left[2] = 0xff; 1407 sc->rt.amounts_right[3] = 0xff; 1408 sc->rt_mono.amounts_left[2] = 0xff; 1409 sc->rt_mono.amounts_left[3] = 0xff; 1410 if (mixer_init(dev, &emudspmixer_class, sc)) { 1411 device_printf(dev, "failed to initialize mixer\n"); 1412 goto bad; 1413 } 1414 break; 1415 case RT_CENTER: 1416 sc->rt.amounts_left[4] = 0xff; 1417 sc->rt_mono.amounts_left[4] = 0xff; 1418 if (mixer_init(dev, &emudspmixer_class, sc)) { 1419 device_printf(dev, "failed to initialize mixer\n"); 1420 goto bad; 1421 } 1422 break; 1423 case RT_SUB: 1424 sc->rt.amounts_left[5] = 0xff; 1425 sc->rt_mono.amounts_left[5] = 0xff; 1426 if (mixer_init(dev, &emudspmixer_class, sc)) { 1427 device_printf(dev, "failed to initialize mixer\n"); 1428 goto bad; 1429 } 1430 break; 1431 case RT_SIDE: 1432 sc->rt.amounts_left[6] = 0xff; 1433 sc->rt.amounts_right[7] = 0xff; 1434 sc->rt_mono.amounts_left[6] = 0xff; 1435 sc->rt_mono.amounts_left[7] = 0xff; 1436 if (mixer_init(dev, &emudspmixer_class, sc)) { 1437 device_printf(dev, "failed to initialize mixer\n"); 1438 goto bad; 1439 } 1440 break; 1441 case RT_MCHRECORD: 1442 if (mixer_init(dev, &emuefxmixer_class, sc)) { 1443 device_printf(dev, "failed to initialize EFX mixer\n"); 1444 goto bad; 1445 } 1446 break; 1447 default: 1448 device_printf(dev, "invalid default route\n"); 1449 goto bad; 1450 } 1451 1452 inte = EMU_INTE_INTERTIMERENB; 1453 ipr = EMU_IPR_INTERVALTIMER; /* Used by playback & ADC */ 1454 sc->ihandle = emu_intr_register(sc->card, inte, ipr, &emu_pcm_intr, sc); 1455 1456 if (emu_pcm_init(sc) == -1) { 1457 device_printf(dev, "unable to initialize PCM part of the card\n"); 1458 goto bad; 1459 } 1460 1461 /* 1462 * We don't register interrupt handler with snd_setup_intr 1463 * in pcm device. Mark pcm device as MPSAFE manually. 1464 */ 1465 pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE); 1466 1467 /* XXX we should better get number of available channels from parent */ 1468 if (pcm_register(dev, sc, (route == RT_FRONT) ? MAX_CHANNELS : 1, (route == RT_FRONT) ? 1 : 0)) { 1469 device_printf(dev, "can't register PCM channels!\n"); 1470 goto bad; 1471 } 1472 sc->pnum = 0; 1473 if (route != RT_MCHRECORD) 1474 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc); 1475 if (route == RT_FRONT) { 1476 for (i = 1; i < MAX_CHANNELS; i++) 1477 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc); 1478 pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc); 1479 } 1480 if (route == RT_MCHRECORD) 1481 pcm_addchan(dev, PCMDIR_REC, &emufxrchan_class, sc); 1482 1483 ksnprintf(status, SND_STATUSLEN, "on %s", 1484 device_get_nameunit(device_get_parent(dev))); 1485 pcm_setstatus(dev, status); 1486 1487 return (0); 1488 1489 bad: 1490 if (sc->codec) 1491 ac97_destroy(sc->codec); 1492 if (sc->lock) 1493 snd_mtxfree(sc->lock); 1494 kfree(sc, M_DEVBUF); 1495 return (ENXIO); 1496 } 1497 1498 static int 1499 emu_pcm_detach(device_t dev) 1500 { 1501 int r; 1502 struct emu_pcm_info *sc; 1503 1504 sc = pcm_getdevinfo(dev); 1505 1506 r = pcm_unregister(dev); 1507 1508 if (r) return (r); 1509 1510 emu_pcm_uninit(sc); 1511 1512 if (sc->lock) 1513 snd_mtxfree(sc->lock); 1514 kfree(sc, M_DEVBUF); 1515 1516 return (0); 1517 } 1518 1519 static device_method_t emu_pcm_methods[] = { 1520 DEVMETHOD(device_probe, emu_pcm_probe), 1521 DEVMETHOD(device_attach, emu_pcm_attach), 1522 DEVMETHOD(device_detach, emu_pcm_detach), 1523 1524 DEVMETHOD_END 1525 }; 1526 1527 static driver_t emu_pcm_driver = { 1528 "pcm", 1529 emu_pcm_methods, 1530 PCM_SOFTC_SIZE, 1531 NULL, 1532 0, 1533 NULL 1534 }; 1535 DRIVER_MODULE(snd_emu10kx_pcm, emu10kx, emu_pcm_driver, pcm_devclass, NULL, NULL); 1536 MODULE_DEPEND(snd_emu10kx_pcm, snd_emu10kx, SND_EMU10KX_MINVER, SND_EMU10KX_PREFVER, SND_EMU10KX_MAXVER); 1537 MODULE_DEPEND(snd_emu10kx_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 1538 MODULE_VERSION(snd_emu10kx_pcm, SND_EMU10KX_PREFVER); 1539