opl3.c

opl3的驱动程序

     
     	if (voice < 0 || voice >= devc->nr_voice)
     		return 0;
     
     	map = &pv_map[devc->lv_map[voice]];
     	pan = devc->voc[voice].panning;
     
     	if (map->voice_mode == 0)
     		return 0;
     
     	if (note == 255)	/*
     				 * Just change the volume
     				 */
     	{
     		set_voice_volume(voice, volume, devc->voc[voice].volume);
     		return 0;
     	}
     
     	/*
     	 * Kill previous note before playing
     	 */
     	
     	opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], 0xff);	/*
     									 * Carrier
     									 * volume to
     									 * min
     									 */
     	opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], 0xff);	/*
     									 * Modulator
     									 * volume to
     									 */
     
     	if (map->voice_mode == 4)
     	{
     		opl3_command(map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
     		opl3_command(map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
     	}
     
     	opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00);	/*
     									 * Note
     									 * off
     									 */
     
     	instr = devc->act_i[voice];
     	
     	if (!instr)
     		instr = &devc->i_map[0];
     
     	if (instr->channel < 0)
     	{
     		printk(KERN_WARNING "opl3: Initializing voice %d with undefined instrument\n", voice);
     		return 0;
     	}
     
     	if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
     		return 0;	/*
     				 * Cannot play
     				 */
     
     	voice_mode = map->voice_mode;
     
     	if (voice_mode == 4)
     	{
     		int voice_shift;
     
     		voice_shift = (map->ioaddr == devc->left_io) ? 0 : 3;
     		voice_shift += map->voice_num;
     
     		if (instr->key != OPL3_PATCH)	/*
     						 * Just 2 OP patch
     						 */
     		{
     			voice_mode = 2;
     			devc->cmask &= ~(1 << voice_shift);
     		}
     		else
     		{
     			devc->cmask |= (1 << voice_shift);
     		}
     
     		opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
     	}
     
     	/*
     	 * Set Sound Characteristics
     	 */
     	
     	opl3_command(map->ioaddr, AM_VIB + map->op[0], instr->operators[0]);
     	opl3_command(map->ioaddr, AM_VIB + map->op[1], instr->operators[1]);
     
     	/*
     	 * Set Attack/Decay
     	 */
     	
     	opl3_command(map->ioaddr, ATTACK_DECAY + map->op[0], instr->operators[4]);
     	opl3_command(map->ioaddr, ATTACK_DECAY + map->op[1], instr->operators[5]);
     
     	/*
     	 * Set Sustain/Release
     	 */
     	
     	opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[0], instr->operators[6]);
     	opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
     
     	/*
     	 * Set Wave Select
     	 */
     
     	opl3_command(map->ioaddr, WAVE_SELECT + map->op[0], instr->operators[8]);
     	opl3_command(map->ioaddr, WAVE_SELECT + map->op[1], instr->operators[9]);
     
     	/*
     	 * Set Feedback/Connection
     	 */
     	
     	fpc = instr->operators[10];
     
     	if (pan != 0xffff)
     	{
     		fpc &= ~STEREO_BITS;
     		if (pan < -64)
     			fpc |= VOICE_TO_LEFT;
     		else
     			if (pan > 64)
     				fpc |= VOICE_TO_RIGHT;
     			else
     				fpc |= (VOICE_TO_LEFT | VOICE_TO_RIGHT);
     	}
     
     	if (!(fpc & 0x30))
     		fpc |= 0x30;	/*
     				 * Ensure that at least one chn is enabled
     				 */
     	opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num, fpc);
     
     	/*
     	 * If the voice is a 4 OP one, initialize the operators 3 and 4 also
     	 */
     
     	if (voice_mode == 4)
     	{
     		/*
     		 * Set Sound Characteristics
     		 */
     	
     		opl3_command(map->ioaddr, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]);
     		opl3_command(map->ioaddr, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
     
     		/*
     		 * Set Attack/Decay
     		 */
     		
     		opl3_command(map->ioaddr, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]);
     		opl3_command(map->ioaddr, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
     
     		/*
     		 * Set Sustain/Release
     		 */
     		
     		opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]);
     		opl3_command(map->ioaddr, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
     
     		/*
     		 * Set Wave Select
     		 */
     		
     		opl3_command(map->ioaddr, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]);
     		opl3_command(map->ioaddr, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
     
     		/*
     		 * Set Feedback/Connection
     		 */
     		
     		fpc = instr->operators[OFFS_4OP + 10];
     		if (!(fpc & 0x30))
     			 fpc |= 0x30;	/*
     					 * Ensure that at least one chn is enabled
     					 */
     		opl3_command(map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
     	}
     
     	devc->voc[voice].mode = voice_mode;
     	set_voice_volume(voice, volume, devc->voc[voice].volume);
     
     	freq = devc->voc[voice].orig_freq = note_to_freq(note) / 1000;
     
     	/*
     	 * Since the pitch bender may have been set before playing the note, we
     	 * have to calculate the bending now.
     	 */
     
     	freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
     	devc->voc[voice].current_freq = freq;
     
     	freq_to_fnum(freq, &block, &fnum);
     
     	/*
     	 * Play note
     	 */
     
     	data = fnum & 0xff;	/*
     				 * Least significant bits of fnumber
     				 */
     	opl3_command(map->ioaddr, FNUM_LOW + map->voice_num, data);
     
     	data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
     		 devc->voc[voice].keyon_byte = data;
     	opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, data);
     	if (voice_mode == 4)
     		opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
     
     	return 0;
     }
     
     static void freq_to_fnum    (int freq, int *block, int *fnum)
     {
     	int f, octave;
     
     	/*
     	 * Converts the note frequency to block and fnum values for the FM chip
     	 */
     	/*
     	 * First try to compute the block -value (octave) where the note belongs
     	 */
     
     	f = freq;
     
     	octave = 5;
     
     	if (f == 0)
     		octave = 0;
     	else if (f < 261)
     	{
     		while (f < 261)
     		{
     			octave--;
     			f <<= 1;
     		}
     	}
     	else if (f > 493)
     	{
     		while (f > 493)
     		{
     			 octave++;
     			 f >>= 1;
     		}
     	}
     
     	if (octave > 7)
     		octave = 7;
     
     	*fnum = freq * (1 << (20 - octave)) / 49716;
     	*block = octave;
     }
     
     static void opl3_command    (int io_addr, unsigned int addr, unsigned int val)
     {
     	 int i;
     
     	/*
     	 * The original 2-OP synth requires a quite long delay after writing to a
     	 * register. The OPL-3 survives with just two INBs
     	 */
     
     	outb(((unsigned char) (addr & 0xff)), io_addr);
     
     	if (devc->model != 2)
     		udelay(10);
     	else
     		for (i = 0; i < 2; i++)
     			inb(io_addr);
     
     	outb(((unsigned char) (val & 0xff)), io_addr + 1);
     
     	if (devc->model != 2)
     		udelay(30);
     	else
     		for (i = 0; i < 2; i++)
     			inb(io_addr);
     }
     
     static void opl3_reset(int devno)
     {
     	int i;
     
     	for (i = 0; i < 18; i++)
     		devc->lv_map[i] = i;
     
     	for (i = 0; i < devc->nr_voice; i++)
     	{
     		opl3_command(pv_map[devc->lv_map[i]].ioaddr,
     			KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
     
     		opl3_command(pv_map[devc->lv_map[i]].ioaddr,
     			KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
     
     		if (pv_map[devc->lv_map[i]].voice_mode == 4)
     		{
     			opl3_command(pv_map[devc->lv_map[i]].ioaddr,
     				KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
     
     			opl3_command(pv_map[devc->lv_map[i]].ioaddr,
     				KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
     		}
     
     		opl3_kill_note(devno, i, 0, 64);
     	}
     
     	if (devc->model == 2)
     	{
     		devc->v_alloc->max_voice = devc->nr_voice = 18;
     
     		for (i = 0; i < 18; i++)
     			pv_map[i].voice_mode = 2;
     
     	}
     }
     
     static int opl3_open(int dev, int mode)
     {
     	int i;
     
     	if (devc->busy)
     		return -EBUSY;
     	devc->busy = 1;
     
     	devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
     	devc->v_alloc->timestamp = 0;
     
     	for (i = 0; i < 18; i++)
     	{
     		devc->v_alloc->map[i] = 0;
     		devc->v_alloc->alloc_times[i] = 0;
     	}
     
     	devc->cmask = 0x00;	/*
     				 * Just 2 OP mode
     				 */
     	if (devc->model == 2)
     		opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
     	return 0;
     }
     
     static void opl3_close(int dev)
     {
     	devc->busy = 0;
     	devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
     
     	devc->fm_info.nr_drums = 0;
     	devc->fm_info.perc_mode = 0;
     
     	opl3_reset(dev);
     }
     
     static void opl3_hw_control(int dev, unsigned char *event)
     {
     }
     
     static int opl3_load_patch(int dev, int format, const char *addr,
     		int offs, int count, int pmgr_flag)
     {
     	struct sbi_instrument ins;
     
     	if (count <sizeof(ins))
     	{
     		printk(KERN_WARNING "FM Error: Patch record too short\n");
     		return -EINVAL;
     	}
     
     	if(copy_from_user(&((char *) &ins)[offs], &(addr)[offs], sizeof(ins) - offs))
     		return -EFAULT;
     
     	if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
     	{
     		printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
     		return -EINVAL;
     	}
     	ins.key = format;
     
     	return store_instr(ins.channel, &ins);
     }
     
     static void opl3_panning(int dev, int voice, int value)
     {
     	devc->voc[voice].panning = value;
     }
     
     static void opl3_volume_method(int dev, int mode)
     {
     }
     
     #define SET_VIBRATO(cell) { \
     	tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
     	if (pressure > 110) \
     		tmp |= 0x40;		/* Vibrato on */ \
     	opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);}
     
     static void opl3_aftertouch(int dev, int voice, int pressure)
     {
     	int tmp;
     	struct sbi_instrument *instr;
     	struct physical_voice_info *map;
     
     	if (voice < 0 || voice >= devc->nr_voice)
     		return;
     
     	map = &pv_map[devc->lv_map[voice]];
     
     	DEB(printk("Aftertouch %d\n", voice));
     
     	if (map->voice_mode == 0)
     		return;
     
     	/*
     	 * Adjust the amount of vibrato depending the pressure
     	 */
     
     	instr = devc->act_i[voice];
     
     	if (!instr)
     		instr = &devc->i_map[0];
     
     	if (devc->voc[voice].mode == 4)
     	{
     		int connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
     
     		switch (connection)
     		{
     			case 0:
     				SET_VIBRATO(4);
     				break;
     
     			case 1:
     				SET_VIBRATO(2);
     				SET_VIBRATO(4);
     				break;
     
     			case 2:
     				SET_VIBRATO(1);
     				SET_VIBRATO(4);
     				break;
     
     			case 3:
     				SET_VIBRATO(1);
     				SET_VIBRATO(3);
     				SET_VIBRATO(4);
     				break;
     
     		}
     		/*
     		 * Not implemented yet
     		 */
     	}
     	else
     	{
     		SET_VIBRATO(1);
     
     		if ((instr->operators[10] & 0x01))	/*
     							 * Additive synthesis
     							 */
     			SET_VIBRATO(2);
     	}
     }
     
     #undef SET_VIBRATO