emu10kx-pcm.c revision 167608
1/*- 2 * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk> 3 * Copyright (c) 2003-2006 Yuriy Tsibizov <yuriy.tsibizov@gfk.ru> 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: head/sys/dev/sound/pci/emu10kx-pcm.c 167608 2007-03-15 16:41:27Z ariff $ 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 "opt_emu10kx.h" 49#include <dev/sound/pci/emu10kx.h> 50#include "emu10k1-alsa%diked.h" 51 52struct emu_pcm_pchinfo { 53 int spd; 54 int fmt; 55 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 65struct emu_pcm_rchinfo { 66 int spd; 67 int fmt; 68 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}; 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 89struct emu_pcm_info { 90 struct mtx *lock; 91 device_t dev; /* device information */ 92 struct snddev_info *devinfo; /* pcm 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}; 107 108 109static uint32_t emu_rfmt_adc[] = { 110 AFMT_S16_LE, 111 AFMT_STEREO | AFMT_S16_LE, 112 0 113}; 114static struct pcmchan_caps emu_reccaps_adc = { 115 8000, 48000, emu_rfmt_adc, 0 116}; 117 118static uint32_t emu_rfmt_efx[] = { 119 AFMT_S16_LE, 120 0 121}; 122 123static struct pcmchan_caps emu_reccaps_efx_live = { 124 48000*32, 48000*32, emu_rfmt_efx, 0 125}; 126 127static struct pcmchan_caps emu_reccaps_efx_audigy = { 128 48000*64, 48000*64, emu_rfmt_efx, 0 129}; 130 131static uint32_t emu_pfmt[] = { 132 AFMT_U8, 133 AFMT_STEREO | AFMT_U8, 134 AFMT_S16_LE, 135 AFMT_STEREO | AFMT_S16_LE, 136 0 137}; 138static uint32_t emu_pfmt_mono[] = { 139 AFMT_U8, 140 AFMT_S16_LE, 141 0 142}; 143 144static struct pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0}; 145static struct pcmchan_caps emu_playcaps_mono = {4000, 48000, emu_pfmt_mono, 0}; 146 147static int emu10k1_adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000}; 148/* audigy supports 12kHz. */ 149static int emu10k2_adcspeed[9] = {48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000}; 150 151static uint32_t emu_pcm_intr(void *pcm, uint32_t stat); 152 153static const struct emu_dspmix_props { 154 u_int8_t present; 155} dspmix [SOUND_MIXER_NRDEVICES] = { 156 [SOUND_MIXER_VOLUME] = {1}, 157 [SOUND_MIXER_PCM] = {1}, 158}; 159 160static int 161emu_dspmixer_init(struct snd_mixer *m) 162{ 163 int i; 164 int v; 165 166 v = 0; 167 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 168 if (dspmix[i].present) 169 v |= 1 << i; 170 } 171 mix_setdevs(m, v); 172 173 mix_setrecdevs(m, 0); 174 return (0); 175} 176 177static int 178emu_dspmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 179{ 180 struct emu_pcm_info *sc; 181 182 sc = mix_getdevinfo(m); 183 184 switch (dev) { 185 case SOUND_MIXER_VOLUME: 186 switch (sc->route) { 187 case RT_REAR: 188 emumix_set_volume(sc->card, M_MASTER_REAR_L, left); 189 emumix_set_volume(sc->card, M_MASTER_REAR_R, right); 190 break; 191 case RT_CENTER: 192 emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2); 193 break; 194 case RT_SUB: 195 emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2); 196 break; 197 } 198 break; 199 case SOUND_MIXER_PCM: 200 switch (sc->route) { 201 case RT_REAR: 202 emumix_set_volume(sc->card, M_FX2_REAR_L, left); 203 emumix_set_volume(sc->card, M_FX3_REAR_R, right); 204 break; 205 case RT_CENTER: 206 emumix_set_volume(sc->card, M_FX4_CENTER, (left+right)/2); 207 break; 208 case RT_SUB: 209 emumix_set_volume(sc->card, M_FX5_SUBWOOFER, (left+right)/2); 210 break; 211 } 212 break; 213 default: 214 device_printf(sc->dev, "mixer error: unknown device %d\n", dev); 215 } 216 return (0); 217} 218 219static int 220emu_dspmixer_setrecsrc(struct snd_mixer *m __unused, u_int32_t src __unused) 221{ 222 return (0); 223} 224 225static kobj_method_t emudspmixer_methods[] = { 226 KOBJMETHOD(mixer_init, emu_dspmixer_init), 227 KOBJMETHOD(mixer_set, emu_dspmixer_set), 228 KOBJMETHOD(mixer_setrecsrc, emu_dspmixer_setrecsrc), 229 { 0, 0 } 230}; 231MIXER_DECLARE(emudspmixer); 232 233/* 234 * AC97 emulation code for Audigy and later cards. 235 * Some parts of AC97 codec are not used by hardware, but can be used 236 * to change some DSP controls via AC97 mixer interface. This includes: 237 * - master volume controls MASTER_FRONT_[R|L] 238 * - pcm volume controls FX[0|1]_FRONT_[R|L] 239 * - rec volume controls MASTER_REC_[R|L] 240 * We do it because we need to put it under user control.... 241 * We also keep some parts of AC97 disabled to get better sound quality 242 */ 243 244#define AC97LEFT(x) ((x & 0x7F00)>>8) 245#define AC97RIGHT(x) (x & 0x007F) 246#define AC97MUTE(x) ((x & 0x8000)>>15) 247#define BIT4_TO100(x) (100-(x)*100/(0x0f)) 248#define BIT6_TO100(x) (100-(x)*100/(0x3f)) 249#define BIT4_TO255(x) (255-(x)*255/(0x0f)) 250#define BIT6_TO255(x) (255-(x)*255/(0x3f)) 251#define V100_TOBIT6(x) (0x3f*(100-x)/100) 252#define V100_TOBIT4(x) (0x0f*(100-x)/100) 253#define AC97ENCODE(x_muted,x_left,x_right) (((x_muted&1)<<15) | ((x_left&0x3f)<<8) | (x_right&0x3f)) 254 255static int 256emu_ac97_read_emulation(struct emu_pcm_info *sc, int regno) 257{ 258 int use_ac97; 259 int emulated; 260 int tmp; 261 262 use_ac97 = 1; 263 emulated = 0; 264 265 switch (regno) { 266 case AC97_MIX_MASTER: 267 emulated = sc->ac97_state[AC97_MIX_MASTER]; 268 use_ac97 = 0; 269 break; 270 case AC97_MIX_PCM: 271 emulated = sc->ac97_state[AC97_MIX_PCM]; 272 use_ac97 = 0; 273 break; 274 case AC97_REG_RECSEL: 275 emulated = 0x0505; 276 use_ac97 = 0; 277 break; 278 case AC97_MIX_RGAIN: 279 emulated = sc->ac97_state[AC97_MIX_RGAIN]; 280 use_ac97 = 0; 281 break; 282 } 283 284 emu_wr(sc->card, AC97ADDRESS, regno, 1); 285 tmp = emu_rd(sc->card, AC97DATA, 2); 286 287 if (use_ac97) 288 emulated = tmp; 289 290 return (emulated); 291} 292 293static void 294emu_ac97_write_emulation(struct emu_pcm_info *sc, int regno, uint32_t data) 295{ 296 int write_ac97; 297 int left, right; 298 uint32_t emu_left, emu_right; 299 int is_mute; 300 301 write_ac97 = 1; 302 303 left = AC97LEFT(data); 304 emu_left = BIT6_TO100(left); /* We show us as 6-bit AC97 mixer */ 305 right = AC97RIGHT(data); 306 emu_right = BIT6_TO100(right); 307 is_mute = AC97MUTE(data); 308 if (is_mute) 309 emu_left = emu_right = 0; 310 311 switch (regno) { 312 /* TODO: reset emulator on AC97_RESET */ 313 case AC97_MIX_MASTER: 314 emumix_set_volume(sc->card, M_MASTER_FRONT_L, emu_left); 315 emumix_set_volume(sc->card, M_MASTER_FRONT_R, emu_right); 316 sc->ac97_state[AC97_MIX_MASTER] = data & (0x8000 | 0x3f3f); 317 data = 0x8000; /* Mute AC97 main out */ 318 break; 319 case AC97_MIX_PCM: /* PCM OUT VOL */ 320 emumix_set_volume(sc->card, M_FX0_FRONT_L, emu_left); 321 emumix_set_volume(sc->card, M_FX1_FRONT_R, emu_right); 322 sc->ac97_state[AC97_MIX_PCM] = data & (0x8000 | 0x3f3f); 323 data = 0x8000; /* Mute AC97 PCM out */ 324 break; 325 case AC97_REG_RECSEL: 326 /* 327 * PCM recording source is set to "stereo mix" (labeled "vol" 328 * in mixer) XXX !I can't remember why! 329 */ 330 data = 0x0505; 331 break; 332 case AC97_MIX_RGAIN: /* RECORD GAIN */ 333 emu_left = BIT4_TO100(left); /* rgain is 4-bit */ 334 emu_right = BIT4_TO100(right); 335 emumix_set_volume(sc->card, M_MASTER_REC_L, 100-emu_left); 336 emumix_set_volume(sc->card, M_MASTER_REC_R, 100-emu_right); 337 /* 338 * Record gain on AC97 should stay zero to get AC97 sound on 339 * AC97_[RL] connectors on EMU10K2 chip. AC97 on Audigy is not 340 * directly connected to any output, only to EMU10K2 chip Use 341 * this control to set AC97 mix volume inside EMU10K2 chip 342 */ 343 sc->ac97_state[AC97_MIX_RGAIN] = data & (0x8000 | 0x0f0f); 344 data = 0x0000; 345 break; 346 } 347 if (write_ac97) { 348 emu_wr(sc->card, AC97ADDRESS, regno, 1); 349 emu_wr(sc->card, AC97DATA, data, 2); 350 } 351} 352 353static int 354emu_erdcd(kobj_t obj __unused, void *devinfo, int regno) 355{ 356 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 357 358 return (emu_ac97_read_emulation(sc, regno)); 359} 360 361static int 362emu_ewrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data) 363{ 364 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 365 366 emu_ac97_write_emulation(sc, regno, data); 367 return (0); 368} 369 370static kobj_method_t emu_eac97_methods[] = { 371 KOBJMETHOD(ac97_read, emu_erdcd), 372 KOBJMETHOD(ac97_write, emu_ewrcd), 373 {0, 0} 374}; 375AC97_DECLARE(emu_eac97); 376 377/* real ac97 codec */ 378static int 379emu_rdcd(kobj_t obj __unused, void *devinfo, int regno) 380{ 381 int rd; 382 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 383 384 KASSERT(sc->card != NULL, ("emu_rdcd: no soundcard")); 385 emu_wr(sc->card, AC97ADDRESS, regno, 1); 386 rd = emu_rd(sc->card, AC97DATA, 2); 387 return (rd); 388} 389 390static int 391emu_wrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data) 392{ 393 struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 394 395 KASSERT(sc->card != NULL, ("emu_wrcd: no soundcard")); 396 emu_wr(sc->card, AC97ADDRESS, regno, 1); 397 emu_wr(sc->card, AC97DATA, data, 2); 398 return (0); 399} 400 401static kobj_method_t emu_ac97_methods[] = { 402 KOBJMETHOD(ac97_read, emu_rdcd), 403 KOBJMETHOD(ac97_write, emu_wrcd), 404 {0, 0} 405}; 406AC97_DECLARE(emu_ac97); 407 408 409static int 410emu_k1_recval(int speed) 411{ 412 int val; 413 414 val = 0; 415 while ((val < 7) && (speed < emu10k1_adcspeed[val])) 416 val++; 417 if (val == 6) val=5; /* XXX 8kHz does not work */ 418 return (val); 419} 420 421static int 422emu_k2_recval(int speed) 423{ 424 int val; 425 426 val = 0; 427 while ((val < 8) && (speed < emu10k2_adcspeed[val])) 428 val++; 429 if (val == 7) val=6; /* XXX 8kHz does not work */ 430 return (val); 431} 432 433static void * 434emupchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 435{ 436 struct emu_pcm_info *sc = devinfo; 437 struct emu_pcm_pchinfo *ch; 438 void *r; 439 440 KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction")); 441 KASSERT(sc->card != NULL, ("empchan_init: no soundcard")); 442 443 444 if (sc->pnum >= MAX_CHANNELS) 445 return (NULL); 446 ch = &(sc->pch[sc->pnum++]); 447 ch->buffer = b; 448 ch->pcm = sc; 449 ch->channel = c; 450 ch->blksz = sc->bufsz; 451 ch->fmt = AFMT_U8; 452 ch->spd = 8000; 453 ch->master = emu_valloc(sc->card); 454 /* 455 * XXX we have to allocate slave even for mono channel until we 456 * fix emu_vfree to handle this case. 457 */ 458 ch->slave = emu_valloc(sc->card); 459 ch->timer = emu_timer_create(sc->card); 460 r = (emu_vinit(sc->card, ch->master, ch->slave, EMU_PLAY_BUFSZ, ch->buffer)) ? NULL : ch; 461 return (r); 462} 463 464static int 465emupchan_free(kobj_t obj __unused, void *c_devinfo) 466{ 467 struct emu_pcm_pchinfo *ch = c_devinfo; 468 struct emu_pcm_info *sc = ch->pcm; 469 470 emu_timer_clear(sc->card, ch->timer); 471 if (ch->slave != NULL) 472 emu_vfree(sc->card, ch->slave); 473 emu_vfree(sc->card, ch->master); 474 return (0); 475} 476 477static int 478emupchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format) 479{ 480 struct emu_pcm_pchinfo *ch = c_devinfo; 481 482 ch->fmt = format; 483 return (0); 484} 485 486static int 487emupchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 488{ 489 struct emu_pcm_pchinfo *ch = c_devinfo; 490 491 ch->spd = speed; 492 return (ch->spd); 493} 494 495static int 496emupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 497{ 498 struct emu_pcm_pchinfo *ch = c_devinfo; 499 struct emu_pcm_info *sc = ch->pcm; 500 501 if (blocksize > ch->pcm->bufsz) 502 blocksize = ch->pcm->bufsz; 503 snd_mtxlock(sc->lock); 504 ch->blksz = blocksize; 505 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getbps(ch->buffer)); 506 snd_mtxunlock(sc->lock); 507 return (blocksize); 508} 509 510static int 511emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 512{ 513 struct emu_pcm_pchinfo *ch = c_devinfo; 514 struct emu_pcm_info *sc = ch->pcm; 515 516 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD) 517 return (0); 518 snd_mtxlock(sc->lock); /* XXX can we trigger on parallel threads ? */ 519 if (go == PCMTRIG_START) { 520 emu_vsetup(ch->master, ch->fmt, ch->spd); 521 if ((ch->fmt & AFMT_STEREO) == AFMT_STEREO) 522 emu_vroute(sc->card, &(sc->rt), ch->master); 523 else 524 emu_vroute(sc->card, &(sc->rt_mono), ch->master); 525 emu_vwrite(sc->card, ch->master); 526 emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getbps(ch->buffer)); 527 emu_timer_enable(sc->card, ch->timer, 1); 528 } 529 /* PCM interrupt handler will handle PCMTRIG_STOP event */ 530 ch->run = (go == PCMTRIG_START) ? 1 : 0; 531 emu_vtrigger(sc->card, ch->master, ch->run); 532 snd_mtxunlock(sc->lock); 533 return (0); 534} 535 536static int 537emupchan_getptr(kobj_t obj __unused, void *c_devinfo) 538{ 539 struct emu_pcm_pchinfo *ch = c_devinfo; 540 struct emu_pcm_info *sc = ch->pcm; 541 int r; 542 543 r = emu_vpos(sc->card, ch->master); 544 545 return (r); 546} 547 548static struct pcmchan_caps * 549emupchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused) 550{ 551 struct emu_pcm_pchinfo *ch = c_devinfo; 552 struct emu_pcm_info *sc = ch->pcm; 553 554 switch (sc->route) { 555 case RT_FRONT: 556 /* FALLTHROUGH */ 557 case RT_REAR: 558 /* FALLTHROUGH */ 559 case RT_SIDE: 560 return (&emu_playcaps); 561 break; 562 case RT_CENTER: 563 /* FALLTHROUGH */ 564 case RT_SUB: 565 return (&emu_playcaps_mono); 566 break; 567 } 568 return (NULL); 569} 570 571static kobj_method_t emupchan_methods[] = { 572 KOBJMETHOD(channel_init, emupchan_init), 573 KOBJMETHOD(channel_free, emupchan_free), 574 KOBJMETHOD(channel_setformat, emupchan_setformat), 575 KOBJMETHOD(channel_setspeed, emupchan_setspeed), 576 KOBJMETHOD(channel_setblocksize, emupchan_setblocksize), 577 KOBJMETHOD(channel_trigger, emupchan_trigger), 578 KOBJMETHOD(channel_getptr, emupchan_getptr), 579 KOBJMETHOD(channel_getcaps, emupchan_getcaps), 580 {0, 0} 581}; 582CHANNEL_DECLARE(emupchan); 583 584static void * 585emurchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 586{ 587 struct emu_pcm_info *sc = devinfo; 588 struct emu_pcm_rchinfo *ch; 589 590 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction")); 591 ch = &sc->rch_adc; 592 ch->buffer = b; 593 ch->pcm = sc; 594 ch->channel = c; 595 ch->blksz = sc->bufsz / 2; /* We rise interrupt for half-full buffer */ 596 ch->fmt = AFMT_U8; 597 ch->spd = 8000; 598 ch->idxreg = sc->is_emu10k1 ? ADCIDX : A_ADCIDX; 599 ch->basereg = ADCBA; 600 ch->sizereg = ADCBS; 601 ch->setupreg = ADCCR; 602 ch->irqmask = INTE_ADCBUFENABLE; 603 ch->iprmask = IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL; 604 605 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), sc->bufsz) != 0) 606 return (NULL); 607 else { 608 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer)); 609 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */ 610 return (ch); 611 } 612} 613 614static int 615emurchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format) 616{ 617 struct emu_pcm_rchinfo *ch = c_devinfo; 618 619 ch->fmt = format; 620 return (0); 621} 622 623static int 624emurchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 625{ 626 struct emu_pcm_rchinfo *ch = c_devinfo; 627 628 if (ch->pcm->is_emu10k1) { 629 speed = emu10k1_adcspeed[emu_k1_recval(speed)]; 630 } else { 631 speed = emu10k2_adcspeed[emu_k2_recval(speed)]; 632 } 633 ch->spd = speed; 634 return (ch->spd); 635} 636 637static int 638emurchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 639{ 640 struct emu_pcm_rchinfo *ch = c_devinfo; 641 642 ch->blksz = blocksize; 643 /* If blocksize is less than half of buffer size we will not get 644 interrupt in time and channel will die due to interrupt timeout */ 645 if(ch->blksz < (ch->pcm->bufsz / 2)) 646 ch->blksz = ch->pcm->bufsz / 2; 647 return (ch->blksz); 648} 649 650static int 651emurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 652{ 653 struct emu_pcm_rchinfo *ch = c_devinfo; 654 struct emu_pcm_info *sc = ch->pcm; 655 uint32_t val, sz; 656 657 switch (sc->bufsz) { 658 case 4096: 659 sz = ADCBS_BUFSIZE_4096; 660 break; 661 case 8192: 662 sz = ADCBS_BUFSIZE_8192; 663 break; 664 case 16384: 665 sz = ADCBS_BUFSIZE_16384; 666 break; 667 case 32768: 668 sz = ADCBS_BUFSIZE_32768; 669 break; 670 case 65536: 671 sz = ADCBS_BUFSIZE_65536; 672 break; 673 default: 674 sz = ADCBS_BUFSIZE_4096; 675 } 676 677 snd_mtxlock(sc->lock); 678 switch (go) { 679 case PCMTRIG_START: 680 ch->run = 1; 681 emu_wrptr(sc->card, 0, ch->sizereg, sz); 682 val = sc->is_emu10k1 ? ADCCR_LCHANENABLE : A_ADCCR_LCHANENABLE; 683 if (ch->fmt & AFMT_STEREO) 684 val |= sc->is_emu10k1 ? ADCCR_RCHANENABLE : A_ADCCR_RCHANENABLE; 685 val |= sc->is_emu10k1 ? emu_k1_recval(ch->spd) : emu_k2_recval(ch->spd); 686 emu_wrptr(sc->card, 0, ch->setupreg, 0); 687 emu_wrptr(sc->card, 0, ch->setupreg, val); 688 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc); 689 break; 690 case PCMTRIG_STOP: 691 /* FALLTHROUGH */ 692 case PCMTRIG_ABORT: 693 ch->run = 0; 694 emu_wrptr(sc->card, 0, ch->sizereg, 0); 695 if (ch->setupreg) 696 emu_wrptr(sc->card, 0, ch->setupreg, 0); 697 (void)emu_intr_unregister(sc->card, ch->ihandle); 698 break; 699 case PCMTRIG_EMLDMAWR: 700 /* FALLTHROUGH */ 701 case PCMTRIG_EMLDMARD: 702 /* FALLTHROUGH */ 703 default: 704 break; 705 } 706 snd_mtxunlock(sc->lock); 707 708 return (0); 709} 710 711static int 712emurchan_getptr(kobj_t obj __unused, void *c_devinfo) 713{ 714 struct emu_pcm_rchinfo *ch = c_devinfo; 715 struct emu_pcm_info *sc = ch->pcm; 716 int r; 717 718 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff; 719 720 return (r); 721} 722 723static struct pcmchan_caps * 724emurchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused) 725{ 726 return (&emu_reccaps_adc); 727} 728 729static kobj_method_t emurchan_methods[] = { 730 KOBJMETHOD(channel_init, emurchan_init), 731 KOBJMETHOD(channel_setformat, emurchan_setformat), 732 KOBJMETHOD(channel_setspeed, emurchan_setspeed), 733 KOBJMETHOD(channel_setblocksize, emurchan_setblocksize), 734 KOBJMETHOD(channel_trigger, emurchan_trigger), 735 KOBJMETHOD(channel_getptr, emurchan_getptr), 736 KOBJMETHOD(channel_getcaps, emurchan_getcaps), 737 {0, 0} 738}; 739CHANNEL_DECLARE(emurchan); 740 741static void * 742emufxrchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 743{ 744 struct emu_pcm_info *sc = devinfo; 745 struct emu_pcm_rchinfo *ch; 746 747 KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction")); 748 749 if (sc == NULL) return (NULL); 750 751 ch = &(sc->rch_efx); 752 ch->fmt = AFMT_S16_LE; 753 ch->spd = sc->is_emu10k1 ? 48000*32 : 48000 * 64; 754 ch->idxreg = FXIDX; 755 ch->basereg = FXBA; 756 ch->sizereg = FXBS; 757 ch->irqmask = INTE_EFXBUFENABLE; 758 ch->iprmask = IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL; 759 ch->buffer = b; 760 ch->pcm = sc; 761 ch->channel = c; 762 ch->blksz = sc->bufsz; 763 764 if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), sc->bufsz) != 0) 765 return (NULL); 766 else { 767 emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer)); 768 emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */ 769 return (ch); 770 } 771} 772 773static int 774emufxrchan_setformat(kobj_t obj __unused, void *c_devinfo __unused, uint32_t format) 775{ 776 if (format == AFMT_S16_LE) return (0); 777 return (-1); 778} 779 780static int 781emufxrchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 782{ 783 struct emu_pcm_rchinfo *ch = c_devinfo; 784 785 /* FIXED RATE CHANNEL */ 786 return (ch->spd); 787} 788 789static int 790emufxrchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 791{ 792 struct emu_pcm_rchinfo *ch = c_devinfo; 793 794 ch->blksz = blocksize; 795 /* If blocksize is less than half of buffer size we will not get 796 interrupt in time and channel will die due to interrupt timeout */ 797 if(ch->blksz < (ch->pcm->bufsz / 2)) 798 ch->blksz = ch->pcm->bufsz / 2; 799 return (ch->blksz); 800} 801 802static int 803emufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 804{ 805 struct emu_pcm_rchinfo *ch = c_devinfo; 806 struct emu_pcm_info *sc = ch->pcm; 807 uint32_t sz; 808 809 switch (sc->bufsz) { 810 case 4096: 811 sz = ADCBS_BUFSIZE_4096; 812 break; 813 case 8192: 814 sz = ADCBS_BUFSIZE_8192; 815 break; 816 case 16384: 817 sz = ADCBS_BUFSIZE_16384; 818 break; 819 case 32768: 820 sz = ADCBS_BUFSIZE_32768; 821 break; 822 case 65536: 823 sz = ADCBS_BUFSIZE_65536; 824 break; 825 default: 826 sz = ADCBS_BUFSIZE_4096; 827 } 828 829 snd_mtxlock(sc->lock); 830 switch (go) { 831 case PCMTRIG_START: 832 ch->run = 1; 833 emu_wrptr(sc->card, 0, ch->sizereg, sz); 834 ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc); 835 /* 836 SB Live! is limited to 32 mono channels. Audigy 837 has 64 mono channels, each of them is selected from 838 one of two A_FXWC[1|2] registers. 839 */ 840 /* XXX there is no way to demultiplex this streams for now */ 841 if(sc->is_emu10k1) { 842 emu_wrptr(sc->card, 0, FXWC, 0xffffffff); 843 } else { 844 emu_wrptr(sc->card, 0, A_FXWC1, 0xffffffff); 845 emu_wrptr(sc->card, 0, A_FXWC2, 0xffffffff); 846 } 847 break; 848 case PCMTRIG_STOP: 849 /* FALLTHROUGH */ 850 case PCMTRIG_ABORT: 851 ch->run = 0; 852 if(sc->is_emu10k1) { 853 emu_wrptr(sc->card, 0, FXWC, 0x0); 854 } else { 855 emu_wrptr(sc->card, 0, A_FXWC1, 0x0); 856 emu_wrptr(sc->card, 0, A_FXWC2, 0x0); 857 } 858 emu_wrptr(sc->card, 0, ch->sizereg, 0); 859 (void)emu_intr_unregister(sc->card, ch->ihandle); 860 break; 861 case PCMTRIG_EMLDMAWR: 862 /* FALLTHROUGH */ 863 case PCMTRIG_EMLDMARD: 864 /* FALLTHROUGH */ 865 default: 866 break; 867 } 868 snd_mtxunlock(sc->lock); 869 870 return (0); 871} 872 873static int 874emufxrchan_getptr(kobj_t obj __unused, void *c_devinfo) 875{ 876 struct emu_pcm_rchinfo *ch = c_devinfo; 877 struct emu_pcm_info *sc = ch->pcm; 878 int r; 879 880 r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff; 881 882 return (r); 883} 884 885static struct pcmchan_caps * 886emufxrchan_getcaps(kobj_t obj __unused, void *c_devinfo) 887{ 888 struct emu_pcm_rchinfo *ch = c_devinfo; 889 struct emu_pcm_info *sc = ch->pcm; 890 891 if(sc->is_emu10k1) 892 return (&emu_reccaps_efx_live); 893 return (&emu_reccaps_efx_audigy); 894 895} 896 897static kobj_method_t emufxrchan_methods[] = { 898 KOBJMETHOD(channel_init, emufxrchan_init), 899 KOBJMETHOD(channel_setformat, emufxrchan_setformat), 900 KOBJMETHOD(channel_setspeed, emufxrchan_setspeed), 901 KOBJMETHOD(channel_setblocksize, emufxrchan_setblocksize), 902 KOBJMETHOD(channel_trigger, emufxrchan_trigger), 903 KOBJMETHOD(channel_getptr, emufxrchan_getptr), 904 KOBJMETHOD(channel_getcaps, emufxrchan_getcaps), 905 {0, 0} 906}; 907CHANNEL_DECLARE(emufxrchan); 908 909 910static uint32_t 911emu_pcm_intr(void *pcm, uint32_t stat) 912{ 913 struct emu_pcm_info *sc = (struct emu_pcm_info *)pcm; 914 uint32_t ack; 915 int i; 916 917 ack = 0; 918 919 if (stat & IPR_INTERVALTIMER) { 920 ack |= IPR_INTERVALTIMER; 921 for (i = 0; i < MAX_CHANNELS; i++) 922 if (sc->pch[i].channel) { 923 if (sc->pch[i].run == 1) 924 chn_intr(sc->pch[i].channel); 925 else 926 emu_timer_enable(sc->card, sc->pch[i].timer, 0); 927 } 928 } 929 930 931 if (stat & (IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL)) { 932 ack |= stat & (IPR_ADCBUFFULL | IPR_ADCBUFHALFFULL); 933 if (sc->rch_adc.channel) 934 chn_intr(sc->rch_adc.channel); 935 } 936 937 if (stat & (IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL)) { 938 ack |= stat & (IPR_EFXBUFFULL | IPR_EFXBUFHALFFULL); 939 if (sc->rch_efx.channel) 940 chn_intr(sc->rch_efx.channel); 941 } 942 return (ack); 943} 944 945static int 946emu_pcm_init(struct emu_pcm_info *sc) 947{ 948 sc->bufsz = pcm_getbuffersize(sc->dev, EMUPAGESIZE, EMU_REC_BUFSZ, EMU_MAX_BUFSZ); 949 return (0); 950} 951 952static int 953emu_pcm_uninit(struct emu_pcm_info *sc __unused) 954{ 955 return (0); 956} 957 958static int 959emu_pcm_probe(device_t dev) 960{ 961 uintptr_t func, route, r; 962 const char *rt; 963 char buffer[255]; 964 965 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_FUNC, &func); 966 967 if (func != SCF_PCM) 968 return (ENXIO); 969 970 rt = "UNKNOWN"; 971 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route); 972 switch (route) { 973 case RT_FRONT: 974 rt = "front"; 975 break; 976 case RT_REAR: 977 rt = "rear"; 978 break; 979 case RT_CENTER: 980 rt = "center"; 981 break; 982 case RT_SUB: 983 rt = "subwoofer"; 984 break; 985 case RT_SIDE: 986 rt = "side"; 987 break; 988 case RT_MCHRECORD: 989 rt = "multichannel recording"; 990 break; 991 } 992 993 snprintf(buffer, 255, "EMU10Kx DSP %s PCM interface", rt); 994 device_set_desc_copy(dev, buffer); 995 return (0); 996} 997 998static int 999emu_pcm_attach(device_t dev) 1000{ 1001 struct emu_pcm_info *sc; 1002 unsigned int i; 1003 char status[SND_STATUSLEN]; 1004 uint32_t inte, ipr; 1005 uintptr_t route, r, is_emu10k1; 1006 1007 if ((sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) { 1008 device_printf(dev, "cannot allocate softc\n"); 1009 return (ENXIO); 1010 } 1011 bzero(sc, sizeof(*sc)); 1012 1013 sc->card = (struct emu_sc_info *)(device_get_softc(device_get_parent(dev))); 1014 if (sc->card == NULL) { 1015 device_printf(dev, "cannot get bridge conf\n"); 1016 return (ENXIO); 1017 } 1018 1019 sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10kx softc"); 1020 sc->dev = dev; 1021 1022 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ISEMU10K1, &is_emu10k1); 1023 sc->is_emu10k1 = is_emu10k1 ? 1 : 0; 1024 1025 sc->codec = NULL; 1026 1027 for (i = 0; i < 8; i++) { 1028 sc->rt.routing_left[i] = i; 1029 sc->rt.amounts_left[i] = 0x00; 1030 sc->rt.routing_right[i] = i; 1031 sc->rt.amounts_right[i] = 0x00; 1032 } 1033 1034 for (i = 0; i < 8; i++) { 1035 sc->rt_mono.routing_left[i] = i; 1036 sc->rt_mono.amounts_left[i] = 0x00; 1037 sc->rt_mono.routing_right[i] = i; 1038 sc->rt_mono.amounts_right[i] = 0x00; 1039 } 1040 1041 r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route); 1042 sc->route = route; 1043 switch (route) { 1044 case RT_FRONT: 1045 sc->rt.amounts_left[0] = 0xff; 1046 sc->rt.amounts_right[1] = 0xff; 1047 sc->rt_mono.amounts_left[0] = 0xff; 1048 sc->rt_mono.amounts_left[1] = 0xff; 1049 if (sc->is_emu10k1) 1050 sc->codec = AC97_CREATE(dev, sc, emu_ac97); 1051 else 1052 sc->codec = AC97_CREATE(dev, sc, emu_eac97); 1053 if (sc->codec == NULL) { 1054 if (mixer_init(dev, &emudspmixer_class, sc)) { 1055 device_printf(dev, "failed to initialize DSP mixer\n"); 1056 goto bad; 1057 } 1058 } else 1059 if (mixer_init(dev, ac97_getmixerclass(), sc->codec) == -1) { 1060 device_printf(dev, "can't initialize AC97 mixer!\n"); 1061 goto bad; 1062 } 1063 break; 1064 case RT_REAR: 1065 sc->rt.amounts_left[2] = 0xff; 1066 sc->rt.amounts_right[3] = 0xff; 1067 sc->rt_mono.amounts_left[2] = 0xff; 1068 sc->rt_mono.amounts_left[3] = 0xff; 1069 if (mixer_init(dev, &emudspmixer_class, sc)) { 1070 device_printf(dev, "failed to initialize mixer\n"); 1071 goto bad; 1072 } 1073 break; 1074 case RT_CENTER: 1075 sc->rt.amounts_left[4] = 0xff; 1076 sc->rt_mono.amounts_left[4] = 0xff; 1077 if (mixer_init(dev, &emudspmixer_class, sc)) { 1078 device_printf(dev, "failed to initialize mixer\n"); 1079 goto bad; 1080 } 1081 break; 1082 case RT_SUB: 1083 sc->rt.amounts_left[5] = 0xff; 1084 sc->rt_mono.amounts_left[5] = 0xff; 1085 if (mixer_init(dev, &emudspmixer_class, sc)) { 1086 device_printf(dev, "failed to initialize mixer\n"); 1087 goto bad; 1088 } 1089 break; 1090 case RT_SIDE: 1091 sc->rt.amounts_left[6] = 0xff; 1092 sc->rt.amounts_right[7] = 0xff; 1093 sc->rt_mono.amounts_left[6] = 0xff; 1094 sc->rt_mono.amounts_left[7] = 0xff; 1095 if (mixer_init(dev, &emudspmixer_class, sc)) { 1096 device_printf(dev, "failed to initialize mixer\n"); 1097 goto bad; 1098 } 1099 break; 1100 case RT_MCHRECORD: 1101 /* XXX add mixer here */ 1102 break; 1103 default: 1104 device_printf(dev, "invalid default route\n"); 1105 goto bad; 1106 } 1107 1108 inte = INTE_INTERVALTIMERENB; 1109 ipr = IPR_INTERVALTIMER; /* Used by playback */ 1110 sc->ihandle = emu_intr_register(sc->card, inte, ipr, &emu_pcm_intr, sc); 1111 1112 if (emu_pcm_init(sc) == -1) { 1113 device_printf(dev, "unable to initialize PCM part of the card\n"); 1114 goto bad; 1115 } 1116 1117 /* XXX we should better get number of available channels from parent */ 1118 if (pcm_register(dev, sc, (route == RT_FRONT) ? MAX_CHANNELS : 1, (route == RT_FRONT) ? 1 : 0)) { 1119 device_printf(dev, "can't register PCM channels!\n"); 1120 goto bad; 1121 } 1122 sc->pnum = 0; 1123 if (route != RT_MCHRECORD) 1124 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc); 1125 if (route == RT_FRONT) { 1126 for (i = 1; i < MAX_CHANNELS; i++) 1127 pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc); 1128 pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc); 1129 } 1130 if (route == RT_MCHRECORD) 1131 pcm_addchan(dev, PCMDIR_REC, &emufxrchan_class, sc); 1132 1133 snprintf(status, SND_STATUSLEN, "on %s", device_get_nameunit(device_get_parent(dev))); 1134 pcm_setstatus(dev, status); 1135 1136 return (0); 1137 1138bad: 1139 if (sc->codec) 1140 ac97_destroy(sc->codec); 1141 if (sc->lock) 1142 snd_mtxfree(sc->lock); 1143 free(sc, M_DEVBUF); 1144 return (ENXIO); 1145} 1146 1147static int 1148emu_pcm_detach(device_t dev) 1149{ 1150 int r; 1151 struct emu_pcm_info *sc; 1152 1153 sc = pcm_getdevinfo(dev); 1154 1155 r = pcm_unregister(dev); 1156 1157 if (r) return (r); 1158 1159 emu_pcm_uninit(sc); 1160 1161 if (sc->lock) 1162 snd_mtxfree(sc->lock); 1163 free(sc, M_DEVBUF); 1164 1165 return (0); 1166} 1167 1168static device_method_t emu_pcm_methods[] = { 1169 DEVMETHOD(device_probe, emu_pcm_probe), 1170 DEVMETHOD(device_attach, emu_pcm_attach), 1171 DEVMETHOD(device_detach, emu_pcm_detach), 1172 1173 {0, 0} 1174}; 1175 1176static driver_t emu_pcm_driver = { 1177 "pcm", 1178 emu_pcm_methods, 1179 PCM_SOFTC_SIZE, 1180 NULL, 1181 0, 1182 NULL 1183}; 1184DRIVER_MODULE(snd_emu10kx_pcm, emu10kx, emu_pcm_driver, pcm_devclass, 0, 0); 1185MODULE_DEPEND(snd_emu10kx_pcm, snd_emu10kx, SND_EMU10KX_MINVER, SND_EMU10KX_PREFVER, SND_EMU10KX_MAXVER); 1186MODULE_DEPEND(snd_emu10kx_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 1187MODULE_VERSION(snd_emu10kx_pcm, SND_EMU10KX_PREFVER); 1188