[linux-block.git] / sound / pci / emu10k1 / emu10k1_callback.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  synth callback routines for Emu10k1
 *
 *  Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
 */

#include <linux/export.h>
#include "emu10k1_synth_local.h"
#include <sound/asoundef.h>

/* voice status */
enum {
	V_FREE=0, V_OFF, V_RELEASED, V_PLAYING, V_END
};

/* Keeps track of what we are finding */
struct best_voice {
	unsigned int time;
	int voice;
};

/*
 * prototypes
 */
static void lookup_voices(struct snd_emux *emux, struct snd_emu10k1 *hw,
			  struct best_voice *best, int active_only);
static struct snd_emux_voice *get_voice(struct snd_emux *emux,
					struct snd_emux_port *port);
static int start_voice(struct snd_emux_voice *vp);
static void trigger_voice(struct snd_emux_voice *vp);
static void release_voice(struct snd_emux_voice *vp);
static void update_voice(struct snd_emux_voice *vp, int update);
static void terminate_voice(struct snd_emux_voice *vp);
static void free_voice(struct snd_emux_voice *vp);
static void set_fmmod(struct snd_emu10k1 *hw, struct snd_emux_voice *vp);
static void set_fm2frq2(struct snd_emu10k1 *hw, struct snd_emux_voice *vp);
static void set_filterQ(struct snd_emu10k1 *hw, struct snd_emux_voice *vp);

/*
 * Ensure a value is between two points
 * macro evaluates its args more than once, so changed to upper-case.
 */
#define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)
#define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)


/*
 * set up operators
 */
static const struct snd_emux_operators emu10k1_ops = {
	.owner =	THIS_MODULE,
	.get_voice =	get_voice,
	.prepare =	start_voice,
	.trigger =	trigger_voice,
	.release =	release_voice,
	.update =	update_voice,
	.terminate =	terminate_voice,
	.free_voice =	free_voice,
	.sample_new =	snd_emu10k1_sample_new,
	.sample_free =	snd_emu10k1_sample_free,
};

void
snd_emu10k1_ops_setup(struct snd_emux *emux)
{
	emux->ops = emu10k1_ops;
}


/*
 * get more voice for pcm
 *
 * terminate most inactive voice and give it as a pcm voice.
 *
 * voice_lock is already held.
 */
int
snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw)
{
	struct snd_emux *emu;
	struct snd_emux_voice *vp;
	struct best_voice best[V_END];
	int i;

	emu = hw->synth;

	lookup_voices(emu, hw, best, 1); /* no OFF voices */
	for (i = 0; i < V_END; i++) {
		if (best[i].voice >= 0) {
			int ch;
			vp = &emu->voices[best[i].voice];
			if ((ch = vp->ch) < 0) {
				/*
				dev_warn(emu->card->dev,
				       "synth_get_voice: ch < 0 (%d) ??", i);
				*/
				continue;
			}
			vp->emu->num_voices--;
			vp->ch = -1;
			vp->state = SNDRV_EMUX_ST_OFF;
			return ch;
		}
	}

	/* not found */
	return -ENOMEM;
}


/*
 * turn off the voice (not terminated)
 */
static void
release_voice(struct snd_emux_voice *vp)
{
	int dcysusv;
	struct snd_emu10k1 *hw;
	
	hw = vp->hw;
	dcysusv = 0x8000 | (unsigned char)vp->reg.parm.modrelease;
	snd_emu10k1_ptr_write(hw, DCYSUSM, vp->ch, dcysusv);
	dcysusv = 0x8000 | (unsigned char)vp->reg.parm.volrelease | DCYSUSV_CHANNELENABLE_MASK;
	snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, dcysusv);
}


/*
 * terminate the voice
 */
static void
terminate_voice(struct snd_emux_voice *vp)
{
	struct snd_emu10k1 *hw;
	
	if (snd_BUG_ON(!vp))
		return;
	hw = vp->hw;
	snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f | DCYSUSV_CHANNELENABLE_MASK);
	if (vp->block) {
		struct snd_emu10k1_memblk *emem;
		emem = (struct snd_emu10k1_memblk *)vp->block;
		if (emem->map_locked > 0)
			emem->map_locked--;
	}
}

/*
 * release the voice to system
 */
static void
free_voice(struct snd_emux_voice *vp)
{
	struct snd_emu10k1 *hw;
	
	hw = vp->hw;
	/* FIXME: emu10k1_synth is broken. */
	/* This can get called with hw == 0 */
	/* Problem apparent on plug, unplug then plug */
	/* on the Audigy 2 ZS Notebook. */
	if (hw && (vp->ch >= 0)) {
		snd_emu10k1_ptr_write(hw, IFATN, vp->ch, 0xff00);
		snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f | DCYSUSV_CHANNELENABLE_MASK);
		// snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0);
		snd_emu10k1_ptr_write(hw, VTFT, vp->ch, 0xffff);
		snd_emu10k1_ptr_write(hw, CVCF, vp->ch, 0xffff);
		snd_emu10k1_voice_free(hw, &hw->voices[vp->ch]);
		vp->emu->num_voices--;
		vp->ch = -1;
	}
}


/*
 * update registers
 */
static void
update_voice(struct snd_emux_voice *vp, int update)
{
	struct snd_emu10k1 *hw;
	
	hw = vp->hw;
	if (update & SNDRV_EMUX_UPDATE_VOLUME)
		snd_emu10k1_ptr_write(hw, IFATN_ATTENUATION, vp->ch, vp->avol);
	if (update & SNDRV_EMUX_UPDATE_PITCH)
		snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);
	if (update & SNDRV_EMUX_UPDATE_PAN) {
		snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_A, vp->ch, vp->apan);
		snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_B, vp->ch, vp->aaux);
	}
	if (update & SNDRV_EMUX_UPDATE_FMMOD)
		set_fmmod(hw, vp);
	if (update & SNDRV_EMUX_UPDATE_TREMFREQ)
		snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
	if (update & SNDRV_EMUX_UPDATE_FM2FRQ2)
		set_fm2frq2(hw, vp);
	if (update & SNDRV_EMUX_UPDATE_Q)
		set_filterQ(hw, vp);
}


/*
 * look up voice table - get the best voice in order of preference
 */
/* spinlock held! */
static void
lookup_voices(struct snd_emux *emu, struct snd_emu10k1 *hw,
	      struct best_voice *best, int active_only)
{
	struct snd_emux_voice *vp;
	struct best_voice *bp;
	int  i;

	for (i = 0; i < V_END; i++) {
		best[i].time = (unsigned int)-1; /* XXX MAX_?INT really */
		best[i].voice = -1;
	}

	/*
	 * Go through them all and get a best one to use.
	 * NOTE: could also look at volume and pick the quietest one.
	 */
	for (i = 0; i < emu->max_voices; i++) {
		int state, val;

		vp = &emu->voices[i];
		state = vp->state;
		if (state == SNDRV_EMUX_ST_OFF) {
			if (vp->ch < 0) {
				if (active_only)
					continue;
				bp = best + V_FREE;
			} else
				bp = best + V_OFF;
		}
		else if (state == SNDRV_EMUX_ST_RELEASED ||
			 state == SNDRV_EMUX_ST_PENDING) {
			bp = best + V_RELEASED;
#if 1
			val = snd_emu10k1_ptr_read(hw, CVCF_CURRENTVOL, vp->ch);
			if (! val)
				bp = best + V_OFF;
#endif
		}
		else if (state == SNDRV_EMUX_ST_STANDBY)
			continue;
		else if (state & SNDRV_EMUX_ST_ON)
			bp = best + V_PLAYING;
		else
			continue;

		/* check if sample is finished playing (non-looping only) */
		if (bp != best + V_OFF && bp != best + V_FREE &&
		    (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_SINGLESHOT)) {
			val = snd_emu10k1_ptr_read(hw, CCCA_CURRADDR, vp->ch);
			if (val >= vp->reg.loopstart)
				bp = best + V_OFF;
		}

		if (vp->time < bp->time) {
			bp->time = vp->time;
			bp->voice = i;
		}
	}
}

/*
 * get an empty voice
 *
 * emu->voice_lock is already held.
 */
static struct snd_emux_voice *
get_voice(struct snd_emux *emu, struct snd_emux_port *port)
{
	struct snd_emu10k1 *hw;
	struct snd_emux_voice *vp;
	struct best_voice best[V_END];
	int i;

	hw = emu->hw;

	lookup_voices(emu, hw, best, 0);
	for (i = 0; i < V_END; i++) {
		if (best[i].voice >= 0) {
			vp = &emu->voices[best[i].voice];
			if (vp->ch < 0) {
				/* allocate a voice */
				struct snd_emu10k1_voice *hwvoice;
				if (snd_emu10k1_voice_alloc(hw, EMU10K1_SYNTH, 1, &hwvoice) < 0 || hwvoice == NULL)
					continue;
				vp->ch = hwvoice->number;
				emu->num_voices++;
			}
			return vp;
		}
	}

	/* not found */
	return NULL;
}

/*
 * prepare envelopes and LFOs
 */
static int
start_voice(struct snd_emux_voice *vp)
{
	unsigned int temp;
	int ch;
	unsigned int addr, mapped_offset;
	struct snd_midi_channel *chan;
	struct snd_emu10k1 *hw;
	struct snd_emu10k1_memblk *emem;
	
	hw = vp->hw;
	ch = vp->ch;
	if (snd_BUG_ON(ch < 0))
		return -EINVAL;
	chan = vp->chan;

	emem = (struct snd_emu10k1_memblk *)vp->block;
	if (emem == NULL)
		return -EINVAL;
	emem->map_locked++;
	if (snd_emu10k1_memblk_map(hw, emem) < 0) {
		/* dev_err(hw->card->devK, "emu: cannot map!\n"); */
		return -ENOMEM;
	}
	mapped_offset = snd_emu10k1_memblk_offset(emem) >> 1;
	vp->reg.start += mapped_offset;
	vp->reg.end += mapped_offset;
	vp->reg.loopstart += mapped_offset;
	vp->reg.loopend += mapped_offset;

	/* set channel routing */
	/* A = left(0), B = right(1), C = reverb(c), D = chorus(d) */
	if (hw->audigy) {
		temp = FXBUS_MIDI_LEFT | (FXBUS_MIDI_RIGHT << 8) | 
			(FXBUS_MIDI_REVERB << 16) | (FXBUS_MIDI_CHORUS << 24);
		snd_emu10k1_ptr_write(hw, A_FXRT1, ch, temp);
	} else {
		temp = (FXBUS_MIDI_LEFT << 16) | (FXBUS_MIDI_RIGHT << 20) | 
			(FXBUS_MIDI_REVERB << 24) | (FXBUS_MIDI_CHORUS << 28);
		snd_emu10k1_ptr_write(hw, FXRT, ch, temp);
	}

	/* channel to be silent and idle */
	snd_emu10k1_ptr_write(hw, DCYSUSV, ch, 0x0000);
	snd_emu10k1_ptr_write(hw, VTFT, ch, 0x0000FFFF);
	snd_emu10k1_ptr_write(hw, CVCF, ch, 0x0000FFFF);
	snd_emu10k1_ptr_write(hw, PTRX, ch, 0);
	snd_emu10k1_ptr_write(hw, CPF, ch, 0);

	/* set pitch offset */
	snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);

	/* set envelope parameters */
	snd_emu10k1_ptr_write(hw, ENVVAL, ch, vp->reg.parm.moddelay);
	snd_emu10k1_ptr_write(hw, ATKHLDM, ch, vp->reg.parm.modatkhld);
	snd_emu10k1_ptr_write(hw, DCYSUSM, ch, vp->reg.parm.moddcysus);
	snd_emu10k1_ptr_write(hw, ENVVOL, ch, vp->reg.parm.voldelay);
	snd_emu10k1_ptr_write(hw, ATKHLDV, ch, vp->reg.parm.volatkhld);
	/* decay/sustain parameter for volume envelope is used
	   for triggerg the voice */

	/* cutoff and volume */
	temp = (unsigned int)vp->acutoff << 8 | (unsigned char)vp->avol;
	snd_emu10k1_ptr_write(hw, IFATN, vp->ch, temp);

	/* modulation envelope heights */
	snd_emu10k1_ptr_write(hw, PEFE, ch, vp->reg.parm.pefe);

	/* lfo1/2 delay */
	snd_emu10k1_ptr_write(hw, LFOVAL1, ch, vp->reg.parm.lfo1delay);
	snd_emu10k1_ptr_write(hw, LFOVAL2, ch, vp->reg.parm.lfo2delay);

	/* lfo1 pitch & cutoff shift */
	set_fmmod(hw, vp);
	/* lfo1 volume & freq */
	snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
	/* lfo2 pitch & freq */
	set_fm2frq2(hw, vp);

	/* reverb and loop start (reverb 8bit, MSB) */
	temp = vp->reg.parm.reverb;
	temp += (int)vp->chan->control[MIDI_CTL_E1_REVERB_DEPTH] * 9 / 10;
	LIMITMAX(temp, 255);
	addr = vp->reg.loopstart;
	snd_emu10k1_ptr_write(hw, PSST, vp->ch, (temp << 24) | addr);

	/* chorus & loop end (chorus 8bit, MSB) */
	addr = vp->reg.loopend;
	temp = vp->reg.parm.chorus;
	temp += (int)chan->control[MIDI_CTL_E3_CHORUS_DEPTH] * 9 / 10;
	LIMITMAX(temp, 255);
	temp = (temp <<24) | addr;
	snd_emu10k1_ptr_write(hw, DSL, ch, temp);

	/* clear filter delay memory */
	snd_emu10k1_ptr_write(hw, Z1, ch, 0);
	snd_emu10k1_ptr_write(hw, Z2, ch, 0);

	/* invalidate maps */
	temp = (hw->silent_page.addr << hw->address_mode) | (hw->address_mode ? MAP_PTI_MASK1 : MAP_PTI_MASK0);
	snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
	snd_emu10k1_ptr_write(hw, MAPB, ch, temp);
#if 0
	/* cache */
	{
		unsigned int val, sample;
		val = 32;
		if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
			sample = 0x80808080;
		else {
			sample = 0;
			val *= 2;
		}

		/* cache */
		snd_emu10k1_ptr_write(hw, CCR, ch, 0x1c << 16);
		snd_emu10k1_ptr_write(hw, CDE, ch, sample);
		snd_emu10k1_ptr_write(hw, CDF, ch, sample);

		/* invalidate maps */
		temp = ((unsigned int)hw->silent_page.addr << hw_address_mode) | (hw->address_mode ? MAP_PTI_MASK1 : MAP_PTI_MASK0);
		snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
		snd_emu10k1_ptr_write(hw, MAPB, ch, temp);
		
		/* fill cache */
		val -= 4;
		val <<= 25;
		val |= 0x1c << 16;
		snd_emu10k1_ptr_write(hw, CCR, ch, val);
	}
#endif

	/* Q & current address (Q 4bit value, MSB) */
	addr = vp->reg.start;
	temp = vp->reg.parm.filterQ;
	temp = (temp<<28) | addr;
	if (vp->apitch < 0xe400)
		temp |= CCCA_INTERPROM_0;
	else {
		unsigned int shift = (vp->apitch - 0xe000) >> 10;
		temp |= shift << 25;
	}
	if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
		temp |= CCCA_8BITSELECT;
	snd_emu10k1_ptr_write(hw, CCCA, ch, temp);

	/* reset volume */
	temp = (unsigned int)vp->vtarget << 16;
	snd_emu10k1_ptr_write(hw, VTFT, ch, temp | vp->ftarget);
	snd_emu10k1_ptr_write(hw, CVCF, ch, temp | 0xff00);
	return 0;
}

/*
 * Start envelope
 */
static void
trigger_voice(struct snd_emux_voice *vp)
{
	unsigned int temp, ptarget;
	struct snd_emu10k1 *hw;
	struct snd_emu10k1_memblk *emem;
	
	hw = vp->hw;

	emem = (struct snd_emu10k1_memblk *)vp->block;
	if (! emem || emem->mapped_page < 0)
		return; /* not mapped */

#if 0
	ptarget = (unsigned int)vp->ptarget << 16;
#else
	ptarget = IP_TO_CP(vp->apitch);
#endif
	/* set pitch target and pan (volume) */
	temp = ptarget | (vp->apan << 8) | vp->aaux;
	snd_emu10k1_ptr_write(hw, PTRX, vp->ch, temp);

	/* pitch target */
	snd_emu10k1_ptr_write(hw, CPF, vp->ch, ptarget);

	/* trigger voice */
	snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, vp->reg.parm.voldcysus|DCYSUSV_CHANNELENABLE_MASK);
}

#define MOD_SENSE 18

/* set lfo1 modulation height and cutoff */
static void
set_fmmod(struct snd_emu10k1 *hw, struct snd_emux_voice *vp)
{
	unsigned short fmmod;
	short pitch;
	unsigned char cutoff;
	int modulation;

	pitch = (char)(vp->reg.parm.fmmod>>8);
	cutoff = (vp->reg.parm.fmmod & 0xff);
	modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
	pitch += (MOD_SENSE * modulation) / 1200;
	LIMITVALUE(pitch, -128, 127);
	fmmod = ((unsigned char)pitch<<8) | cutoff;
	snd_emu10k1_ptr_write(hw, FMMOD, vp->ch, fmmod);
}

/* set lfo2 pitch & frequency */
static void
set_fm2frq2(struct snd_emu10k1 *hw, struct snd_emux_voice *vp)
{
	unsigned short fm2frq2;
	short pitch;
	unsigned char freq;
	int modulation;

	pitch = (char)(vp->reg.parm.fm2frq2>>8);
	freq = vp->reg.parm.fm2frq2 & 0xff;
	modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
	pitch += (MOD_SENSE * modulation) / 1200;
	LIMITVALUE(pitch, -128, 127);
	fm2frq2 = ((unsigned char)pitch<<8) | freq;
	snd_emu10k1_ptr_write(hw, FM2FRQ2, vp->ch, fm2frq2);
}

/* set filterQ */
static void
set_filterQ(struct snd_emu10k1 *hw, struct snd_emux_voice *vp)
{
	unsigned int val;
	val = snd_emu10k1_ptr_read(hw, CCCA, vp->ch) & ~CCCA_RESONANCE;
	val |= (vp->reg.parm.filterQ << 28);
	snd_emu10k1_ptr_write(hw, CCCA, vp->ch, val);
}
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	* synth callback routines for Emu10k1
	4	*
	5	* Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
1da177e4 LT	6	*/
1da177e4 LT	7
d81a6d71	8	#include <linux/export.h>
1da177e4 LT	9	#include "emu10k1_synth_local.h"
	10	#include <sound/asoundef.h>
	11
	12	/* voice status */
	13	enum {
	14	V_FREE=0, V_OFF, V_RELEASED, V_PLAYING, V_END
	15	};
	16
	17	/* Keeps track of what we are finding */
eb4698f3	18	struct best_voice {
1da177e4 LT	19	unsigned int time;
1da177e4 LT	20	int voice;
eb4698f3	21	};
1da177e4 LT	22
	23	/*
	24	* prototypes
	25	*/
c94fa4c9	26	static void lookup_voices(struct snd_emux emux, struct snd_emu10k1 hw,
eb4698f3	27	struct best_voice *best, int active_only);
c94fa4c9	28	static struct snd_emux_voice get_voice(struct snd_emux emux,
eb4698f3 TI	29	struct snd_emux_port *port);
	30	static int start_voice(struct snd_emux_voice *vp);
	31	static void trigger_voice(struct snd_emux_voice *vp);
	32	static void release_voice(struct snd_emux_voice *vp);
	33	static void update_voice(struct snd_emux_voice *vp, int update);
	34	static void terminate_voice(struct snd_emux_voice *vp);
	35	static void free_voice(struct snd_emux_voice *vp);
eb4698f3 TI	36	static void set_fmmod(struct snd_emu10k1 hw, struct snd_emux_voice vp);
	37	static void set_fm2frq2(struct snd_emu10k1 hw, struct snd_emux_voice vp);
	38	static void set_filterQ(struct snd_emu10k1 hw, struct snd_emux_voice vp);
1da177e4 LT	39
	40	/*
	41	* Ensure a value is between two points
	42	* macro evaluates its args more than once, so changed to upper-case.
	43	*/
	44	#define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)
	45	#define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)
	46
	47
	48	/*
	49	* set up operators
	50	*/
3bb9eca9	51	static const struct snd_emux_operators emu10k1_ops = {
1da177e4 LT	52	.owner = THIS_MODULE,
	53	.get_voice = get_voice,
	54	.prepare = start_voice,
	55	.trigger = trigger_voice,
	56	.release = release_voice,
	57	.update = update_voice,
	58	.terminate = terminate_voice,
	59	.free_voice = free_voice,
	60	.sample_new = snd_emu10k1_sample_new,
	61	.sample_free = snd_emu10k1_sample_free,
	62	};
	63
	64	void
c94fa4c9	65	snd_emu10k1_ops_setup(struct snd_emux *emux)
1da177e4	66	{
c94fa4c9	67	emux->ops = emu10k1_ops;
1da177e4 LT	68	}
	69
	70
	71	/*
	72	* get more voice for pcm
	73	*
	74	* terminate most inactive voice and give it as a pcm voice.
95926035 TI	75	*
95926035 TI	76	* voice_lock is already held.
1da177e4 LT	77	*/
1da177e4 LT	78	int
eb4698f3	79	snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw)
1da177e4	80	{
eb4698f3 TI	81	struct snd_emux *emu;
	82	struct snd_emux_voice *vp;
	83	struct best_voice best[V_END];
1da177e4 LT	84	int i;
	85
	86	emu = hw->synth;
	87
1da177e4 LT	88	lookup_voices(emu, hw, best, 1); /* no OFF voices */
	89	for (i = 0; i < V_END; i++) {
	90	if (best[i].voice >= 0) {
	91	int ch;
	92	vp = &emu->voices[best[i].voice];
	93	if ((ch = vp->ch) < 0) {
28a97c19	94	/*
6f002b02	95	dev_warn(emu->card->dev,
28a97c19 TI	96	"synth_get_voice: ch < 0 (%d) ??", i);
28a97c19 TI	97	*/
1da177e4 LT	98	continue;
	99	}
	100	vp->emu->num_voices--;
	101	vp->ch = -1;
	102	vp->state = SNDRV_EMUX_ST_OFF;
1da177e4 LT	103	return ch;
	104	}
	105	}
1da177e4 LT	106
	107	/* not found */
	108	return -ENOMEM;
	109	}
	110
	111
	112	/*
	113	* turn off the voice (not terminated)
	114	*/
	115	static void
eb4698f3	116	release_voice(struct snd_emux_voice *vp)
1da177e4 LT	117	{
1da177e4 LT	118	int dcysusv;
eb4698f3	119	struct snd_emu10k1 *hw;
1da177e4 LT	120
	121	hw = vp->hw;
	122	dcysusv = 0x8000 \| (unsigned char)vp->reg.parm.modrelease;
	123	snd_emu10k1_ptr_write(hw, DCYSUSM, vp->ch, dcysusv);
	124	dcysusv = 0x8000 \| (unsigned char)vp->reg.parm.volrelease \| DCYSUSV_CHANNELENABLE_MASK;
	125	snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, dcysusv);
	126	}
	127
	128
	129	/*
	130	* terminate the voice
	131	*/
	132	static void
eb4698f3	133	terminate_voice(struct snd_emux_voice *vp)
1da177e4	134	{
eb4698f3	135	struct snd_emu10k1 *hw;
1da177e4	136
da3cec35 TI	137	if (snd_BUG_ON(!vp))
da3cec35 TI	138	return;
1da177e4 LT	139	hw = vp->hw;
	140	snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f \| DCYSUSV_CHANNELENABLE_MASK);
	141	if (vp->block) {
eb4698f3 TI	142	struct snd_emu10k1_memblk *emem;
eb4698f3 TI	143	emem = (struct snd_emu10k1_memblk *)vp->block;
1da177e4 LT	144	if (emem->map_locked > 0)
	145	emem->map_locked--;
	146	}
	147	}
	148
	149	/*
	150	* release the voice to system
	151	*/
	152	static void
eb4698f3	153	free_voice(struct snd_emux_voice *vp)
1da177e4	154	{
eb4698f3	155	struct snd_emu10k1 *hw;
1da177e4 LT	156
1da177e4 LT	157	hw = vp->hw;
c94fa4c9 JCD	158	/* FIXME: emu10k1_synth is broken. */
	159	/* This can get called with hw == 0 */
	160	/* Problem apparent on plug, unplug then plug */
	161	/* on the Audigy 2 ZS Notebook. */
	162	if (hw && (vp->ch >= 0)) {
1da177e4 LT	163	snd_emu10k1_ptr_write(hw, IFATN, vp->ch, 0xff00);
	164	snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f \| DCYSUSV_CHANNELENABLE_MASK);
	165	// snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0);
	166	snd_emu10k1_ptr_write(hw, VTFT, vp->ch, 0xffff);
	167	snd_emu10k1_ptr_write(hw, CVCF, vp->ch, 0xffff);
	168	snd_emu10k1_voice_free(hw, &hw->voices[vp->ch]);
	169	vp->emu->num_voices--;
	170	vp->ch = -1;
	171	}
	172	}
	173
	174
	175	/*
	176	* update registers
	177	*/
	178	static void
eb4698f3	179	update_voice(struct snd_emux_voice *vp, int update)
1da177e4	180	{
eb4698f3	181	struct snd_emu10k1 *hw;
1da177e4 LT	182
	183	hw = vp->hw;
	184	if (update & SNDRV_EMUX_UPDATE_VOLUME)
	185	snd_emu10k1_ptr_write(hw, IFATN_ATTENUATION, vp->ch, vp->avol);
	186	if (update & SNDRV_EMUX_UPDATE_PITCH)
	187	snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);
	188	if (update & SNDRV_EMUX_UPDATE_PAN) {
	189	snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_A, vp->ch, vp->apan);
	190	snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_B, vp->ch, vp->aaux);
	191	}
	192	if (update & SNDRV_EMUX_UPDATE_FMMOD)
	193	set_fmmod(hw, vp);
	194	if (update & SNDRV_EMUX_UPDATE_TREMFREQ)
	195	snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
	196	if (update & SNDRV_EMUX_UPDATE_FM2FRQ2)
	197	set_fm2frq2(hw, vp);
	198	if (update & SNDRV_EMUX_UPDATE_Q)
	199	set_filterQ(hw, vp);
	200	}
	201
	202
	203	/*
	204	* look up voice table - get the best voice in order of preference
	205	*/
	206	/* spinlock held! */
	207	static void
eb4698f3 TI	208	lookup_voices(struct snd_emux emu, struct snd_emu10k1 hw,
eb4698f3 TI	209	struct best_voice *best, int active_only)
1da177e4	210	{
eb4698f3 TI	211	struct snd_emux_voice *vp;
eb4698f3 TI	212	struct best_voice *bp;
1da177e4 LT	213	int i;
	214
	215	for (i = 0; i < V_END; i++) {
395d9dd5	216	best[i].time = (unsigned int)-1; /* XXX MAX_?INT really */
1da177e4 LT	217	best[i].voice = -1;
	218	}
	219
	220	/*
	221	* Go through them all and get a best one to use.
	222	* NOTE: could also look at volume and pick the quietest one.
	223	*/
	224	for (i = 0; i < emu->max_voices; i++) {
	225	int state, val;
	226
	227	vp = &emu->voices[i];
	228	state = vp->state;
	229	if (state == SNDRV_EMUX_ST_OFF) {
	230	if (vp->ch < 0) {
	231	if (active_only)
	232	continue;
	233	bp = best + V_FREE;
	234	} else
	235	bp = best + V_OFF;
	236	}
	237	else if (state == SNDRV_EMUX_ST_RELEASED \|\|
	238	state == SNDRV_EMUX_ST_PENDING) {
	239	bp = best + V_RELEASED;
fc207733	240	#if 1
1da177e4 LT	241	val = snd_emu10k1_ptr_read(hw, CVCF_CURRENTVOL, vp->ch);
	242	if (! val)
	243	bp = best + V_OFF;
	244	#endif
	245	}
	246	else if (state == SNDRV_EMUX_ST_STANDBY)
	247	continue;
	248	else if (state & SNDRV_EMUX_ST_ON)
	249	bp = best + V_PLAYING;
	250	else
	251	continue;
	252
	253	/* check if sample is finished playing (non-looping only) */
	254	if (bp != best + V_OFF && bp != best + V_FREE &&
	255	(vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_SINGLESHOT)) {
	256	val = snd_emu10k1_ptr_read(hw, CCCA_CURRADDR, vp->ch);
	257	if (val >= vp->reg.loopstart)
	258	bp = best + V_OFF;
	259	}
	260
	261	if (vp->time < bp->time) {
	262	bp->time = vp->time;
	263	bp->voice = i;
	264	}
	265	}
	266	}
	267
	268	/*
	269	* get an empty voice
	270	*
	271	* emu->voice_lock is already held.
	272	*/
eb4698f3 TI	273	static struct snd_emux_voice *
eb4698f3 TI	274	get_voice(struct snd_emux emu, struct snd_emux_port port)
1da177e4	275	{
eb4698f3 TI	276	struct snd_emu10k1 *hw;
	277	struct snd_emux_voice *vp;
	278	struct best_voice best[V_END];
1da177e4 LT	279	int i;
	280
	281	hw = emu->hw;
	282
	283	lookup_voices(emu, hw, best, 0);
	284	for (i = 0; i < V_END; i++) {
	285	if (best[i].voice >= 0) {
	286	vp = &emu->voices[best[i].voice];
	287	if (vp->ch < 0) {
	288	/* allocate a voice */
eb4698f3	289	struct snd_emu10k1_voice *hwvoice;
1da177e4 LT	290	if (snd_emu10k1_voice_alloc(hw, EMU10K1_SYNTH, 1, &hwvoice) < 0 \|\| hwvoice == NULL)
	291	continue;
	292	vp->ch = hwvoice->number;
	293	emu->num_voices++;
	294	}
	295	return vp;
	296	}
	297	}
	298
	299	/* not found */
	300	return NULL;
	301	}
	302
	303	/*
	304	* prepare envelopes and LFOs
	305	*/
	306	static int
eb4698f3	307	start_voice(struct snd_emux_voice *vp)
1da177e4 LT	308	{
	309	unsigned int temp;
	310	int ch;
	311	unsigned int addr, mapped_offset;
eb4698f3 TI	312	struct snd_midi_channel *chan;
	313	struct snd_emu10k1 *hw;
	314	struct snd_emu10k1_memblk *emem;
1da177e4 LT	315
	316	hw = vp->hw;
	317	ch = vp->ch;
da3cec35 TI	318	if (snd_BUG_ON(ch < 0))
da3cec35 TI	319	return -EINVAL;
1da177e4 LT	320	chan = vp->chan;
1da177e4 LT	321
eb4698f3	322	emem = (struct snd_emu10k1_memblk *)vp->block;
1da177e4 LT	323	if (emem == NULL)
	324	return -EINVAL;
	325	emem->map_locked++;
	326	if (snd_emu10k1_memblk_map(hw, emem) < 0) {
6f002b02	327	/* dev_err(hw->card->devK, "emu: cannot map!\n"); */
1da177e4 LT	328	return -ENOMEM;
	329	}
	330	mapped_offset = snd_emu10k1_memblk_offset(emem) >> 1;
	331	vp->reg.start += mapped_offset;
	332	vp->reg.end += mapped_offset;
	333	vp->reg.loopstart += mapped_offset;
	334	vp->reg.loopend += mapped_offset;
	335
	336	/* set channel routing */
	337	/* A = left(0), B = right(1), C = reverb(c), D = chorus(d) */
	338	if (hw->audigy) {
	339	temp = FXBUS_MIDI_LEFT \| (FXBUS_MIDI_RIGHT << 8) \|
	340	(FXBUS_MIDI_REVERB << 16) \| (FXBUS_MIDI_CHORUS << 24);
	341	snd_emu10k1_ptr_write(hw, A_FXRT1, ch, temp);
	342	} else {
	343	temp = (FXBUS_MIDI_LEFT << 16) \| (FXBUS_MIDI_RIGHT << 20) \|
	344	(FXBUS_MIDI_REVERB << 24) \| (FXBUS_MIDI_CHORUS << 28);
	345	snd_emu10k1_ptr_write(hw, FXRT, ch, temp);
	346	}
	347
	348	/* channel to be silent and idle */
fc207733	349	snd_emu10k1_ptr_write(hw, DCYSUSV, ch, 0x0000);
1da177e4 LT	350	snd_emu10k1_ptr_write(hw, VTFT, ch, 0x0000FFFF);
	351	snd_emu10k1_ptr_write(hw, CVCF, ch, 0x0000FFFF);
	352	snd_emu10k1_ptr_write(hw, PTRX, ch, 0);
	353	snd_emu10k1_ptr_write(hw, CPF, ch, 0);
	354
	355	/* set pitch offset */
	356	snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);
	357
	358	/* set envelope parameters */
	359	snd_emu10k1_ptr_write(hw, ENVVAL, ch, vp->reg.parm.moddelay);
	360	snd_emu10k1_ptr_write(hw, ATKHLDM, ch, vp->reg.parm.modatkhld);
	361	snd_emu10k1_ptr_write(hw, DCYSUSM, ch, vp->reg.parm.moddcysus);
	362	snd_emu10k1_ptr_write(hw, ENVVOL, ch, vp->reg.parm.voldelay);
	363	snd_emu10k1_ptr_write(hw, ATKHLDV, ch, vp->reg.parm.volatkhld);
	364	/* decay/sustain parameter for volume envelope is used
	365	for triggerg the voice */
	366
	367	/* cutoff and volume */
	368	temp = (unsigned int)vp->acutoff << 8 \| (unsigned char)vp->avol;
	369	snd_emu10k1_ptr_write(hw, IFATN, vp->ch, temp);
	370
	371	/* modulation envelope heights */
	372	snd_emu10k1_ptr_write(hw, PEFE, ch, vp->reg.parm.pefe);
	373
	374	/* lfo1/2 delay */
	375	snd_emu10k1_ptr_write(hw, LFOVAL1, ch, vp->reg.parm.lfo1delay);
	376	snd_emu10k1_ptr_write(hw, LFOVAL2, ch, vp->reg.parm.lfo2delay);
	377
	378	/* lfo1 pitch & cutoff shift */
	379	set_fmmod(hw, vp);
	380	/* lfo1 volume & freq */
	381	snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
	382	/* lfo2 pitch & freq */
	383	set_fm2frq2(hw, vp);
	384
	385	/* reverb and loop start (reverb 8bit, MSB) */
	386	temp = vp->reg.parm.reverb;
	387	temp += (int)vp->chan->control[MIDI_CTL_E1_REVERB_DEPTH] * 9 / 10;
	388	LIMITMAX(temp, 255);
	389	addr = vp->reg.loopstart;
	390	snd_emu10k1_ptr_write(hw, PSST, vp->ch, (temp << 24) \| addr);
	391
	392	/* chorus & loop end (chorus 8bit, MSB) */
	393	addr = vp->reg.loopend;
	394	temp = vp->reg.parm.chorus;
	395	temp += (int)chan->control[MIDI_CTL_E3_CHORUS_DEPTH] * 9 / 10;
	396	LIMITMAX(temp, 255);
	397	temp = (temp <<24) \| addr;
	398	snd_emu10k1_ptr_write(hw, DSL, ch, temp);
	399
	400	/* clear filter delay memory */
	401	snd_emu10k1_ptr_write(hw, Z1, ch, 0);
	402	snd_emu10k1_ptr_write(hw, Z2, ch, 0);
	403
	404	/* invalidate maps */
7241ea55	405	temp = (hw->silent_page.addr << hw->address_mode) \| (hw->address_mode ? MAP_PTI_MASK1 : MAP_PTI_MASK0);
1da177e4 LT	406	snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
	407	snd_emu10k1_ptr_write(hw, MAPB, ch, temp);
	408	#if 0
	409	/* cache */
	410	{
	411	unsigned int val, sample;
	412	val = 32;
	413	if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
	414	sample = 0x80808080;
	415	else {
	416	sample = 0;
	417	val *= 2;
	418	}
	419
	420	/* cache */
	421	snd_emu10k1_ptr_write(hw, CCR, ch, 0x1c << 16);
	422	snd_emu10k1_ptr_write(hw, CDE, ch, sample);
	423	snd_emu10k1_ptr_write(hw, CDF, ch, sample);
	424
	425	/* invalidate maps */
7241ea55	426	temp = ((unsigned int)hw->silent_page.addr << hw_address_mode) \| (hw->address_mode ? MAP_PTI_MASK1 : MAP_PTI_MASK0);
1da177e4 LT	427	snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
	428	snd_emu10k1_ptr_write(hw, MAPB, ch, temp);
	429
	430	/* fill cache */
	431	val -= 4;
	432	val <<= 25;
	433	val \|= 0x1c << 16;
	434	snd_emu10k1_ptr_write(hw, CCR, ch, val);
	435	}
	436	#endif
	437
	438	/* Q & current address (Q 4bit value, MSB) */
	439	addr = vp->reg.start;
	440	temp = vp->reg.parm.filterQ;
	441	temp = (temp<<28) \| addr;
	442	if (vp->apitch < 0xe400)
	443	temp \|= CCCA_INTERPROM_0;
	444	else {
	445	unsigned int shift = (vp->apitch - 0xe000) >> 10;
	446	temp \|= shift << 25;
	447	}
	448	if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
	449	temp \|= CCCA_8BITSELECT;
	450	snd_emu10k1_ptr_write(hw, CCCA, ch, temp);
	451
	452	/* reset volume */
	453	temp = (unsigned int)vp->vtarget << 16;
	454	snd_emu10k1_ptr_write(hw, VTFT, ch, temp \| vp->ftarget);
	455	snd_emu10k1_ptr_write(hw, CVCF, ch, temp \| 0xff00);
	456	return 0;
	457	}
	458
	459	/*
	460	* Start envelope
	461	*/
	462	static void
eb4698f3	463	trigger_voice(struct snd_emux_voice *vp)
1da177e4 LT	464	{
1da177e4 LT	465	unsigned int temp, ptarget;
eb4698f3 TI	466	struct snd_emu10k1 *hw;
eb4698f3 TI	467	struct snd_emu10k1_memblk *emem;
1da177e4 LT	468
	469	hw = vp->hw;
	470
eb4698f3	471	emem = (struct snd_emu10k1_memblk *)vp->block;
1da177e4 LT	472	if (! emem \|\| emem->mapped_page < 0)
	473	return; /* not mapped */
	474
	475	#if 0
	476	ptarget = (unsigned int)vp->ptarget << 16;
	477	#else
	478	ptarget = IP_TO_CP(vp->apitch);
	479	#endif
	480	/* set pitch target and pan (volume) */
	481	temp = ptarget \| (vp->apan << 8) \| vp->aaux;
	482	snd_emu10k1_ptr_write(hw, PTRX, vp->ch, temp);
	483
	484	/* pitch target */
	485	snd_emu10k1_ptr_write(hw, CPF, vp->ch, ptarget);
	486
	487	/* trigger voice */
	488	snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, vp->reg.parm.voldcysus\|DCYSUSV_CHANNELENABLE_MASK);
	489	}
	490
	491	#define MOD_SENSE 18
	492
	493	/* set lfo1 modulation height and cutoff */
	494	static void
eb4698f3	495	set_fmmod(struct snd_emu10k1 hw, struct snd_emux_voice vp)
1da177e4 LT	496	{
	497	unsigned short fmmod;
	498	short pitch;
	499	unsigned char cutoff;
	500	int modulation;
	501
	502	pitch = (char)(vp->reg.parm.fmmod>>8);
	503	cutoff = (vp->reg.parm.fmmod & 0xff);
	504	modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
	505	pitch += (MOD_SENSE * modulation) / 1200;
	506	LIMITVALUE(pitch, -128, 127);
	507	fmmod = ((unsigned char)pitch<<8) \| cutoff;
	508	snd_emu10k1_ptr_write(hw, FMMOD, vp->ch, fmmod);
	509	}
	510
	511	/* set lfo2 pitch & frequency */
	512	static void
eb4698f3	513	set_fm2frq2(struct snd_emu10k1 hw, struct snd_emux_voice vp)
1da177e4 LT	514	{
	515	unsigned short fm2frq2;
	516	short pitch;
	517	unsigned char freq;
	518	int modulation;
	519
	520	pitch = (char)(vp->reg.parm.fm2frq2>>8);
	521	freq = vp->reg.parm.fm2frq2 & 0xff;
	522	modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
	523	pitch += (MOD_SENSE * modulation) / 1200;
	524	LIMITVALUE(pitch, -128, 127);
	525	fm2frq2 = ((unsigned char)pitch<<8) \| freq;
	526	snd_emu10k1_ptr_write(hw, FM2FRQ2, vp->ch, fm2frq2);
	527	}
	528
	529	/* set filterQ */
	530	static void
eb4698f3	531	set_filterQ(struct snd_emu10k1 hw, struct snd_emux_voice vp)
1da177e4 LT	532	{
	533	unsigned int val;
	534	val = snd_emu10k1_ptr_read(hw, CCCA, vp->ch) & ~CCCA_RESONANCE;
	535	val \|= (vp->reg.parm.filterQ << 28);
	536	snd_emu10k1_ptr_write(hw, CCCA, vp->ch, val);
	537	}