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