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