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

/*
 *  synth callback routines for Emu10k1
 *
 *  Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

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