emu10kx-pcm.c revision 330897
1214501Srpaulo/*- 2214501Srpaulo * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3214501Srpaulo * 4214501Srpaulo * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk> 5214501Srpaulo * Copyright (c) 2003-2007 Yuriy Tsibizov <yuriy.tsibizov@gfk.ru> 6214501Srpaulo * All rights reserved. 7214501Srpaulo * 8252190Srpaulo * Redistribution and use in source and binary forms, with or without 9252190Srpaulo * modification, are permitted provided that the following conditions 10214501Srpaulo * are met: 11214501Srpaulo * 1. Redistributions of source code must retain the above copyright 12214501Srpaulo * notice, this list of conditions and the following disclaimer. 13214501Srpaulo * 2. Redistributions in binary form must reproduce the above copyright 14214501Srpaulo * notice, this list of conditions and the following disclaimer in the 15214501Srpaulo * documentation and/or other materials provided with the distribution. 16214501Srpaulo * 17252190Srpaulo * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18252190Srpaulo * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19252190Srpaulo * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20252190Srpaulo * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21252190Srpaulo * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22252190Srpaulo * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23214501Srpaulo * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24214501Srpaulo * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT 25214501Srpaulo * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26214501Srpaulo * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27214501Srpaulo * SUCH DAMAGE. 28214501Srpaulo * 29214501Srpaulo * $FreeBSD: stable/11/sys/dev/sound/pci/emu10kx-pcm.c 330897 2018-03-14 03:19:51Z eadler $ 30214501Srpaulo */ 31214501Srpaulo 32214501Srpaulo#include <sys/param.h> 33214501Srpaulo#include <sys/types.h> 34214501Srpaulo#include <sys/bus.h> 35214501Srpaulo#include <machine/bus.h> 36214501Srpaulo#include <sys/rman.h> 37252190Srpaulo#include <sys/systm.h> 38214501Srpaulo#include <sys/sbuf.h> 39341618Scy#include <sys/queue.h> 40341618Scy#include <sys/systm.h> 41341618Scy#include <sys/lock.h> 42214501Srpaulo#include <sys/mutex.h> 43341618Scy 44214501Srpaulo#ifdef HAVE_KERNEL_OPTION_HEADERS 45214501Srpaulo#include "opt_snd.h" 46252190Srpaulo#endif 47214501Srpaulo 48214501Srpaulo#include <dev/sound/chip.h> 49214501Srpaulo#include <dev/sound/pcm/sound.h> 50214501Srpaulo#include <dev/sound/pcm/ac97.h> 51214501Srpaulo 52252190Srpaulo#include "mixer_if.h" 53214501Srpaulo 54214501Srpaulo#include <dev/sound/pci/emuxkireg.h> 55214501Srpaulo#include <dev/sound/pci/emu10kx.h> 56214501Srpaulo 57214501Srpaulostruct emu_pcm_pchinfo { 58214501Srpaulo int spd; 59214501Srpaulo int fmt; 60214501Srpaulo unsigned int blksz; 61214501Srpaulo int run; 62341618Scy struct emu_voice *master; 63289284Srpaulo struct emu_voice *slave; 64289284Srpaulo struct snd_dbuf *buffer; 65214501Srpaulo struct pcm_channel *channel; 66289284Srpaulo struct emu_pcm_info *pcm; 67252190Srpaulo int timer; 68214501Srpaulo}; 69214501Srpaulo 70214501Srpaulostruct emu_pcm_rchinfo { 71214501Srpaulo int spd; 72214501Srpaulo int fmt; 73214501Srpaulo unsigned int blksz; 74214501Srpaulo int run; 75214501Srpaulo uint32_t idxreg; 76214501Srpaulo uint32_t basereg; 77341618Scy uint32_t sizereg; 78214501Srpaulo uint32_t setupreg; 79214501Srpaulo uint32_t irqmask; 80214501Srpaulo uint32_t iprmask; 81214501Srpaulo int ihandle; 82252190Srpaulo struct snd_dbuf *buffer; 83252190Srpaulo struct pcm_channel *channel; 84252190Srpaulo struct emu_pcm_info *pcm; 85252190Srpaulo int timer; 86214501Srpaulo}; 87214501Srpaulo 88252190Srpaulo/* XXX Hardware playback channels */ 89214501Srpaulo#define MAX_CHANNELS 4 90252190Srpaulo 91214501Srpaulo#if MAX_CHANNELS > 13 92214501Srpaulo#error Too many hardware channels defined. 13 is the maximum 93214501Srpaulo#endif 94214501Srpaulo 95214501Srpaulostruct emu_pcm_info { 96214501Srpaulo struct mtx *lock; 97214501Srpaulo device_t dev; /* device information */ 98214501Srpaulo struct emu_sc_info *card; 99214501Srpaulo struct emu_pcm_pchinfo pch[MAX_CHANNELS]; /* hardware channels */ 100214501Srpaulo int pnum; /* next free channel number */ 101214501Srpaulo struct emu_pcm_rchinfo rch_adc; 102214501Srpaulo struct emu_pcm_rchinfo rch_efx; 103214501Srpaulo struct emu_route rt; 104214501Srpaulo struct emu_route rt_mono; 105214501Srpaulo int route; 106214501Srpaulo int ihandle; /* interrupt handler */ 107214501Srpaulo unsigned int bufsz; 108214501Srpaulo int is_emu10k1; 109214501Srpaulo struct ac97_info *codec; 110214501Srpaulo uint32_t ac97_state[0x7F]; 111214501Srpaulo kobj_class_t ac97_mixerclass; 112214501Srpaulo uint32_t ac97_recdevs; 113214501Srpaulo uint32_t ac97_playdevs; 114214501Srpaulo struct snd_mixer *sm; 115214501Srpaulo int mch_disabled; 116214501Srpaulo unsigned int emu10k1_volcache[2][2]; 117214501Srpaulo}; 118214501Srpaulo 119214501Srpaulo 120214501Srpaulostatic uint32_t emu_rfmt_adc[] = { 121214501Srpaulo SND_FORMAT(AFMT_S16_LE, 1, 0), 122214501Srpaulo SND_FORMAT(AFMT_S16_LE, 2, 0), 123214501Srpaulo 0 124214501Srpaulo}; 125214501Srpaulostatic struct pcmchan_caps emu_reccaps_adc = { 126214501Srpaulo 8000, 48000, emu_rfmt_adc, 0 127214501Srpaulo}; 128214501Srpaulo 129214501Srpaulostatic uint32_t emu_rfmt_efx[] = { 130214501Srpaulo SND_FORMAT(AFMT_S16_LE, 1, 0), 131214501Srpaulo 0 132214501Srpaulo}; 133214501Srpaulo 134214501Srpaulostatic struct pcmchan_caps emu_reccaps_efx_live = { 135214501Srpaulo 48000*32, 48000*32, emu_rfmt_efx, 0 136214501Srpaulo}; 137214501Srpaulo 138214501Srpaulostatic struct pcmchan_caps emu_reccaps_efx_audigy = { 139214501Srpaulo 48000*64, 48000*64, emu_rfmt_efx, 0 140214501Srpaulo}; 141214501Srpaulo 142214501Srpaulostatic int emu_rates_live[] = { 143214501Srpaulo 48000*32 144214501Srpaulo}; 145214501Srpaulo 146214501Srpaulostatic int emu_rates_audigy[] = { 147214501Srpaulo 48000*64 148214501Srpaulo}; 149214501Srpaulo 150214501Srpaulostatic uint32_t emu_pfmt[] = { 151214501Srpaulo SND_FORMAT(AFMT_U8, 1, 0), 152214501Srpaulo SND_FORMAT(AFMT_U8, 2, 0), 153214501Srpaulo SND_FORMAT(AFMT_S16_LE, 1, 0), 154214501Srpaulo SND_FORMAT(AFMT_S16_LE, 2, 0), 155214501Srpaulo 0 156214501Srpaulo}; 157214501Srpaulostatic uint32_t emu_pfmt_mono[] = { 158214501Srpaulo SND_FORMAT(AFMT_U8, 1, 0), 159214501Srpaulo SND_FORMAT(AFMT_S16_LE, 1, 0), 160214501Srpaulo 0 161214501Srpaulo}; 162214501Srpaulo 163214501Srpaulostatic struct pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0}; 164214501Srpaulostatic struct pcmchan_caps emu_playcaps_mono = {4000, 48000, emu_pfmt_mono, 0}; 165214501Srpaulo 166214501Srpaulostatic int emu10k1_adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000}; 167214501Srpaulo/* audigy supports 12kHz. */ 168214501Srpaulostatic int emu10k2_adcspeed[9] = {48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000}; 169214501Srpaulo 170214501Srpaulostatic uint32_t emu_pcm_intr(void *pcm, uint32_t stat); 171214501Srpaulo 172214501Srpaulostatic const struct emu_dspmix_props_k1 { 173214501Srpaulo uint8_t present; 174214501Srpaulo uint8_t recdev; 175214501Srpaulo int8_t input; 176214501Srpaulo} dspmix_k1 [SOUND_MIXER_NRDEVICES] = { 177214501Srpaulo /* no mixer device for ac97 */ /* in0 AC97 */ 178214501Srpaulo [SOUND_MIXER_DIGITAL1] = {1, 1, 1}, /* in1 CD SPDIF */ 179214501Srpaulo /* not connected */ /* in2 (zoom) */ 180214501Srpaulo [SOUND_MIXER_DIGITAL2] = {1, 1, 3}, /* in3 toslink */ 181214501Srpaulo [SOUND_MIXER_LINE2] = {1, 1, 4}, /* in4 Line-In2 */ 182214501Srpaulo [SOUND_MIXER_DIGITAL3] = {1, 1, 5}, /* in5 on-card SPDIF */ 183214501Srpaulo [SOUND_MIXER_LINE3] = {1, 1, 6}, /* in6 AUX2 */ 184214501Srpaulo /* not connected */ /* in7 */ 185214501Srpaulo}; 186341618Scystatic const struct emu_dspmix_props_k2 { 187214501Srpaulo uint8_t present; 188341618Scy uint8_t recdev; 189341618Scy int8_t input; 190341618Scy} dspmix_k2 [SOUND_MIXER_NRDEVICES] = { 191341618Scy [SOUND_MIXER_VOLUME] = {1, 0, (-1)}, 192341618Scy [SOUND_MIXER_PCM] = {1, 0, (-1)}, 193341618Scy 194341618Scy /* no mixer device */ /* in0 AC97 */ 195341618Scy [SOUND_MIXER_DIGITAL1] = {1, 1, 1}, /* in1 CD SPDIF */ 196341618Scy [SOUND_MIXER_DIGITAL2] = {1, 1, 2}, /* in2 COAX SPDIF */ 197341618Scy /* not connected */ /* in3 */ 198341618Scy [SOUND_MIXER_LINE2] = {1, 1, 4}, /* in4 Line-In2 */ 199341618Scy [SOUND_MIXER_DIGITAL3] = {1, 1, 5}, /* in5 on-card SPDIF */ 200341618Scy [SOUND_MIXER_LINE3] = {1, 1, 6}, /* in6 AUX2 */ 201341618Scy /* not connected */ /* in7 */ 202341618Scy}; 203341618Scy 204341618Scystatic int 205341618Scyemu_dspmixer_init(struct snd_mixer *m) 206252190Srpaulo{ 207214501Srpaulo struct emu_pcm_info *sc; 208214501Srpaulo int i; 209214501Srpaulo int p, r; 210214501Srpaulo 211214501Srpaulo p = 0; 212214501Srpaulo r = 0; 213214501Srpaulo 214214501Srpaulo sc = mix_getdevinfo(m); 215214501Srpaulo 216324714Scy if (sc->route == RT_FRONT) { 217214501Srpaulo /* create submixer for AC97 codec */ 218214501Srpaulo if ((sc->ac97_mixerclass != NULL) && (sc->codec != NULL)) { 219214501Srpaulo sc->sm = mixer_create(sc->dev, sc->ac97_mixerclass, sc->codec, "ac97"); 220214501Srpaulo if (sc->sm != NULL) { 221214501Srpaulo p = mix_getdevs(sc->sm); 222324714Scy r = mix_getrecdevs(sc->sm); 223214501Srpaulo } 224214501Srpaulo } 225214501Srpaulo 226214501Srpaulo sc->ac97_playdevs = p; 227214501Srpaulo sc->ac97_recdevs = r; 228214501Srpaulo } 229214501Srpaulo 230214501Srpaulo /* This two are always here */ 231214501Srpaulo p |= (1 << SOUND_MIXER_PCM); 232214501Srpaulo p |= (1 << SOUND_MIXER_VOLUME); 233214501Srpaulo 234214501Srpaulo if (sc->route == RT_FRONT) { 235214501Srpaulo if (sc->is_emu10k1) { 236214501Srpaulo for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 237214501Srpaulo if (dspmix_k1[i].present) 238214501Srpaulo p |= (1 << i); 239214501Srpaulo if (dspmix_k1[i].recdev) 240214501Srpaulo r |= (1 << i); 241214501Srpaulo } 242214501Srpaulo } else { 243214501Srpaulo for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 244214501Srpaulo if (dspmix_k2[i].present) 245252190Srpaulo p |= (1 << i); 246214501Srpaulo if (dspmix_k2[i].recdev) 247214501Srpaulo r |= (1 << i); 248214501Srpaulo } 249324714Scy } 250214501Srpaulo } 251214501Srpaulo 252324714Scy mix_setdevs(m, p); 253214501Srpaulo mix_setrecdevs(m, r); 254214501Srpaulo 255281681Srpaulo return (0); 256281681Srpaulo} 257281681Srpaulo 258281681Srpaulostatic int 259214501Srpauloemu_dspmixer_uninit(struct snd_mixer *m) 260214501Srpaulo{ 261214501Srpaulo struct emu_pcm_info *sc; 262214501Srpaulo int err = 0; 263214501Srpaulo 264214501Srpaulo /* drop submixer for AC97 codec */ 265214501Srpaulo sc = mix_getdevinfo(m); 266214501Srpaulo if (sc->sm != NULL) 267214501Srpaulo err = mixer_delete(sc->sm); 268214501Srpaulo if (err) 269214501Srpaulo return (err); 270214501Srpaulo sc->sm = NULL; 271324714Scy return (0); 272214501Srpaulo} 273324714Scy 274214501Srpaulostatic int 275214501Srpauloemu_dspmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 276214501Srpaulo{ 277214501Srpaulo struct emu_pcm_info *sc; 278214501Srpaulo 279214501Srpaulo sc = mix_getdevinfo(m); 280214501Srpaulo 281214501Srpaulo switch (dev) { 282252190Srpaulo case SOUND_MIXER_VOLUME: 283214501Srpaulo switch (sc->route) { 284214501Srpaulo case RT_FRONT: 285214501Srpaulo if (sc->sm != NULL) 286214501Srpaulo mix_set(sc->sm, dev, left, right); 287214501Srpaulo if (sc->mch_disabled) { 288214501Srpaulo /* In emu10k1 case PCM volume does not affect 289214501Srpaulo sound routed to rear & center/sub (it is connected 290214501Srpaulo to AC97 codec). Calculate it manually. */ 291281681Srpaulo /* This really should belong to emu10kx.c */ 292281681Srpaulo if (sc->is_emu10k1) { 293281681Srpaulo sc->emu10k1_volcache[0][0] = left; 294281681Srpaulo left = left * sc->emu10k1_volcache[1][0] / 100; 295281681Srpaulo sc->emu10k1_volcache[0][1] = right; 296281681Srpaulo right = right * sc->emu10k1_volcache[1][1] / 100; 297281681Srpaulo } 298281681Srpaulo 299281681Srpaulo emumix_set_volume(sc->card, M_MASTER_REAR_L, left); 300281681Srpaulo emumix_set_volume(sc->card, M_MASTER_REAR_R, right); 301281681Srpaulo if (!sc->is_emu10k1) { 302214501Srpaulo emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2); 303214501Srpaulo emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2); 304214501Srpaulo /* XXX side */ 305214501Srpaulo } 306214501Srpaulo } /* mch disabled */ 307214501Srpaulo break; 308214501Srpaulo case RT_REAR: 309214501Srpaulo emumix_set_volume(sc->card, M_MASTER_REAR_L, left); 310214501Srpaulo emumix_set_volume(sc->card, M_MASTER_REAR_R, right); 311214501Srpaulo break; 312214501Srpaulo case RT_CENTER: 313214501Srpaulo emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2); 314214501Srpaulo break; 315214501Srpaulo case RT_SUB: 316214501Srpaulo emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2); 317214501Srpaulo break; 318214501Srpaulo } 319214501Srpaulo break; 320214501Srpaulo case SOUND_MIXER_PCM: 321281681Srpaulo switch (sc->route) { 322214501Srpaulo case RT_FRONT: 323214501Srpaulo if (sc->sm != NULL) 324214501Srpaulo mix_set(sc->sm, dev, left, right); 325214501Srpaulo if (sc->mch_disabled) { 326214501Srpaulo /* See SOUND_MIXER_VOLUME case */ 327214501Srpaulo if (sc->is_emu10k1) { 328281681Srpaulo sc->emu10k1_volcache[1][0] = left; 329281681Srpaulo left = left * sc->emu10k1_volcache[0][0] / 100; 330214501Srpaulo sc->emu10k1_volcache[1][1] = right; 331214501Srpaulo right = right * sc->emu10k1_volcache[0][1] / 100; 332214501Srpaulo } 333214501Srpaulo emumix_set_volume(sc->card, M_MASTER_REAR_L, left); 334214501Srpaulo emumix_set_volume(sc->card, M_MASTER_REAR_R, right); 335214501Srpaulo 336214501Srpaulo if (!sc->is_emu10k1) { 337281681Srpaulo emumix_set_volume(sc->card, M_MASTER_CENTER, (left+right)/2); 338281681Srpaulo emumix_set_volume(sc->card, M_MASTER_SUBWOOFER, (left+right)/2); 339281681Srpaulo /* XXX side */ 340281681Srpaulo } 341281681Srpaulo } /* mch_disabled */ 342281681Srpaulo break; 343281681Srpaulo case RT_REAR: 344281681Srpaulo emumix_set_volume(sc->card, M_FX2_REAR_L, left); 345214501Srpaulo emumix_set_volume(sc->card, M_FX3_REAR_R, right); 346214501Srpaulo break; 347214501Srpaulo case RT_CENTER: 348214501Srpaulo emumix_set_volume(sc->card, M_FX4_CENTER, (left+right)/2); 349214501Srpaulo break; 350214501Srpaulo case RT_SUB: 351281681Srpaulo emumix_set_volume(sc->card, M_FX5_SUBWOOFER, (left+right)/2); 352281681Srpaulo break; 353214501Srpaulo } 354214501Srpaulo break; 355214501Srpaulo case SOUND_MIXER_DIGITAL1: /* CD SPDIF, in1 */ 356214501Srpaulo emumix_set_volume(sc->card, M_IN1_FRONT_L, left); 357214501Srpaulo emumix_set_volume(sc->card, M_IN1_FRONT_R, right); 358214501Srpaulo break; 359214501Srpaulo case SOUND_MIXER_DIGITAL2: 360281681Srpaulo if (sc->is_emu10k1) { 361281681Srpaulo /* TOSLink, in3 */ 362281681Srpaulo emumix_set_volume(sc->card, M_IN3_FRONT_L, left); 363214501Srpaulo emumix_set_volume(sc->card, M_IN3_FRONT_R, right); 364214501Srpaulo } else { 365214501Srpaulo /* COAX SPDIF, in2 */ 366214501Srpaulo emumix_set_volume(sc->card, M_IN2_FRONT_L, left); 367214501Srpaulo emumix_set_volume(sc->card, M_IN2_FRONT_R, right); 368214501Srpaulo } 369252190Srpaulo break; 370252190Srpaulo case SOUND_MIXER_LINE2: /* Line-In2, in4 */ 371252190Srpaulo emumix_set_volume(sc->card, M_IN4_FRONT_L, left); 372252190Srpaulo emumix_set_volume(sc->card, M_IN4_FRONT_R, right); 373252190Srpaulo break; 374252190Srpaulo case SOUND_MIXER_DIGITAL3: /* on-card SPDIF, in5 */ 375252190Srpaulo emumix_set_volume(sc->card, M_IN5_FRONT_L, left); 376252190Srpaulo emumix_set_volume(sc->card, M_IN5_FRONT_R, right); 377252190Srpaulo break; 378214501Srpaulo case SOUND_MIXER_LINE3: /* AUX2, in6 */ 379281681Srpaulo emumix_set_volume(sc->card, M_IN6_FRONT_L, left); 380281681Srpaulo emumix_set_volume(sc->card, M_IN6_FRONT_R, right); 381214501Srpaulo break; 382214501Srpaulo default: 383214501Srpaulo if (sc->sm != NULL) { 384214501Srpaulo /* XXX emumix_set_volume is not required here */ 385214501Srpaulo emumix_set_volume(sc->card, M_IN0_FRONT_L, 100); 386281681Srpaulo emumix_set_volume(sc->card, M_IN0_FRONT_R, 100); 387214501Srpaulo mix_set(sc->sm, dev, left, right); 388214501Srpaulo } else 389214501Srpaulo device_printf(sc->dev, "mixer error: unknown device %d\n", dev); 390214501Srpaulo } 391214501Srpaulo return (0); 392214501Srpaulo} 393252190Srpaulo 394214501Srpaulostatic u_int32_t 395252190Srpauloemu_dspmixer_setrecsrc(struct snd_mixer *m, u_int32_t src) 396214501Srpaulo{ 397214501Srpaulo struct emu_pcm_info *sc; 398214501Srpaulo int i; 399214501Srpaulo u_int32_t recmask; 400214501Srpaulo int input[8]; 401214501Srpaulo 402214501Srpaulo sc = mix_getdevinfo(m); 403214501Srpaulo recmask = 0; 404214501Srpaulo for (i=0; i < 8; i++) 405252190Srpaulo input[i]=0; 406214501Srpaulo 407214501Srpaulo if (sc->sm != NULL) 408281681Srpaulo if ((src & sc->ac97_recdevs) !=0) 409214501Srpaulo if (mix_setrecsrc(sc->sm, src & sc->ac97_recdevs) == 0) { 410214501Srpaulo recmask |= (src & sc->ac97_recdevs); 411252190Srpaulo /* Recording from AC97 codec. 412281681Srpaulo Enable AC97 route to rec on DSP */ 413214501Srpaulo input[0] = 1; 414214501Srpaulo } 415214501Srpaulo if (sc->is_emu10k1) { 416214501Srpaulo for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 417281681Srpaulo if (dspmix_k1[i].recdev) 418214501Srpaulo if ((src & (1 << i)) == ((uint32_t)1 << i)) { 419214501Srpaulo recmask |= (1 << i); 420214501Srpaulo /* enable device i */ 421214501Srpaulo input[dspmix_k1[i].input] = 1; 422214501Srpaulo } 423214501Srpaulo } 424214501Srpaulo } else { 425252190Srpaulo for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 426214501Srpaulo if (dspmix_k2[i].recdev) 427252190Srpaulo if ((src & (1 << i)) == ((uint32_t)1 << i)) { 428214501Srpaulo recmask |= (1 << i); 429214501Srpaulo /* enable device i */ 430214501Srpaulo input[dspmix_k2[i].input] = 1; 431214501Srpaulo } 432214501Srpaulo } 433214501Srpaulo } 434214501Srpaulo emumix_set_volume(sc->card, M_IN0_REC_L, input[0] == 1 ? 100 : 0); 435252190Srpaulo emumix_set_volume(sc->card, M_IN0_REC_R, input[0] == 1 ? 100 : 0); 436214501Srpaulo 437252190Srpaulo emumix_set_volume(sc->card, M_IN1_REC_L, input[1] == 1 ? 100 : 0); 438214501Srpaulo emumix_set_volume(sc->card, M_IN1_REC_R, input[1] == 1 ? 100 : 0); 439214501Srpaulo 440214501Srpaulo if (!sc->is_emu10k1) { 441214501Srpaulo emumix_set_volume(sc->card, M_IN2_REC_L, input[2] == 1 ? 100 : 0); 442214501Srpaulo emumix_set_volume(sc->card, M_IN2_REC_R, input[2] == 1 ? 100 : 0); 443214501Srpaulo } 444214501Srpaulo 445214501Srpaulo if (sc->is_emu10k1) { 446214501Srpaulo emumix_set_volume(sc->card, M_IN3_REC_L, input[3] == 1 ? 100 : 0); 447214501Srpaulo emumix_set_volume(sc->card, M_IN3_REC_R, input[3] == 1 ? 100 : 0); 448214501Srpaulo } 449324714Scy 450214501Srpaulo emumix_set_volume(sc->card, M_IN4_REC_L, input[4] == 1 ? 100 : 0); 451214501Srpaulo emumix_set_volume(sc->card, M_IN4_REC_R, input[4] == 1 ? 100 : 0); 452214501Srpaulo 453214501Srpaulo emumix_set_volume(sc->card, M_IN5_REC_L, input[5] == 1 ? 100 : 0); 454214501Srpaulo emumix_set_volume(sc->card, M_IN5_REC_R, input[5] == 1 ? 100 : 0); 455214501Srpaulo 456214501Srpaulo emumix_set_volume(sc->card, M_IN6_REC_L, input[6] == 1 ? 100 : 0); 457214501Srpaulo emumix_set_volume(sc->card, M_IN6_REC_R, input[6] == 1 ? 100 : 0); 458214501Srpaulo 459214501Srpaulo /* XXX check for K1/k2 differences? */ 460252190Srpaulo if ((src & (1 << SOUND_MIXER_PCM)) == (1 << SOUND_MIXER_PCM)) { 461289284Srpaulo emumix_set_volume(sc->card, M_FX0_REC_L, emumix_get_volume(sc->card, M_FX0_FRONT_L)); 462289284Srpaulo emumix_set_volume(sc->card, M_FX1_REC_R, emumix_get_volume(sc->card, M_FX1_FRONT_R)); 463214501Srpaulo } else { 464214501Srpaulo emumix_set_volume(sc->card, M_FX0_REC_L, 0); 465214501Srpaulo emumix_set_volume(sc->card, M_FX1_REC_R, 0); 466252190Srpaulo } 467214501Srpaulo 468252190Srpaulo return (recmask); 469214501Srpaulo} 470214501Srpaulo 471214501Srpaulostatic kobj_method_t emudspmixer_methods[] = { 472214501Srpaulo KOBJMETHOD(mixer_init, emu_dspmixer_init), 473252190Srpaulo KOBJMETHOD(mixer_uninit, emu_dspmixer_uninit), 474214501Srpaulo KOBJMETHOD(mixer_set, emu_dspmixer_set), 475252190Srpaulo KOBJMETHOD(mixer_setrecsrc, emu_dspmixer_setrecsrc), 476214501Srpaulo KOBJMETHOD_END 477214501Srpaulo}; 478214501SrpauloMIXER_DECLARE(emudspmixer); 479214501Srpaulo 480214501Srpaulostatic int 481214501Srpauloemu_efxmixer_init(struct snd_mixer *m) 482324714Scy{ 483214501Srpaulo mix_setdevs(m, SOUND_MASK_VOLUME); 484324714Scy mix_setrecdevs(m, SOUND_MASK_MONITOR); 485214501Srpaulo return (0); 486214501Srpaulo} 487214501Srpaulo 488214501Srpaulostatic int 489214501Srpauloemu_efxmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 490214501Srpaulo{ 491214501Srpaulo if (left + right == 200) return (0); 492214501Srpaulo return (0); 493214501Srpaulo} 494214501Srpaulo 495214501Srpaulostatic u_int32_t 496214501Srpauloemu_efxmixer_setrecsrc(struct snd_mixer *m __unused, u_int32_t src __unused) 497214501Srpaulo{ 498214501Srpaulo return (SOUND_MASK_MONITOR); 499214501Srpaulo} 500214501Srpaulo 501252190Srpaulostatic kobj_method_t emuefxmixer_methods[] = { 502214501Srpaulo KOBJMETHOD(mixer_init, emu_efxmixer_init), 503214501Srpaulo KOBJMETHOD(mixer_set, emu_efxmixer_set), 504214501Srpaulo KOBJMETHOD(mixer_setrecsrc, emu_efxmixer_setrecsrc), 505252190Srpaulo KOBJMETHOD_END 506214501Srpaulo}; 507214501SrpauloMIXER_DECLARE(emuefxmixer); 508214501Srpaulo 509214501Srpaulo/* 510214501Srpaulo * AC97 emulation code for Audigy and later cards. 511252190Srpaulo * Some parts of AC97 codec are not used by hardware, but can be used 512214501Srpaulo * to change some DSP controls via AC97 mixer interface. This includes: 513214501Srpaulo * - master volume controls MASTER_FRONT_[R|L] 514214501Srpaulo * - pcm volume controls FX[0|1]_FRONT_[R|L] 515214501Srpaulo * - rec volume controls MASTER_REC_[R|L] 516214501Srpaulo * We do it because we need to put it under user control.... 517214501Srpaulo * We also keep some parts of AC97 disabled to get better sound quality 518214501Srpaulo */ 519214501Srpaulo 520214501Srpaulo#define AC97LEFT(x) ((x & 0x7F00)>>8) 521214501Srpaulo#define AC97RIGHT(x) (x & 0x007F) 522214501Srpaulo#define AC97MUTE(x) ((x & 0x8000)>>15) 523214501Srpaulo#define BIT4_TO100(x) (100-(x)*100/(0x0f)) 524214501Srpaulo#define BIT6_TO100(x) (100-(x)*100/(0x3f)) 525214501Srpaulo#define BIT4_TO255(x) (255-(x)*255/(0x0f)) 526281681Srpaulo#define BIT6_TO255(x) (255-(x)*255/(0x3f)) 527281681Srpaulo#define V100_TOBIT6(x) (0x3f*(100-x)/100) 528281681Srpaulo#define V100_TOBIT4(x) (0x0f*(100-x)/100) 529281681Srpaulo#define AC97ENCODE(x_muted, x_left, x_right) (((x_muted & 1)<<15) | ((x_left & 0x3f)<<8) | (x_right & 0x3f)) 530281681Srpaulo 531281681Srpaulostatic int 532281681Srpauloemu_ac97_read_emulation(struct emu_pcm_info *sc, int regno) 533281681Srpaulo{ 534281681Srpaulo int use_ac97; 535281681Srpaulo int emulated; 536281681Srpaulo int tmp; 537252190Srpaulo 538252190Srpaulo use_ac97 = 1; 539252190Srpaulo emulated = 0; 540252190Srpaulo 541281681Srpaulo switch (regno) { 542281681Srpaulo case AC97_MIX_MASTER: 543281681Srpaulo emulated = sc->ac97_state[AC97_MIX_MASTER]; 544281681Srpaulo use_ac97 = 0; 545281681Srpaulo break; 546281681Srpaulo case AC97_MIX_PCM: 547281681Srpaulo emulated = sc->ac97_state[AC97_MIX_PCM]; 548281681Srpaulo use_ac97 = 0; 549281681Srpaulo break; 550281681Srpaulo case AC97_REG_RECSEL: 551281681Srpaulo emulated = 0x0505; 552252190Srpaulo use_ac97 = 0; 553214501Srpaulo break; 554281681Srpaulo case AC97_MIX_RGAIN: 555281681Srpaulo emulated = sc->ac97_state[AC97_MIX_RGAIN]; 556214501Srpaulo use_ac97 = 0; 557214501Srpaulo break; 558214501Srpaulo } 559214501Srpaulo 560281681Srpaulo emu_wr(sc->card, EMU_AC97ADDR, regno, 1); 561281681Srpaulo tmp = emu_rd(sc->card, EMU_AC97DATA, 2); 562214501Srpaulo 563214501Srpaulo if (use_ac97) 564214501Srpaulo emulated = tmp; 565324714Scy 566214501Srpaulo return (emulated); 567214501Srpaulo} 568252190Srpaulo 569324714Scystatic void 570214501Srpauloemu_ac97_write_emulation(struct emu_pcm_info *sc, int regno, uint32_t data) 571252190Srpaulo{ 572252190Srpaulo int write_ac97; 573214501Srpaulo int left, right; 574324714Scy uint32_t emu_left, emu_right; 575214501Srpaulo int is_mute; 576214501Srpaulo 577214501Srpaulo write_ac97 = 1; 578324714Scy 579214501Srpaulo left = AC97LEFT(data); 580214501Srpaulo emu_left = BIT6_TO100(left); /* We show us as 6-bit AC97 mixer */ 581214501Srpaulo right = AC97RIGHT(data); 582214501Srpaulo emu_right = BIT6_TO100(right); 583214501Srpaulo is_mute = AC97MUTE(data); 584214501Srpaulo if (is_mute) 585214501Srpaulo emu_left = emu_right = 0; 586214501Srpaulo 587214501Srpaulo switch (regno) { 588214501Srpaulo /* TODO: reset emulator on AC97_RESET */ 589214501Srpaulo case AC97_MIX_MASTER: 590214501Srpaulo emumix_set_volume(sc->card, M_MASTER_FRONT_L, emu_left); 591214501Srpaulo emumix_set_volume(sc->card, M_MASTER_FRONT_R, emu_right); 592214501Srpaulo sc->ac97_state[AC97_MIX_MASTER] = data & (0x8000 | 0x3f3f); 593252190Srpaulo data = 0x8000; /* Mute AC97 main out */ 594214501Srpaulo break; 595214501Srpaulo case AC97_MIX_PCM: /* PCM OUT VOL */ 596252190Srpaulo emumix_set_volume(sc->card, M_FX0_FRONT_L, emu_left); 597214501Srpaulo emumix_set_volume(sc->card, M_FX1_FRONT_R, emu_right); 598214501Srpaulo sc->ac97_state[AC97_MIX_PCM] = data & (0x8000 | 0x3f3f); 599214501Srpaulo data = 0x8000; /* Mute AC97 PCM out */ 600214501Srpaulo break; 601214501Srpaulo case AC97_REG_RECSEL: 602324714Scy /* 603214501Srpaulo * PCM recording source is set to "stereo mix" (labeled "vol" 604324714Scy * in mixer). There is no 'playback' from AC97 codec - 605214501Srpaulo * if you want to hear anything from AC97 you have to _record_ 606324714Scy * it. Keep things simple and record "stereo mix". 607214501Srpaulo */ 608214501Srpaulo data = 0x0505; 609214501Srpaulo break; 610214501Srpaulo case AC97_MIX_RGAIN: /* RECORD GAIN */ 611214501Srpaulo emu_left = BIT4_TO100(left); /* rgain is 4-bit */ 612214501Srpaulo emu_right = BIT4_TO100(right); 613214501Srpaulo emumix_set_volume(sc->card, M_MASTER_REC_L, 100-emu_left); 614214501Srpaulo emumix_set_volume(sc->card, M_MASTER_REC_R, 100-emu_right); 615214501Srpaulo /* 616214501Srpaulo * Record gain on AC97 should stay zero to get AC97 sound on 617214501Srpaulo * AC97_[RL] connectors on EMU10K2 chip. AC97 on Audigy is not 618214501Srpaulo * directly connected to any output, only to EMU10K2 chip Use 619214501Srpaulo * this control to set AC97 mix volume inside EMU10K2 chip 620214501Srpaulo */ 621214501Srpaulo sc->ac97_state[AC97_MIX_RGAIN] = data & (0x8000 | 0x0f0f); 622214501Srpaulo data = 0x0000; 623214501Srpaulo break; 624214501Srpaulo } 625214501Srpaulo if (write_ac97) { 626214501Srpaulo emu_wr(sc->card, EMU_AC97ADDR, regno, 1); 627324714Scy emu_wr(sc->card, EMU_AC97DATA, data, 2); 628214501Srpaulo } 629214501Srpaulo} 630214501Srpaulo 631214501Srpaulostatic int 632214501Srpauloemu_erdcd(kobj_t obj __unused, void *devinfo, int regno) 633324714Scy{ 634214501Srpaulo struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 635214501Srpaulo 636214501Srpaulo return (emu_ac97_read_emulation(sc, regno)); 637214501Srpaulo} 638214501Srpaulo 639214501Srpaulostatic int 640252190Srpauloemu_ewrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data) 641214501Srpaulo{ 642214501Srpaulo struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 643324714Scy 644252190Srpaulo emu_ac97_write_emulation(sc, regno, data); 645214501Srpaulo return (0); 646214501Srpaulo} 647214501Srpaulo 648214501Srpaulostatic kobj_method_t emu_eac97_methods[] = { 649214501Srpaulo KOBJMETHOD(ac97_read, emu_erdcd), 650252190Srpaulo KOBJMETHOD(ac97_write, emu_ewrcd), 651214501Srpaulo KOBJMETHOD_END 652214501Srpaulo}; 653252190SrpauloAC97_DECLARE(emu_eac97); 654214501Srpaulo 655214501Srpaulo/* real ac97 codec */ 656324714Scystatic int 657214501Srpauloemu_rdcd(kobj_t obj __unused, void *devinfo, int regno) 658214501Srpaulo{ 659214501Srpaulo int rd; 660214501Srpaulo struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 661324714Scy 662324714Scy KASSERT(sc->card != NULL, ("emu_rdcd: no soundcard")); 663214501Srpaulo emu_wr(sc->card, EMU_AC97ADDR, regno, 1); 664214501Srpaulo rd = emu_rd(sc->card, EMU_AC97DATA, 2); 665214501Srpaulo return (rd); 666214501Srpaulo} 667324714Scy 668324714Scystatic int 669214501Srpauloemu_wrcd(kobj_t obj __unused, void *devinfo, int regno, uint32_t data) 670214501Srpaulo{ 671214501Srpaulo struct emu_pcm_info *sc = (struct emu_pcm_info *)devinfo; 672281681Srpaulo 673281681Srpaulo KASSERT(sc->card != NULL, ("emu_wrcd: no soundcard")); 674214501Srpaulo emu_wr(sc->card, EMU_AC97ADDR, regno, 1); 675214501Srpaulo emu_wr(sc->card, EMU_AC97DATA, data, 2); 676214501Srpaulo return (0); 677214501Srpaulo} 678214501Srpaulo 679214501Srpaulostatic kobj_method_t emu_ac97_methods[] = { 680214501Srpaulo KOBJMETHOD(ac97_read, emu_rdcd), 681214501Srpaulo KOBJMETHOD(ac97_write, emu_wrcd), 682214501Srpaulo KOBJMETHOD_END 683214501Srpaulo}; 684214501SrpauloAC97_DECLARE(emu_ac97); 685214501Srpaulo 686252190Srpaulo 687214501Srpaulostatic int 688252190Srpauloemu_k1_recval(int speed) 689214501Srpaulo{ 690214501Srpaulo int val; 691214501Srpaulo 692214501Srpaulo val = 0; 693214501Srpaulo while ((val < 7) && (speed < emu10k1_adcspeed[val])) 694214501Srpaulo val++; 695324714Scy return (val); 696214501Srpaulo} 697214501Srpaulo 698214501Srpaulostatic int 699214501Srpauloemu_k2_recval(int speed) 700214501Srpaulo{ 701214501Srpaulo int val; 702214501Srpaulo 703214501Srpaulo val = 0; 704214501Srpaulo while ((val < 8) && (speed < emu10k2_adcspeed[val])) 705214501Srpaulo val++; 706214501Srpaulo return (val); 707214501Srpaulo} 708252190Srpaulo 709214501Srpaulostatic void * 710252190Srpauloemupchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 711252190Srpaulo{ 712252190Srpaulo struct emu_pcm_info *sc = devinfo; 713252190Srpaulo struct emu_pcm_pchinfo *ch; 714252190Srpaulo void *r; 715252190Srpaulo 716252190Srpaulo KASSERT(dir == PCMDIR_PLAY, ("emupchan_init: bad direction")); 717252190Srpaulo KASSERT(sc->card != NULL, ("empchan_init: no soundcard")); 718252190Srpaulo 719341618Scy 720341618Scy if (sc->pnum >= MAX_CHANNELS) 721341618Scy return (NULL); 722341618Scy ch = &(sc->pch[sc->pnum++]); 723252190Srpaulo ch->buffer = b; 724252190Srpaulo ch->pcm = sc; 725341618Scy ch->channel = c; 726341618Scy ch->blksz = sc->bufsz; 727252190Srpaulo ch->fmt = SND_FORMAT(AFMT_U8, 1, 0); 728252190Srpaulo ch->spd = 8000; 729252190Srpaulo ch->master = emu_valloc(sc->card); 730252190Srpaulo /* 731252190Srpaulo * XXX we have to allocate slave even for mono channel until we 732252190Srpaulo * fix emu_vfree to handle this case. 733252190Srpaulo */ 734252190Srpaulo ch->slave = emu_valloc(sc->card); 735252190Srpaulo ch->timer = emu_timer_create(sc->card); 736252190Srpaulo r = (emu_vinit(sc->card, ch->master, ch->slave, EMU_PLAY_BUFSZ, ch->buffer)) ? NULL : ch; 737252190Srpaulo return (r); 738252190Srpaulo} 739252190Srpaulo 740252190Srpaulostatic int 741252190Srpauloemupchan_free(kobj_t obj __unused, void *c_devinfo) 742252190Srpaulo{ 743252190Srpaulo struct emu_pcm_pchinfo *ch = c_devinfo; 744252190Srpaulo struct emu_pcm_info *sc = ch->pcm; 745252190Srpaulo 746252190Srpaulo emu_timer_clear(sc->card, ch->timer); 747252190Srpaulo if (ch->slave != NULL) 748252190Srpaulo emu_vfree(sc->card, ch->slave); 749252190Srpaulo emu_vfree(sc->card, ch->master); 750252190Srpaulo return (0); 751252190Srpaulo} 752252190Srpaulo 753252190Srpaulostatic int 754252190Srpauloemupchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format) 755252190Srpaulo{ 756252190Srpaulo struct emu_pcm_pchinfo *ch = c_devinfo; 757252190Srpaulo 758252190Srpaulo ch->fmt = format; 759214501Srpaulo return (0); 760214501Srpaulo} 761214501Srpaulo 762214501Srpaulostatic uint32_t 763252190Srpauloemupchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 764214501Srpaulo{ 765214501Srpaulo struct emu_pcm_pchinfo *ch = c_devinfo; 766252190Srpaulo 767214501Srpaulo ch->spd = speed; 768214501Srpaulo return (ch->spd); 769214501Srpaulo} 770214501Srpaulo 771214501Srpaulostatic uint32_t 772214501Srpauloemupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 773214501Srpaulo{ 774214501Srpaulo struct emu_pcm_pchinfo *ch = c_devinfo; 775324714Scy struct emu_pcm_info *sc = ch->pcm; 776214501Srpaulo 777214501Srpaulo if (blocksize > ch->pcm->bufsz) 778214501Srpaulo blocksize = ch->pcm->bufsz; 779214501Srpaulo snd_mtxlock(sc->lock); 780214501Srpaulo ch->blksz = blocksize; 781214501Srpaulo emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer)); 782214501Srpaulo snd_mtxunlock(sc->lock); 783214501Srpaulo return (ch->blksz); 784214501Srpaulo} 785214501Srpaulo 786214501Srpaulostatic int 787252190Srpauloemupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 788214501Srpaulo{ 789214501Srpaulo struct emu_pcm_pchinfo *ch = c_devinfo; 790252190Srpaulo struct emu_pcm_info *sc = ch->pcm; 791214501Srpaulo 792214501Srpaulo if (!PCMTRIG_COMMON(go)) 793214501Srpaulo return (0); 794214501Srpaulo 795214501Srpaulo snd_mtxlock(sc->lock); /* XXX can we trigger on parallel threads ? */ 796214501Srpaulo if (go == PCMTRIG_START) { 797214501Srpaulo emu_vsetup(ch->master, ch->fmt, ch->spd); 798214501Srpaulo if (AFMT_CHANNEL(ch->fmt) > 1) 799324714Scy emu_vroute(sc->card, &(sc->rt), ch->master); 800214501Srpaulo else 801214501Srpaulo emu_vroute(sc->card, &(sc->rt_mono), ch->master); 802214501Srpaulo emu_vwrite(sc->card, ch->master); 803214501Srpaulo emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer)); 804214501Srpaulo emu_timer_enable(sc->card, ch->timer, 1); 805214501Srpaulo } 806214501Srpaulo /* PCM interrupt handler will handle PCMTRIG_STOP event */ 807214501Srpaulo ch->run = (go == PCMTRIG_START) ? 1 : 0; 808214501Srpaulo emu_vtrigger(sc->card, ch->master, ch->run); 809214501Srpaulo snd_mtxunlock(sc->lock); 810281681Srpaulo return (0); 811281681Srpaulo} 812214501Srpaulo 813281681Srpaulostatic uint32_t 814252190Srpauloemupchan_getptr(kobj_t obj __unused, void *c_devinfo) 815281681Srpaulo{ 816281681Srpaulo struct emu_pcm_pchinfo *ch = c_devinfo; 817281681Srpaulo struct emu_pcm_info *sc = ch->pcm; 818281681Srpaulo int r; 819214501Srpaulo 820281681Srpaulo r = emu_vpos(sc->card, ch->master); 821281681Srpaulo 822281681Srpaulo return (r); 823281681Srpaulo} 824281681Srpaulo 825324714Scystatic struct pcmchan_caps * 826281681Srpauloemupchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused) 827281681Srpaulo{ 828281681Srpaulo struct emu_pcm_pchinfo *ch = c_devinfo; 829281681Srpaulo struct emu_pcm_info *sc = ch->pcm; 830281681Srpaulo 831281681Srpaulo switch (sc->route) { 832214501Srpaulo case RT_FRONT: 833281681Srpaulo /* FALLTHROUGH */ 834281681Srpaulo case RT_REAR: 835281681Srpaulo /* FALLTHROUGH */ 836281681Srpaulo case RT_SIDE: 837281681Srpaulo return (&emu_playcaps); 838281681Srpaulo break; 839281681Srpaulo case RT_CENTER: 840281681Srpaulo /* FALLTHROUGH */ 841214501Srpaulo case RT_SUB: 842281681Srpaulo return (&emu_playcaps_mono); 843281681Srpaulo break; 844281681Srpaulo } 845281681Srpaulo return (NULL); 846281681Srpaulo} 847214501Srpaulo 848281681Srpaulostatic kobj_method_t emupchan_methods[] = { 849281681Srpaulo KOBJMETHOD(channel_init, emupchan_init), 850281681Srpaulo KOBJMETHOD(channel_free, emupchan_free), 851281681Srpaulo KOBJMETHOD(channel_setformat, emupchan_setformat), 852281681Srpaulo KOBJMETHOD(channel_setspeed, emupchan_setspeed), 853281681Srpaulo KOBJMETHOD(channel_setblocksize, emupchan_setblocksize), 854281681Srpaulo KOBJMETHOD(channel_trigger, emupchan_trigger), 855281681Srpaulo KOBJMETHOD(channel_getptr, emupchan_getptr), 856281681Srpaulo KOBJMETHOD(channel_getcaps, emupchan_getcaps), 857214501Srpaulo KOBJMETHOD_END 858214501Srpaulo}; 859289284SrpauloCHANNEL_DECLARE(emupchan); 860281681Srpaulo 861281681Srpaulostatic void * 862214501Srpauloemurchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 863252190Srpaulo{ 864281681Srpaulo struct emu_pcm_info *sc = devinfo; 865252190Srpaulo struct emu_pcm_rchinfo *ch; 866281681Srpaulo 867252190Srpaulo KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction")); 868252190Srpaulo ch = &sc->rch_adc; 869252190Srpaulo ch->buffer = b; 870252190Srpaulo ch->pcm = sc; 871252190Srpaulo ch->channel = c; 872281681Srpaulo ch->blksz = sc->bufsz / 2; /* We rise interrupt for half-full buffer */ 873252190Srpaulo ch->fmt = SND_FORMAT(AFMT_U8, 1, 0); 874252190Srpaulo ch->spd = 8000; 875252190Srpaulo ch->idxreg = sc->is_emu10k1 ? EMU_ADCIDX : EMU_A_ADCIDX; 876252190Srpaulo ch->basereg = EMU_ADCBA; 877252190Srpaulo ch->sizereg = EMU_ADCBS; 878252190Srpaulo ch->setupreg = EMU_ADCCR; 879281681Srpaulo ch->irqmask = EMU_INTE_ADCBUFENABLE; 880252190Srpaulo ch->iprmask = EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL; 881252190Srpaulo 882252190Srpaulo if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0) 883252190Srpaulo return (NULL); 884252190Srpaulo else { 885281681Srpaulo ch->timer = emu_timer_create(sc->card); 886324714Scy emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer)); 887281681Srpaulo emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */ 888281681Srpaulo return (ch); 889281681Srpaulo } 890281681Srpaulo} 891281681Srpaulo 892281681Srpaulostatic int 893324714Scyemurchan_free(kobj_t obj __unused, void *c_devinfo) 894324714Scy{ 895281681Srpaulo struct emu_pcm_rchinfo *ch = c_devinfo; 896281681Srpaulo struct emu_pcm_info *sc = ch->pcm; 897281681Srpaulo 898281681Srpaulo emu_timer_clear(sc->card, ch->timer); 899324714Scy return (0); 900324714Scy} 901324714Scy 902324714Scystatic int 903324714Scyemurchan_setformat(kobj_t obj __unused, void *c_devinfo, uint32_t format) 904324714Scy{ 905324714Scy struct emu_pcm_rchinfo *ch = c_devinfo; 906324714Scy 907324714Scy ch->fmt = format; 908324714Scy return (0); 909252190Srpaulo} 910252190Srpaulo 911252190Srpaulostatic uint32_t 912252190Srpauloemurchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 913252190Srpaulo{ 914281681Srpaulo struct emu_pcm_rchinfo *ch = c_devinfo; 915252190Srpaulo 916252190Srpaulo if (ch->pcm->is_emu10k1) { 917281681Srpaulo speed = emu10k1_adcspeed[emu_k1_recval(speed)]; 918252190Srpaulo } else { 919252190Srpaulo speed = emu10k2_adcspeed[emu_k2_recval(speed)]; 920252190Srpaulo } 921252190Srpaulo ch->spd = speed; 922252190Srpaulo return (ch->spd); 923252190Srpaulo} 924281681Srpaulo 925252190Srpaulostatic uint32_t 926252190Srpauloemurchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 927252190Srpaulo{ 928252190Srpaulo struct emu_pcm_rchinfo *ch = c_devinfo; 929252190Srpaulo struct emu_pcm_info *sc = ch->pcm; 930252190Srpaulo 931281681Srpaulo ch->blksz = blocksize; 932252190Srpaulo /* 933252190Srpaulo * If blocksize is less than half of buffer size we will not get 934341618Scy * BUFHALFFULL interrupt in time and channel will need to generate 935341618Scy * (and use) timer interrupts. Otherwise channel will be marked dead. 936341618Scy */ 937341618Scy if (ch->blksz < (ch->pcm->bufsz / 2)) { 938341618Scy emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer)); 939341618Scy emu_timer_enable(sc->card, ch->timer, 1); 940252190Srpaulo } else { 941252190Srpaulo emu_timer_enable(sc->card, ch->timer, 0); 942252190Srpaulo } 943252190Srpaulo return (ch->blksz); 944252190Srpaulo} 945252190Srpaulo 946252190Srpaulostatic int 947252190Srpauloemurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 948252190Srpaulo{ 949252190Srpaulo struct emu_pcm_rchinfo *ch = c_devinfo; 950252190Srpaulo struct emu_pcm_info *sc = ch->pcm; 951252190Srpaulo uint32_t val, sz; 952252190Srpaulo 953252190Srpaulo if (!PCMTRIG_COMMON(go)) 954252190Srpaulo return (0); 955252190Srpaulo 956289284Srpaulo switch (sc->bufsz) { 957252190Srpaulo case 4096: 958252190Srpaulo sz = EMU_RECBS_BUFSIZE_4096; 959252190Srpaulo break; 960214501Srpaulo case 8192: 961214501Srpaulo sz = EMU_RECBS_BUFSIZE_8192; 962214501Srpaulo break; 963214501Srpaulo case 16384: 964252190Srpaulo sz = EMU_RECBS_BUFSIZE_16384; 965252190Srpaulo break; 966252190Srpaulo case 32768: 967252190Srpaulo sz = EMU_RECBS_BUFSIZE_32768; 968341618Scy break; 969252190Srpaulo case 65536: 970252190Srpaulo sz = EMU_RECBS_BUFSIZE_65536; 971252190Srpaulo break; 972341618Scy default: 973252190Srpaulo sz = EMU_RECBS_BUFSIZE_4096; 974252190Srpaulo } 975252190Srpaulo 976252190Srpaulo snd_mtxlock(sc->lock); 977252190Srpaulo switch (go) { 978252190Srpaulo case PCMTRIG_START: 979252190Srpaulo ch->run = 1; 980252190Srpaulo emu_wrptr(sc->card, 0, ch->sizereg, sz); 981252190Srpaulo val = sc->is_emu10k1 ? EMU_ADCCR_LCHANENABLE : EMU_A_ADCCR_LCHANENABLE; 982252190Srpaulo if (AFMT_CHANNEL(ch->fmt) > 1) 983252190Srpaulo val |= sc->is_emu10k1 ? EMU_ADCCR_RCHANENABLE : EMU_A_ADCCR_RCHANENABLE; 984252190Srpaulo val |= sc->is_emu10k1 ? emu_k1_recval(ch->spd) : emu_k2_recval(ch->spd); 985214501Srpaulo emu_wrptr(sc->card, 0, ch->setupreg, 0); 986341618Scy emu_wrptr(sc->card, 0, ch->setupreg, val); 987214501Srpaulo ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc); 988252190Srpaulo break; 989214501Srpaulo case PCMTRIG_STOP: 990214501Srpaulo /* FALLTHROUGH */ 991341618Scy case PCMTRIG_ABORT: 992214501Srpaulo ch->run = 0; 993214501Srpaulo emu_wrptr(sc->card, 0, ch->sizereg, 0); 994214501Srpaulo if (ch->setupreg) 995252190Srpaulo emu_wrptr(sc->card, 0, ch->setupreg, 0); 996252190Srpaulo (void)emu_intr_unregister(sc->card, ch->ihandle); 997252190Srpaulo break; 998252190Srpaulo case PCMTRIG_EMLDMAWR: 999252190Srpaulo /* FALLTHROUGH */ 1000252190Srpaulo case PCMTRIG_EMLDMARD: 1001252190Srpaulo /* FALLTHROUGH */ 1002252190Srpaulo default: 1003214501Srpaulo break; 1004214501Srpaulo } 1005252190Srpaulo snd_mtxunlock(sc->lock); 1006214501Srpaulo 1007252190Srpaulo return (0); 1008252190Srpaulo} 1009214501Srpaulo 1010214501Srpaulostatic uint32_t 1011252190Srpauloemurchan_getptr(kobj_t obj __unused, void *c_devinfo) 1012252190Srpaulo{ 1013252190Srpaulo struct emu_pcm_rchinfo *ch = c_devinfo; 1014214501Srpaulo struct emu_pcm_info *sc = ch->pcm; 1015214501Srpaulo int r; 1016214501Srpaulo 1017214501Srpaulo r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff; 1018341618Scy 1019341618Scy return (r); 1020214501Srpaulo} 1021252190Srpaulo 1022252190Srpaulostatic struct pcmchan_caps * 1023252190Srpauloemurchan_getcaps(kobj_t obj __unused, void *c_devinfo __unused) 1024252190Srpaulo{ 1025252190Srpaulo return (&emu_reccaps_adc); 1026252190Srpaulo} 1027252190Srpaulo 1028252190Srpaulostatic kobj_method_t emurchan_methods[] = { 1029252190Srpaulo KOBJMETHOD(channel_init, emurchan_init), 1030252190Srpaulo KOBJMETHOD(channel_free, emurchan_free), 1031252190Srpaulo KOBJMETHOD(channel_setformat, emurchan_setformat), 1032252190Srpaulo KOBJMETHOD(channel_setspeed, emurchan_setspeed), 1033252190Srpaulo KOBJMETHOD(channel_setblocksize, emurchan_setblocksize), 1034214501Srpaulo KOBJMETHOD(channel_trigger, emurchan_trigger), 1035252190Srpaulo KOBJMETHOD(channel_getptr, emurchan_getptr), 1036252190Srpaulo KOBJMETHOD(channel_getcaps, emurchan_getcaps), 1037214501Srpaulo KOBJMETHOD_END 1038214501Srpaulo}; 1039214501SrpauloCHANNEL_DECLARE(emurchan); 1040252190Srpaulo 1041252190Srpaulostatic void * 1042252190Srpauloemufxrchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir __unused) 1043214501Srpaulo{ 1044252190Srpaulo struct emu_pcm_info *sc = devinfo; 1045252190Srpaulo struct emu_pcm_rchinfo *ch; 1046252190Srpaulo 1047252190Srpaulo KASSERT(dir == PCMDIR_REC, ("emurchan_init: bad direction")); 1048252190Srpaulo 1049252190Srpaulo if (sc == NULL) return (NULL); 1050252190Srpaulo 1051252190Srpaulo ch = &(sc->rch_efx); 1052252190Srpaulo ch->fmt = SND_FORMAT(AFMT_S16_LE, 1, 0); 1053252190Srpaulo ch->spd = sc->is_emu10k1 ? 48000*32 : 48000 * 64; 1054252190Srpaulo ch->idxreg = EMU_FXIDX; 1055252190Srpaulo ch->basereg = EMU_FXBA; 1056252190Srpaulo ch->sizereg = EMU_FXBS; 1057252190Srpaulo ch->irqmask = EMU_INTE_EFXBUFENABLE; 1058252190Srpaulo ch->iprmask = EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL; 1059252190Srpaulo ch->buffer = b; 1060214501Srpaulo ch->pcm = sc; 1061214501Srpaulo ch->channel = c; 1062214501Srpaulo ch->blksz = sc->bufsz / 2; 1063252190Srpaulo 1064214501Srpaulo if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0) 1065214501Srpaulo return (NULL); 1066214501Srpaulo else { 1067214501Srpaulo emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer)); 1068214501Srpaulo emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */ 1069252190Srpaulo return (ch); 1070214501Srpaulo } 1071214501Srpaulo} 1072341618Scy 1073252190Srpaulostatic int 1074341618Scyemufxrchan_setformat(kobj_t obj __unused, void *c_devinfo __unused, uint32_t format) 1075252190Srpaulo{ 1076252190Srpaulo if (format == SND_FORMAT(AFMT_S16_LE, 1, 0)) return (0); 1077252190Srpaulo return (EINVAL); 1078252190Srpaulo} 1079252190Srpaulo 1080252190Srpaulostatic uint32_t 1081341618Scyemufxrchan_setspeed(kobj_t obj __unused, void *c_devinfo, uint32_t speed) 1082252190Srpaulo{ 1083341618Scy struct emu_pcm_rchinfo *ch = c_devinfo; 1084341618Scy 1085341618Scy /* FIXED RATE CHANNEL */ 1086341618Scy return (ch->spd); 1087341618Scy} 1088341618Scy 1089341618Scystatic uint32_t 1090341618Scyemufxrchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize) 1091341618Scy{ 1092341618Scy struct emu_pcm_rchinfo *ch = c_devinfo; 1093341618Scy 1094341618Scy ch->blksz = blocksize; 1095341618Scy /* 1096341618Scy * XXX If blocksize is less than half of buffer size we will not get 1097341618Scy * interrupt in time and channel will die due to interrupt timeout. 1098341618Scy * This should not happen with FX rchan, because it will fill buffer 1099341618Scy * very fast (64K buffer is 0.021seconds on Audigy). 1100341618Scy */ 1101341618Scy if (ch->blksz < (ch->pcm->bufsz / 2)) 1102341618Scy ch->blksz = ch->pcm->bufsz / 2; 1103341618Scy return (ch->blksz); 1104341618Scy} 1105341618Scy 1106252190Srpaulostatic int 1107341618Scyemufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go) 1108341618Scy{ 1109341618Scy struct emu_pcm_rchinfo *ch = c_devinfo; 1110341618Scy struct emu_pcm_info *sc = ch->pcm; 1111341618Scy uint32_t sz; 1112341618Scy 1113341618Scy if (!PCMTRIG_COMMON(go)) 1114341618Scy return (0); 1115341618Scy 1116252190Srpaulo switch (sc->bufsz) { 1117252190Srpaulo case 4096: 1118252190Srpaulo sz = EMU_RECBS_BUFSIZE_4096; 1119252190Srpaulo break; 1120341618Scy case 8192: 1121341618Scy sz = EMU_RECBS_BUFSIZE_8192; 1122252190Srpaulo break; 1123252190Srpaulo case 16384: 1124252190Srpaulo sz = EMU_RECBS_BUFSIZE_16384; 1125252190Srpaulo break; 1126252190Srpaulo case 32768: 1127252190Srpaulo sz = EMU_RECBS_BUFSIZE_32768; 1128252190Srpaulo break; 1129341618Scy case 65536: 1130252190Srpaulo sz = EMU_RECBS_BUFSIZE_65536; 1131252190Srpaulo break; 1132252190Srpaulo default: 1133252190Srpaulo sz = EMU_RECBS_BUFSIZE_4096; 1134252190Srpaulo } 1135252190Srpaulo 1136252190Srpaulo snd_mtxlock(sc->lock); 1137252190Srpaulo switch (go) { 1138252190Srpaulo case PCMTRIG_START: 1139252190Srpaulo ch->run = 1; 1140252190Srpaulo emu_wrptr(sc->card, 0, ch->sizereg, sz); 1141252190Srpaulo ch->ihandle = emu_intr_register(sc->card, ch->irqmask, ch->iprmask, &emu_pcm_intr, sc); 1142252190Srpaulo /* 1143252190Srpaulo * SB Live! is limited to 32 mono channels. Audigy 1144252190Srpaulo * has 64 mono channels. Channels are enabled 1145252190Srpaulo * by setting a bit in EMU_A_FXWC[1|2] registers. 1146252190Srpaulo */ 1147252190Srpaulo /* XXX there is no way to demultiplex this streams for now */ 1148252190Srpaulo if (sc->is_emu10k1) { 1149252190Srpaulo emu_wrptr(sc->card, 0, EMU_FXWC, 0xffffffff); 1150252190Srpaulo } else { 1151252190Srpaulo emu_wrptr(sc->card, 0, EMU_A_FXWC1, 0xffffffff); 1152252190Srpaulo emu_wrptr(sc->card, 0, EMU_A_FXWC2, 0xffffffff); 1153252190Srpaulo } 1154252190Srpaulo break; 1155252190Srpaulo case PCMTRIG_STOP: 1156252190Srpaulo /* FALLTHROUGH */ 1157252190Srpaulo case PCMTRIG_ABORT: 1158252190Srpaulo ch->run = 0; 1159252190Srpaulo if (sc->is_emu10k1) { 1160252190Srpaulo emu_wrptr(sc->card, 0, EMU_FXWC, 0x0); 1161252190Srpaulo } else { 1162252190Srpaulo emu_wrptr(sc->card, 0, EMU_A_FXWC1, 0x0); 1163252190Srpaulo emu_wrptr(sc->card, 0, EMU_A_FXWC2, 0x0); 1164252190Srpaulo } 1165252190Srpaulo emu_wrptr(sc->card, 0, ch->sizereg, 0); 1166252190Srpaulo (void)emu_intr_unregister(sc->card, ch->ihandle); 1167252190Srpaulo break; 1168252190Srpaulo case PCMTRIG_EMLDMAWR: 1169252190Srpaulo /* FALLTHROUGH */ 1170252190Srpaulo case PCMTRIG_EMLDMARD: 1171252190Srpaulo /* FALLTHROUGH */ 1172341618Scy default: 1173252190Srpaulo break; 1174214501Srpaulo } 1175252190Srpaulo snd_mtxunlock(sc->lock); 1176214501Srpaulo 1177214501Srpaulo return (0); 1178214501Srpaulo} 1179214501Srpaulo 1180214501Srpaulostatic uint32_t 1181214501Srpauloemufxrchan_getptr(kobj_t obj __unused, void *c_devinfo) 1182214501Srpaulo{ 1183214501Srpaulo struct emu_pcm_rchinfo *ch = c_devinfo; 1184214501Srpaulo struct emu_pcm_info *sc = ch->pcm; 1185324714Scy int r; 1186324714Scy 1187214501Srpaulo r = emu_rdptr(sc->card, 0, ch->idxreg) & 0x0000ffff; 1188214501Srpaulo 1189214501Srpaulo return (r); 1190214501Srpaulo} 1191214501Srpaulo 1192214501Srpaulostatic struct pcmchan_caps * 1193214501Srpauloemufxrchan_getcaps(kobj_t obj __unused, void *c_devinfo) 1194214501Srpaulo{ 1195214501Srpaulo struct emu_pcm_rchinfo *ch = c_devinfo; 1196252190Srpaulo struct emu_pcm_info *sc = ch->pcm; 1197214501Srpaulo 1198252190Srpaulo if (sc->is_emu10k1) 1199214501Srpaulo return (&emu_reccaps_efx_live); 1200252190Srpaulo return (&emu_reccaps_efx_audigy); 1201252190Srpaulo 1202252190Srpaulo} 1203252190Srpaulo 1204214501Srpaulostatic int 1205252190Srpauloemufxrchan_getrates(kobj_t obj __unused, void *c_devinfo, int **rates) 1206214501Srpaulo{ 1207214501Srpaulo struct emu_pcm_rchinfo *ch = c_devinfo; 1208214501Srpaulo struct emu_pcm_info *sc = ch->pcm; 1209214501Srpaulo 1210252190Srpaulo if (sc->is_emu10k1) 1211214501Srpaulo *rates = emu_rates_live; 1212214501Srpaulo else 1213214501Srpaulo *rates = emu_rates_audigy; 1214214501Srpaulo 1215214501Srpaulo return 1; 1216214501Srpaulo} 1217214501Srpaulo 1218252190Srpaulostatic kobj_method_t emufxrchan_methods[] = { 1219252190Srpaulo KOBJMETHOD(channel_init, emufxrchan_init), 1220252190Srpaulo KOBJMETHOD(channel_setformat, emufxrchan_setformat), 1221346563Scy KOBJMETHOD(channel_setspeed, emufxrchan_setspeed), 1222252190Srpaulo KOBJMETHOD(channel_setblocksize, emufxrchan_setblocksize), 1223252190Srpaulo KOBJMETHOD(channel_trigger, emufxrchan_trigger), 1224252190Srpaulo KOBJMETHOD(channel_getptr, emufxrchan_getptr), 1225252190Srpaulo KOBJMETHOD(channel_getcaps, emufxrchan_getcaps), 1226252190Srpaulo KOBJMETHOD(channel_getrates, emufxrchan_getrates), 1227214501Srpaulo KOBJMETHOD_END 1228214501Srpaulo}; 1229214501SrpauloCHANNEL_DECLARE(emufxrchan); 1230214501Srpaulo 1231214501Srpaulo 1232214501Srpaulostatic uint32_t 1233252190Srpauloemu_pcm_intr(void *pcm, uint32_t stat) 1234214501Srpaulo{ 1235324714Scy struct emu_pcm_info *sc = (struct emu_pcm_info *)pcm; 1236214501Srpaulo uint32_t ack; 1237324714Scy int i; 1238324714Scy 1239214501Srpaulo ack = 0; 1240214501Srpaulo 1241214501Srpaulo snd_mtxlock(sc->lock); 1242214501Srpaulo 1243252190Srpaulo if (stat & EMU_IPR_INTERVALTIMER) { 1244214501Srpaulo ack |= EMU_IPR_INTERVALTIMER; 1245214501Srpaulo for (i = 0; i < MAX_CHANNELS; i++) 1246289284Srpaulo if (sc->pch[i].channel) { 1247214501Srpaulo if (sc->pch[i].run == 1) { 1248214501Srpaulo snd_mtxunlock(sc->lock); 1249324714Scy chn_intr(sc->pch[i].channel); 1250214501Srpaulo snd_mtxlock(sc->lock); 1251214501Srpaulo } else 1252324714Scy emu_timer_enable(sc->card, sc->pch[i].timer, 0); 1253214501Srpaulo } 1254214501Srpaulo /* ADC may install timer to get low-latency interrupts */ 1255214501Srpaulo if ((sc->rch_adc.channel) && (sc->rch_adc.run)) { 1256214501Srpaulo snd_mtxunlock(sc->lock); 1257214501Srpaulo chn_intr(sc->rch_adc.channel); 1258214501Srpaulo snd_mtxlock(sc->lock); 1259214501Srpaulo } 1260214501Srpaulo /* 1261214501Srpaulo * EFX does not use timer, because it will fill 1262214501Srpaulo * buffer at least 32x times faster than ADC. 1263214501Srpaulo */ 1264214501Srpaulo } 1265214501Srpaulo 1266214501Srpaulo 1267214501Srpaulo if (stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL)) { 1268214501Srpaulo ack |= stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL); 1269214501Srpaulo if (sc->rch_adc.channel) { 1270214501Srpaulo snd_mtxunlock(sc->lock); 1271214501Srpaulo chn_intr(sc->rch_adc.channel); 1272214501Srpaulo snd_mtxlock(sc->lock); 1273214501Srpaulo } 1274214501Srpaulo } 1275214501Srpaulo 1276324714Scy if (stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL)) { 1277214501Srpaulo ack |= stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL); 1278324714Scy if (sc->rch_efx.channel) { 1279214501Srpaulo snd_mtxunlock(sc->lock); 1280214501Srpaulo chn_intr(sc->rch_efx.channel); 1281214501Srpaulo snd_mtxlock(sc->lock); 1282214501Srpaulo } 1283324714Scy } 1284214501Srpaulo snd_mtxunlock(sc->lock); 1285324714Scy 1286214501Srpaulo return (ack); 1287324714Scy} 1288214501Srpaulo 1289324714Scystatic int 1290214501Srpauloemu_pcm_init(struct emu_pcm_info *sc) 1291324714Scy{ 1292214501Srpaulo sc->bufsz = pcm_getbuffersize(sc->dev, EMUPAGESIZE, EMU_REC_BUFSZ, EMU_MAX_BUFSZ); 1293214501Srpaulo return (0); 1294214501Srpaulo} 1295214501Srpaulo 1296324714Scystatic int 1297214501Srpauloemu_pcm_uninit(struct emu_pcm_info *sc __unused) 1298214501Srpaulo{ 1299214501Srpaulo return (0); 1300214501Srpaulo} 1301214501Srpaulo 1302324714Scystatic int 1303214501Srpauloemu_pcm_probe(device_t dev) 1304214501Srpaulo{ 1305214501Srpaulo uintptr_t func, route, r; 1306214501Srpaulo const char *rt; 1307214501Srpaulo char buffer[255]; 1308214501Srpaulo 1309214501Srpaulo r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_FUNC, &func); 1310324714Scy 1311214501Srpaulo if (func != SCF_PCM) 1312214501Srpaulo return (ENXIO); 1313214501Srpaulo 1314214501Srpaulo rt = "UNKNOWN"; 1315252190Srpaulo r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route); 1316252190Srpaulo switch (route) { 1317289284Srpaulo case RT_FRONT: 1318341618Scy rt = "front"; 1319324714Scy break; 1320252190Srpaulo case RT_REAR: 1321252190Srpaulo rt = "rear"; 1322252190Srpaulo break; 1323324714Scy case RT_CENTER: 1324289284Srpaulo rt = "center"; 1325289284Srpaulo break; 1326289284Srpaulo case RT_SUB: 1327252190Srpaulo rt = "subwoofer"; 1328252190Srpaulo break; 1329252190Srpaulo case RT_SIDE: 1330252190Srpaulo rt = "side"; 1331341618Scy break; 1332289284Srpaulo case RT_MCHRECORD: 1333289284Srpaulo rt = "multichannel recording"; 1334341618Scy break; 1335341618Scy } 1336289284Srpaulo 1337289284Srpaulo snprintf(buffer, 255, "EMU10Kx DSP %s PCM interface", rt); 1338252190Srpaulo device_set_desc_copy(dev, buffer); 1339252190Srpaulo return (0); 1340252190Srpaulo} 1341252190Srpaulo 1342341618Scystatic int 1343289284Srpauloemu_pcm_attach(device_t dev) 1344341618Scy{ 1345289284Srpaulo struct emu_pcm_info *sc; 1346252190Srpaulo unsigned int i; 1347289284Srpaulo char status[SND_STATUSLEN]; 1348324714Scy uint32_t inte, ipr; 1349289284Srpaulo uintptr_t route, r, ivar; 1350289284Srpaulo 1351289284Srpaulo sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO); 1352252190Srpaulo sc->card = (struct emu_sc_info *)(device_get_softc(device_get_parent(dev))); 1353252190Srpaulo if (sc->card == NULL) { 1354252190Srpaulo device_printf(dev, "cannot get bridge conf\n"); 1355252190Srpaulo free(sc, M_DEVBUF); 1356289284Srpaulo return (ENXIO); 1357214501Srpaulo } 1358214501Srpaulo 1359214501Srpaulo sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10kx pcm softc"); 1360341618Scy sc->dev = dev; 1361341618Scy 1362341618Scy r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ISEMU10K1, &ivar); 1363341618Scy sc->is_emu10k1 = ivar ? 1 : 0; 1364341618Scy 1365341618Scy r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_MCH_DISABLED, &ivar); 1366341618Scy sc->mch_disabled = ivar ? 1 : 0; 1367341618Scy 1368341618Scy sc->codec = NULL; 1369341618Scy 1370341618Scy for (i = 0; i < 8; i++) { 1371341618Scy sc->rt.routing_left[i] = i; 1372341618Scy sc->rt.amounts_left[i] = 0x00; 1373341618Scy sc->rt.routing_right[i] = i; 1374341618Scy sc->rt.amounts_right[i] = 0x00; 1375341618Scy } 1376341618Scy 1377341618Scy for (i = 0; i < 8; i++) { 1378341618Scy sc->rt_mono.routing_left[i] = i; 1379341618Scy sc->rt_mono.amounts_left[i] = 0x00; 1380341618Scy sc->rt_mono.routing_right[i] = i; 1381341618Scy sc->rt_mono.amounts_right[i] = 0x00; 1382341618Scy } 1383341618Scy 1384341618Scy sc->emu10k1_volcache[0][0] = 75; 1385341618Scy sc->emu10k1_volcache[1][0] = 75; 1386341618Scy sc->emu10k1_volcache[0][1] = 75; 1387341618Scy sc->emu10k1_volcache[1][1] = 75; 1388341618Scy r = BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ROUTE, &route); 1389341618Scy sc->route = route; 1390341618Scy switch (route) { 1391341618Scy case RT_FRONT: 1392341618Scy sc->rt.amounts_left[0] = 0xff; 1393341618Scy sc->rt.amounts_right[1] = 0xff; 1394252190Srpaulo sc->rt_mono.amounts_left[0] = 0xff; 1395252190Srpaulo sc->rt_mono.amounts_left[1] = 0xff; 1396252190Srpaulo if (sc->is_emu10k1) 1397252190Srpaulo sc->codec = AC97_CREATE(dev, sc, emu_ac97); 1398252190Srpaulo else 1399252190Srpaulo sc->codec = AC97_CREATE(dev, sc, emu_eac97); 1400252190Srpaulo sc->ac97_mixerclass = NULL; 1401252190Srpaulo if (sc->codec != NULL) 1402252190Srpaulo sc->ac97_mixerclass = ac97_getmixerclass(); 1403252190Srpaulo if (mixer_init(dev, &emudspmixer_class, sc)) { 1404252190Srpaulo device_printf(dev, "failed to initialize DSP mixer\n"); 1405252190Srpaulo goto bad; 1406252190Srpaulo } 1407252190Srpaulo break; 1408252190Srpaulo case RT_REAR: 1409252190Srpaulo sc->rt.amounts_left[2] = 0xff; 1410252190Srpaulo sc->rt.amounts_right[3] = 0xff; 1411252190Srpaulo sc->rt_mono.amounts_left[2] = 0xff; 1412281681Srpaulo sc->rt_mono.amounts_left[3] = 0xff; 1413252190Srpaulo if (mixer_init(dev, &emudspmixer_class, sc)) { 1414252190Srpaulo device_printf(dev, "failed to initialize mixer\n"); 1415252190Srpaulo goto bad; 1416252190Srpaulo } 1417252190Srpaulo break; 1418252190Srpaulo case RT_CENTER: 1419252190Srpaulo sc->rt.amounts_left[4] = 0xff; 1420252190Srpaulo sc->rt_mono.amounts_left[4] = 0xff; 1421252190Srpaulo if (mixer_init(dev, &emudspmixer_class, sc)) { 1422252190Srpaulo device_printf(dev, "failed to initialize mixer\n"); 1423252190Srpaulo goto bad; 1424252190Srpaulo } 1425252190Srpaulo break; 1426252190Srpaulo case RT_SUB: 1427252190Srpaulo sc->rt.amounts_left[5] = 0xff; 1428252190Srpaulo sc->rt_mono.amounts_left[5] = 0xff; 1429252190Srpaulo if (mixer_init(dev, &emudspmixer_class, sc)) { 1430252190Srpaulo device_printf(dev, "failed to initialize mixer\n"); 1431252190Srpaulo goto bad; 1432252190Srpaulo } 1433252190Srpaulo break; 1434252190Srpaulo case RT_SIDE: 1435252190Srpaulo sc->rt.amounts_left[6] = 0xff; 1436252190Srpaulo sc->rt.amounts_right[7] = 0xff; 1437252190Srpaulo sc->rt_mono.amounts_left[6] = 0xff; 1438252190Srpaulo sc->rt_mono.amounts_left[7] = 0xff; 1439252190Srpaulo if (mixer_init(dev, &emudspmixer_class, sc)) { 1440252190Srpaulo device_printf(dev, "failed to initialize mixer\n"); 1441252190Srpaulo goto bad; 1442252190Srpaulo } 1443252190Srpaulo break; 1444252190Srpaulo case RT_MCHRECORD: 1445252190Srpaulo if (mixer_init(dev, &emuefxmixer_class, sc)) { 1446252190Srpaulo device_printf(dev, "failed to initialize EFX mixer\n"); 1447252190Srpaulo goto bad; 1448252190Srpaulo } 1449252190Srpaulo break; 1450252190Srpaulo default: 1451252190Srpaulo device_printf(dev, "invalid default route\n"); 1452252190Srpaulo goto bad; 1453252190Srpaulo } 1454252190Srpaulo 1455252190Srpaulo inte = EMU_INTE_INTERTIMERENB; 1456252190Srpaulo ipr = EMU_IPR_INTERVALTIMER; /* Used by playback & ADC */ 1457252190Srpaulo sc->ihandle = emu_intr_register(sc->card, inte, ipr, &emu_pcm_intr, sc); 1458341618Scy 1459341618Scy if (emu_pcm_init(sc) == -1) { 1460341618Scy device_printf(dev, "unable to initialize PCM part of the card\n"); 1461341618Scy goto bad; 1462341618Scy } 1463252190Srpaulo 1464252190Srpaulo /* 1465252190Srpaulo * We don't register interrupt handler with snd_setup_intr 1466252190Srpaulo * in pcm device. Mark pcm device as MPSAFE manually. 1467252190Srpaulo */ 1468252190Srpaulo pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE); 1469252190Srpaulo 1470252190Srpaulo /* XXX we should better get number of available channels from parent */ 1471214501Srpaulo if (pcm_register(dev, sc, (route == RT_FRONT) ? MAX_CHANNELS : 1, (route == RT_FRONT) ? 1 : 0)) { 1472252190Srpaulo device_printf(dev, "can't register PCM channels!\n"); 1473252190Srpaulo goto bad; 1474252190Srpaulo } 1475252190Srpaulo sc->pnum = 0; 1476341618Scy if (route != RT_MCHRECORD) 1477341618Scy pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc); 1478341618Scy if (route == RT_FRONT) { 1479341618Scy for (i = 1; i < MAX_CHANNELS; i++) 1480252190Srpaulo pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc); 1481252190Srpaulo pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc); 1482252190Srpaulo } 1483252190Srpaulo if (route == RT_MCHRECORD) 1484252190Srpaulo pcm_addchan(dev, PCMDIR_REC, &emufxrchan_class, sc); 1485252190Srpaulo 1486252190Srpaulo snprintf(status, SND_STATUSLEN, "on %s", device_get_nameunit(device_get_parent(dev))); 1487252190Srpaulo pcm_setstatus(dev, status); 1488252190Srpaulo 1489252190Srpaulo return (0); 1490252190Srpaulo 1491324714Scybad: 1492214501Srpaulo if (sc->codec) 1493214501Srpaulo ac97_destroy(sc->codec); 1494214501Srpaulo if (sc->lock) 1495214501Srpaulo snd_mtxfree(sc->lock); 1496214501Srpaulo free(sc, M_DEVBUF); 1497214501Srpaulo return (ENXIO); 1498214501Srpaulo} 1499324714Scy 1500214501Srpaulostatic int 1501214501Srpauloemu_pcm_detach(device_t dev) 1502324714Scy{ 1503214501Srpaulo int r; 1504214501Srpaulo struct emu_pcm_info *sc; 1505324714Scy 1506214501Srpaulo sc = pcm_getdevinfo(dev); 1507214501Srpaulo 1508214501Srpaulo r = pcm_unregister(dev); 1509214501Srpaulo 1510214501Srpaulo if (r) return (r); 1511214501Srpaulo 1512214501Srpaulo emu_pcm_uninit(sc); 1513214501Srpaulo 1514214501Srpaulo if (sc->lock) 1515214501Srpaulo snd_mtxfree(sc->lock); 1516324714Scy free(sc, M_DEVBUF); 1517324714Scy 1518214501Srpaulo return (0); 1519324714Scy} 1520214501Srpaulo 1521214501Srpaulostatic device_method_t emu_pcm_methods[] = { 1522214501Srpaulo DEVMETHOD(device_probe, emu_pcm_probe), 1523214501Srpaulo DEVMETHOD(device_attach, emu_pcm_attach), 1524214501Srpaulo DEVMETHOD(device_detach, emu_pcm_detach), 1525214501Srpaulo 1526214501Srpaulo DEVMETHOD_END 1527214501Srpaulo}; 1528214501Srpaulo 1529252190Srpaulostatic driver_t emu_pcm_driver = { 1530214501Srpaulo "pcm", 1531214501Srpaulo emu_pcm_methods, 1532214501Srpaulo PCM_SOFTC_SIZE, 1533214501Srpaulo NULL, 1534214501Srpaulo 0, 1535214501Srpaulo NULL 1536214501Srpaulo}; 1537324714ScyDRIVER_MODULE(snd_emu10kx_pcm, emu10kx, emu_pcm_driver, pcm_devclass, 0, 0); 1538214501SrpauloMODULE_DEPEND(snd_emu10kx_pcm, snd_emu10kx, SND_EMU10KX_MINVER, SND_EMU10KX_PREFVER, SND_EMU10KX_MAXVER); 1539324714ScyMODULE_DEPEND(snd_emu10kx_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 1540214501SrpauloMODULE_VERSION(snd_emu10kx_pcm, SND_EMU10KX_PREFVER); 1541214501Srpaulo