[linux.git] / sound / oss / midi_synth.c

/*
 * sound/midi_synth.c
 *
 * High level midi sequencer manager for dumb MIDI interfaces.
 */
/*
 * Copyright (C) by Hannu Savolainen 1993-1997
 *
 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 * Version 2 (June 1991). See the "COPYING" file distributed with this software
 * for more info.
 */
/*
 * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
 * Andrew Veliath  : fixed running status in MIDI input state machine
 */
#define USE_SEQ_MACROS
#define USE_SIMPLE_MACROS

#include "sound_config.h"

#define _MIDI_SYNTH_C_

#include "midi_synth.h"

static int      midi2synth[MAX_MIDI_DEV];
static int      sysex_state[MAX_MIDI_DEV] =
{0};
static unsigned char prev_out_status[MAX_MIDI_DEV];

#define STORE(cmd) \
{ \
  int len; \
  unsigned char obuf[8]; \
  cmd; \
  seq_input_event(obuf, len); \
}

#define _seqbuf obuf
#define _seqbufptr 0
#define _SEQ_ADVBUF(x) len=x

void
do_midi_msg(int synthno, unsigned char *msg, int mlen)
{
	switch (msg[0] & 0xf0)
	  {
	  case 0x90:
		  if (msg[2] != 0)
		    {
			    STORE(SEQ_START_NOTE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
			    break;
		    }
		  msg[2] = 64;

	  case 0x80:
		  STORE(SEQ_STOP_NOTE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
		  break;

	  case 0xA0:
		  STORE(SEQ_KEY_PRESSURE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
		  break;

	  case 0xB0:
		  STORE(SEQ_CONTROL(synthno, msg[0] & 0x0f,
				    msg[1], msg[2]));
		  break;

	  case 0xC0:
		  STORE(SEQ_SET_PATCH(synthno, msg[0] & 0x0f, msg[1]));
		  break;

	  case 0xD0:
		  STORE(SEQ_CHN_PRESSURE(synthno, msg[0] & 0x0f, msg[1]));
		  break;

	  case 0xE0:
		  STORE(SEQ_BENDER(synthno, msg[0] & 0x0f,
			      (msg[1] & 0x7f) | ((msg[2] & 0x7f) << 7)));
		  break;

	  default:
		  /* printk( "MPU: Unknown midi channel message %02x\n",  msg[0]); */
		  ;
	  }
}

static void
midi_outc(int midi_dev, int data)
{
	int             timeout;

	for (timeout = 0; timeout < 3200; timeout++)
		if (midi_devs[midi_dev]->outputc(midi_dev, (unsigned char) (data & 0xff)))
		  {
			  if (data & 0x80)	/*
						 * Status byte
						 */
				  prev_out_status[midi_dev] =
				      (unsigned char) (data & 0xff);	/*
									 * Store for running status
									 */
			  return;	/*
					 * Mission complete
					 */
		  }
	/*
	 * Sorry! No space on buffers.
	 */
	printk("Midi send timed out\n");
}

static int
prefix_cmd(int midi_dev, unsigned char status)
{
	if ((char *) midi_devs[midi_dev]->prefix_cmd == NULL)
		return 1;

	return midi_devs[midi_dev]->prefix_cmd(midi_dev, status);
}

static void
midi_synth_input(int orig_dev, unsigned char data)
{
	int             dev;
	struct midi_input_info *inc;

	static unsigned char len_tab[] =	/* # of data bytes following a status
						 */
	{
		2,		/* 8x */
		2,		/* 9x */
		2,		/* Ax */
		2,		/* Bx */
		1,		/* Cx */
		1,		/* Dx */
		2,		/* Ex */
		0		/* Fx */
	};

	if (orig_dev < 0 || orig_dev > num_midis || midi_devs[orig_dev] == NULL)
		return;

	if (data == 0xfe)	/* Ignore active sensing */
		return;

	dev = midi2synth[orig_dev];
	inc = &midi_devs[orig_dev]->in_info;

	switch (inc->m_state)
	  {
	  case MST_INIT:
		  if (data & 0x80)	/* MIDI status byte */
		    {
			    if ((data & 0xf0) == 0xf0)	/* Common message */
			      {
				      switch (data)
					{
					case 0xf0:	/* Sysex */
						inc->m_state = MST_SYSEX;
						break;	/* Sysex */

					case 0xf1:	/* MTC quarter frame */
					case 0xf3:	/* Song select */
						inc->m_state = MST_DATA;
						inc->m_ptr = 1;
						inc->m_left = 1;
						inc->m_buf[0] = data;
						break;

					case 0xf2:	/* Song position pointer */
						inc->m_state = MST_DATA;
						inc->m_ptr = 1;
						inc->m_left = 2;
						inc->m_buf[0] = data;
						break;

					default:
						inc->m_buf[0] = data;
						inc->m_ptr = 1;
						do_midi_msg(dev, inc->m_buf, inc->m_ptr);
						inc->m_ptr = 0;
						inc->m_left = 0;
					}
			    } else
			      {
				      inc->m_state = MST_DATA;
				      inc->m_ptr = 1;
				      inc->m_left = len_tab[(data >> 4) - 8];
				      inc->m_buf[0] = inc->m_prev_status = data;
			      }
		    } else if (inc->m_prev_status & 0x80) {
			    /* Data byte (use running status) */
			    inc->m_ptr = 2;
			    inc->m_buf[1] = data;
			    inc->m_buf[0] = inc->m_prev_status;
			    inc->m_left = len_tab[(inc->m_buf[0] >> 4) - 8] - 1;
			    if (inc->m_left > 0)
				    inc->m_state = MST_DATA; /* Not done yet */
			    else {
				    inc->m_state = MST_INIT;
				    do_midi_msg(dev, inc->m_buf, inc->m_ptr);
				    inc->m_ptr = 0;
			    }
		    }
		  break;	/* MST_INIT */

	  case MST_DATA:
		  inc->m_buf[inc->m_ptr++] = data;
		  if (--inc->m_left <= 0)
		    {
			    inc->m_state = MST_INIT;
			    do_midi_msg(dev, inc->m_buf, inc->m_ptr);
			    inc->m_ptr = 0;
		    }
		  break;	/* MST_DATA */

	  case MST_SYSEX:
		  if (data == 0xf7)	/* Sysex end */
		    {
			    inc->m_state = MST_INIT;
			    inc->m_left = 0;
			    inc->m_ptr = 0;
		    }
		  break;	/* MST_SYSEX */

	  default:
		  printk("MIDI%d: Unexpected state %d (%02x)\n", orig_dev, inc->m_state, (int) data);
		  inc->m_state = MST_INIT;
	  }
}

static void
leave_sysex(int dev)
{
	int             orig_dev = synth_devs[dev]->midi_dev;
	int             timeout = 0;

	if (!sysex_state[dev])
		return;

	sysex_state[dev] = 0;

	while (!midi_devs[orig_dev]->outputc(orig_dev, 0xf7) &&
	       timeout < 1000)
		timeout++;

	sysex_state[dev] = 0;
}

static void
midi_synth_output(int dev)
{
	/*
	 * Currently NOP
	 */
}

int midi_synth_ioctl(int dev, unsigned int cmd, void __user *arg)
{
	/*
	 * int orig_dev = synth_devs[dev]->midi_dev;
	 */

	switch (cmd) {

	case SNDCTL_SYNTH_INFO:
		if (__copy_to_user(arg, synth_devs[dev]->info, sizeof(struct synth_info)))
			return -EFAULT;
		return 0;
		
	case SNDCTL_SYNTH_MEMAVL:
		return 0x7fffffff;

	default:
		return -EINVAL;
	}
}

int
midi_synth_kill_note(int dev, int channel, int note, int velocity)
{
	int             orig_dev = synth_devs[dev]->midi_dev;
	int             msg, chn;

	if (note < 0 || note > 127)
		return 0;
	if (channel < 0 || channel > 15)
		return 0;
	if (velocity < 0)
		velocity = 0;
	if (velocity > 127)
		velocity = 127;

	leave_sysex(dev);

	msg = prev_out_status[orig_dev] & 0xf0;
	chn = prev_out_status[orig_dev] & 0x0f;

	if (chn == channel && ((msg == 0x90 && velocity == 64) || msg == 0x80))
	  {			/*
				 * Use running status
				 */
		  if (!prefix_cmd(orig_dev, note))
			  return 0;

		  midi_outc(orig_dev, note);

		  if (msg == 0x90)	/*
					 * Running status = Note on
					 */
			  midi_outc(orig_dev, 0);	/*
							   * Note on with velocity 0 == note
							   * off
							 */
		  else
			  midi_outc(orig_dev, velocity);
	} else
	  {
		  if (velocity == 64)
		    {
			    if (!prefix_cmd(orig_dev, 0x90 | (channel & 0x0f)))
				    return 0;
			    midi_outc(orig_dev, 0x90 | (channel & 0x0f));	/*
										 * Note on
										 */
			    midi_outc(orig_dev, note);
			    midi_outc(orig_dev, 0);	/*
							 * Zero G
							 */
		  } else
		    {
			    if (!prefix_cmd(orig_dev, 0x80 | (channel & 0x0f)))
				    return 0;
			    midi_outc(orig_dev, 0x80 | (channel & 0x0f));	/*
										 * Note off
										 */
			    midi_outc(orig_dev, note);
			    midi_outc(orig_dev, velocity);
		    }
	  }

	return 0;
}

int
midi_synth_set_instr(int dev, int channel, int instr_no)
{
	int             orig_dev = synth_devs[dev]->midi_dev;

	if (instr_no < 0 || instr_no > 127)
		instr_no = 0;
	if (channel < 0 || channel > 15)
		return 0;

	leave_sysex(dev);

	if (!prefix_cmd(orig_dev, 0xc0 | (channel & 0x0f)))
		return 0;
	midi_outc(orig_dev, 0xc0 | (channel & 0x0f));	/*
							 * Program change
							 */
	midi_outc(orig_dev, instr_no);

	return 0;
}

int
midi_synth_start_note(int dev, int channel, int note, int velocity)
{
	int             orig_dev = synth_devs[dev]->midi_dev;
	int             msg, chn;

	if (note < 0 || note > 127)
		return 0;
	if (channel < 0 || channel > 15)
		return 0;
	if (velocity < 0)
		velocity = 0;
	if (velocity > 127)
		velocity = 127;

	leave_sysex(dev);

	msg = prev_out_status[orig_dev] & 0xf0;
	chn = prev_out_status[orig_dev] & 0x0f;

	if (chn == channel && msg == 0x90)
	  {			/*
				 * Use running status
				 */
		  if (!prefix_cmd(orig_dev, note))
			  return 0;
		  midi_outc(orig_dev, note);
		  midi_outc(orig_dev, velocity);
	} else
	  {
		  if (!prefix_cmd(orig_dev, 0x90 | (channel & 0x0f)))
			  return 0;
		  midi_outc(orig_dev, 0x90 | (channel & 0x0f));		/*
									 * Note on
									 */
		  midi_outc(orig_dev, note);
		  midi_outc(orig_dev, velocity);
	  }
	return 0;
}

void
midi_synth_reset(int dev)
{

	leave_sysex(dev);
}

int
midi_synth_open(int dev, int mode)
{
	int             orig_dev = synth_devs[dev]->midi_dev;
	int             err;
	struct midi_input_info *inc;

	if (orig_dev < 0 || orig_dev > num_midis || midi_devs[orig_dev] == NULL)
		return -ENXIO;

	midi2synth[orig_dev] = dev;
	sysex_state[dev] = 0;
	prev_out_status[orig_dev] = 0;

	if ((err = midi_devs[orig_dev]->open(orig_dev, mode,
			       midi_synth_input, midi_synth_output)) < 0)
		return err;
	inc = &midi_devs[orig_dev]->in_info;

	/* save_flags(flags);
	cli(); 
	don't know against what irqhandler to protect*/
	inc->m_busy = 0;
	inc->m_state = MST_INIT;
	inc->m_ptr = 0;
	inc->m_left = 0;
	inc->m_prev_status = 0x00;
	/* restore_flags(flags); */

	return 1;
}

void
midi_synth_close(int dev)
{
	int             orig_dev = synth_devs[dev]->midi_dev;

	leave_sysex(dev);

	/*
	 * Shut up the synths by sending just single active sensing message.
	 */
	midi_devs[orig_dev]->outputc(orig_dev, 0xfe);

	midi_devs[orig_dev]->close(orig_dev);
}

void
midi_synth_hw_control(int dev, unsigned char *event)
{
}

int
midi_synth_load_patch(int dev, int format, const char __user *addr,
		      int offs, int count, int pmgr_flag)
{
	int             orig_dev = synth_devs[dev]->midi_dev;

	struct sysex_info sysex;
	int             i;
	unsigned long   left, src_offs, eox_seen = 0;
	int             first_byte = 1;
	int             hdr_size = (unsigned long) &sysex.data[0] - (unsigned long) &sysex;

	leave_sysex(dev);

	if (!prefix_cmd(orig_dev, 0xf0))
		return 0;

	if (format != SYSEX_PATCH)
	{
/*		  printk("MIDI Error: Invalid patch format (key) 0x%x\n", format);*/
		  return -EINVAL;
	}
	if (count < hdr_size)
	{
/*		printk("MIDI Error: Patch header too short\n");*/
		return -EINVAL;
	}
	count -= hdr_size;

	/*
	 * Copy the header from user space but ignore the first bytes which have
	 * been transferred already.
	 */

	if(copy_from_user(&((char *) &sysex)[offs], &(addr)[offs], hdr_size - offs))
		return -EFAULT;
 
 	if (count < sysex.len)
	{
/*		printk(KERN_WARNING "MIDI Warning: Sysex record too short (%d<%d)\n", count, (int) sysex.len);*/
		sysex.len = count;
	}
  	left = sysex.len;
  	src_offs = 0;

	for (i = 0; i < left && !signal_pending(current); i++)
	{
		unsigned char   data;

		get_user(*(unsigned char *) &data, (unsigned char __user *) &((addr)[hdr_size + i]));

		eox_seen = (i > 0 && data & 0x80);	/* End of sysex */

		if (eox_seen && data != 0xf7)
			data = 0xf7;

		if (i == 0)
		{
			if (data != 0xf0)
			{
				printk(KERN_WARNING "midi_synth: Sysex start missing\n");
				return -EINVAL;
			}
		}
		while (!midi_devs[orig_dev]->outputc(orig_dev, (unsigned char) (data & 0xff)) &&
			!signal_pending(current))
			schedule();

		if (!first_byte && data & 0x80)
			return 0;
		first_byte = 0;
	}

	if (!eox_seen)
		midi_outc(orig_dev, 0xf7);
	return 0;
}
  
void midi_synth_panning(int dev, int channel, int pressure)
{
}
  
void midi_synth_aftertouch(int dev, int channel, int pressure)
{
	int             orig_dev = synth_devs[dev]->midi_dev;
	int             msg, chn;

	if (pressure < 0 || pressure > 127)
		return;
	if (channel < 0 || channel > 15)
		return;

	leave_sysex(dev);

	msg = prev_out_status[orig_dev] & 0xf0;
	chn = prev_out_status[orig_dev] & 0x0f;

	if (msg != 0xd0 || chn != channel)	/*
						 * Test for running status
						 */
	  {
		  if (!prefix_cmd(orig_dev, 0xd0 | (channel & 0x0f)))
			  return;
		  midi_outc(orig_dev, 0xd0 | (channel & 0x0f));		/*
									 * Channel pressure
									 */
	} else if (!prefix_cmd(orig_dev, pressure))
		return;

	midi_outc(orig_dev, pressure);
}

void
midi_synth_controller(int dev, int channel, int ctrl_num, int value)
{
	int             orig_dev = synth_devs[dev]->midi_dev;
	int             chn, msg;

	if (ctrl_num < 0 || ctrl_num > 127)
		return;
	if (channel < 0 || channel > 15)
		return;

	leave_sysex(dev);

	msg = prev_out_status[orig_dev] & 0xf0;
	chn = prev_out_status[orig_dev] & 0x0f;

	if (msg != 0xb0 || chn != channel)
	  {
		  if (!prefix_cmd(orig_dev, 0xb0 | (channel & 0x0f)))
			  return;
		  midi_outc(orig_dev, 0xb0 | (channel & 0x0f));
	} else if (!prefix_cmd(orig_dev, ctrl_num))
		return;

	midi_outc(orig_dev, ctrl_num);
	midi_outc(orig_dev, value & 0x7f);
}

void
midi_synth_bender(int dev, int channel, int value)
{
	int             orig_dev = synth_devs[dev]->midi_dev;
	int             msg, prev_chn;

	if (channel < 0 || channel > 15)
		return;

	if (value < 0 || value > 16383)
		return;

	leave_sysex(dev);

	msg = prev_out_status[orig_dev] & 0xf0;
	prev_chn = prev_out_status[orig_dev] & 0x0f;

	if (msg != 0xd0 || prev_chn != channel)		/*
							 * Test for running status
							 */
	  {
		  if (!prefix_cmd(orig_dev, 0xe0 | (channel & 0x0f)))
			  return;
		  midi_outc(orig_dev, 0xe0 | (channel & 0x0f));
	} else if (!prefix_cmd(orig_dev, value & 0x7f))
		return;

	midi_outc(orig_dev, value & 0x7f);
	midi_outc(orig_dev, (value >> 7) & 0x7f);
}

void
midi_synth_setup_voice(int dev, int voice, int channel)
{
}

int
midi_synth_send_sysex(int dev, unsigned char *bytes, int len)
{
	int             orig_dev = synth_devs[dev]->midi_dev;
	int             i;

	for (i = 0; i < len; i++)
	  {
		  switch (bytes[i])
		    {
		    case 0xf0:	/* Start sysex */
			    if (!prefix_cmd(orig_dev, 0xf0))
				    return 0;
			    sysex_state[dev] = 1;
			    break;

		    case 0xf7:	/* End sysex */
			    if (!sysex_state[dev])	/* Orphan sysex end */
				    return 0;
			    sysex_state[dev] = 0;
			    break;

		    default:
			    if (!sysex_state[dev])
				    return 0;

			    if (bytes[i] & 0x80)	/* Error. Another message before sysex end */
			      {
				      bytes[i] = 0xf7;	/* Sysex end */
				      sysex_state[dev] = 0;
			      }
		    }

		  if (!midi_devs[orig_dev]->outputc(orig_dev, bytes[i]))
		    {
/*
 * Hardware level buffer is full. Abort the sysex message.
 */

			    int             timeout = 0;

			    bytes[i] = 0xf7;
			    sysex_state[dev] = 0;

			    while (!midi_devs[orig_dev]->outputc(orig_dev, bytes[i]) &&
				   timeout < 1000)
				    timeout++;
		    }
		  if (!sysex_state[dev])
			  return 0;
	  }

	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* sound/midi_synth.c
	3	*
	4	* High level midi sequencer manager for dumb MIDI interfaces.
	5	*/
	6	/*
	7	* Copyright (C) by Hannu Savolainen 1993-1997
	8	*
	9	* OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
	10	* Version 2 (June 1991). See the "COPYING" file distributed with this software
	11	* for more info.
	12	*/
	13	/*
	14	* Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
	15	* Andrew Veliath : fixed running status in MIDI input state machine
	16	*/
	17	#define USE_SEQ_MACROS
	18	#define USE_SIMPLE_MACROS
	19
	20	#include "sound_config.h"
	21
	22	#define _MIDI_SYNTH_C_
	23
	24	#include "midi_synth.h"
	25
	26	static int midi2synth[MAX_MIDI_DEV];
	27	static int sysex_state[MAX_MIDI_DEV] =
	28	{0};
	29	static unsigned char prev_out_status[MAX_MIDI_DEV];
	30
	31	#define STORE(cmd) \
	32	{ \
	33	int len; \
	34	unsigned char obuf[8]; \
	35	cmd; \
	36	seq_input_event(obuf, len); \
	37	}
	38
	39	#define _seqbuf obuf
	40	#define _seqbufptr 0
	41	#define _SEQ_ADVBUF(x) len=x
	42
	43	void
	44	do_midi_msg(int synthno, unsigned char *msg, int mlen)
	45	{
	46	switch (msg[0] & 0xf0)
	47	{
	48	case 0x90:
	49	if (msg[2] != 0)
	50	{
	51	STORE(SEQ_START_NOTE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
	52	break;
	53	}
	54	msg[2] = 64;
	55
	56	case 0x80:
	57	STORE(SEQ_STOP_NOTE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
	58	break;
	59
	60	case 0xA0:
	61	STORE(SEQ_KEY_PRESSURE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
	62	break;
	63
	64	case 0xB0:
65	STORE(SEQ_CONTROL(synthno, msg[0] & 0x0f,
66	msg[1], msg[2]));
67	break;
68
69	case 0xC0:
70	STORE(SEQ_SET_PATCH(synthno, msg[0] & 0x0f, msg[1]));
71	break;
72
73	case 0xD0:
74	STORE(SEQ_CHN_PRESSURE(synthno, msg[0] & 0x0f, msg[1]));
75	break;
76
77	case 0xE0:
78	STORE(SEQ_BENDER(synthno, msg[0] & 0x0f,
79	(msg[1] & 0x7f) \| ((msg[2] & 0x7f) << 7)));
80	break;
81
82	default:
83	/* printk( "MPU: Unknown midi channel message %02x\n", msg[0]); */
84	;
85	}
86	}
87
88	static void
89	midi_outc(int midi_dev, int data)
90	{
91	int timeout;
92
93	for (timeout = 0; timeout < 3200; timeout++)
94	if (midi_devs[midi_dev]->outputc(midi_dev, (unsigned char) (data & 0xff)))
95	{
96	if (data & 0x80) /*
97	* Status byte
98	*/
99	prev_out_status[midi_dev] =
100	(unsigned char) (data & 0xff); /*
101	* Store for running status
102	*/
103	return; /*
104	* Mission complete
105	*/
106	}
107	/*
108	* Sorry! No space on buffers.
109	*/
110	printk("Midi send timed out\n");
111	}
112
113	static int
114	prefix_cmd(int midi_dev, unsigned char status)
115	{
116	if ((char *) midi_devs[midi_dev]->prefix_cmd == NULL)
117	return 1;
118
119	return midi_devs[midi_dev]->prefix_cmd(midi_dev, status);
120	}
121
122	static void
123	midi_synth_input(int orig_dev, unsigned char data)
124	{
125	int dev;
126	struct midi_input_info *inc;
127
128	static unsigned char len_tab[] = /* # of data bytes following a status
129	*/
130	{
131	2, /* 8x */
132	2, /* 9x */
133	2, /* Ax */
134	2, /* Bx */
135	1, /* Cx */
136	1, /* Dx */
137	2, /* Ex */
138	0 /* Fx */
139	};
140
141	if (orig_dev < 0 \|\| orig_dev > num_midis \|\| midi_devs[orig_dev] == NULL)
142	return;
143
144	if (data == 0xfe) /* Ignore active sensing */
145	return;
146
147	dev = midi2synth[orig_dev];
148	inc = &midi_devs[orig_dev]->in_info;
149
150	switch (inc->m_state)
151	{
152	case MST_INIT:
153	if (data & 0x80) /* MIDI status byte */
154	{
155	if ((data & 0xf0) == 0xf0) /* Common message */
156	{
157	switch (data)
158	{
159	case 0xf0: /* Sysex */
160	inc->m_state = MST_SYSEX;
161	break; /* Sysex */
162
163	case 0xf1: /* MTC quarter frame */
164	case 0xf3: /* Song select */
165	inc->m_state = MST_DATA;
166	inc->m_ptr = 1;
167	inc->m_left = 1;
168	inc->m_buf[0] = data;
169	break;
170
171	case 0xf2: /* Song position pointer */
172	inc->m_state = MST_DATA;
173	inc->m_ptr = 1;
174	inc->m_left = 2;
175	inc->m_buf[0] = data;
176	break;
177
178	default:
179	inc->m_buf[0] = data;
180	inc->m_ptr = 1;
181	do_midi_msg(dev, inc->m_buf, inc->m_ptr);
182	inc->m_ptr = 0;
183	inc->m_left = 0;
184	}
185	} else
186	{
187	inc->m_state = MST_DATA;
188	inc->m_ptr = 1;
189	inc->m_left = len_tab[(data >> 4) - 8];
190	inc->m_buf[0] = inc->m_prev_status = data;
191	}
192	} else if (inc->m_prev_status & 0x80) {
193	/* Data byte (use running status) */
194	inc->m_ptr = 2;
195	inc->m_buf[1] = data;
196	inc->m_buf[0] = inc->m_prev_status;
197	inc->m_left = len_tab[(inc->m_buf[0] >> 4) - 8] - 1;
198	if (inc->m_left > 0)
199	inc->m_state = MST_DATA; /* Not done yet */
200	else {
201	inc->m_state = MST_INIT;
202	do_midi_msg(dev, inc->m_buf, inc->m_ptr);
203	inc->m_ptr = 0;
204	}
205	}
206	break; /* MST_INIT */
207
208	case MST_DATA:
209	inc->m_buf[inc->m_ptr++] = data;
210	if (--inc->m_left <= 0)
211	{
212	inc->m_state = MST_INIT;
213	do_midi_msg(dev, inc->m_buf, inc->m_ptr);
214	inc->m_ptr = 0;
215	}
216	break; /* MST_DATA */
217
218	case MST_SYSEX:
219	if (data == 0xf7) /* Sysex end */
220	{
221	inc->m_state = MST_INIT;
222	inc->m_left = 0;
223	inc->m_ptr = 0;
224	}
225	break; /* MST_SYSEX */
226
227	default:
228	printk("MIDI%d: Unexpected state %d (%02x)\n", orig_dev, inc->m_state, (int) data);
229	inc->m_state = MST_INIT;
230	}
231	}
232
233	static void
234	leave_sysex(int dev)
235	{
236	int orig_dev = synth_devs[dev]->midi_dev;
237	int timeout = 0;
238
239	if (!sysex_state[dev])
240	return;
241
242	sysex_state[dev] = 0;
243
244	while (!midi_devs[orig_dev]->outputc(orig_dev, 0xf7) &&
245	timeout < 1000)
246	timeout++;
247
248	sysex_state[dev] = 0;
249	}
250
251	static void
252	midi_synth_output(int dev)
253	{
254	/*
255	* Currently NOP
256	*/
257	}
258
259	int midi_synth_ioctl(int dev, unsigned int cmd, void __user *arg)
260	{
261	/*
262	* int orig_dev = synth_devs[dev]->midi_dev;
263	*/
264
265	switch (cmd) {
266
267	case SNDCTL_SYNTH_INFO:
268	if (__copy_to_user(arg, synth_devs[dev]->info, sizeof(struct synth_info)))
269	return -EFAULT;
270	return 0;
271
272	case SNDCTL_SYNTH_MEMAVL:
273	return 0x7fffffff;
274
275	default:
276	return -EINVAL;
277	}
278	}
279
280	int
281	midi_synth_kill_note(int dev, int channel, int note, int velocity)
282	{
283	int orig_dev = synth_devs[dev]->midi_dev;
284	int msg, chn;
285
286	if (note < 0 \|\| note > 127)
287	return 0;
288	if (channel < 0 \|\| channel > 15)
289	return 0;
290	if (velocity < 0)
291	velocity = 0;
292	if (velocity > 127)
293	velocity = 127;
294
295	leave_sysex(dev);
296
297	msg = prev_out_status[orig_dev] & 0xf0;
298	chn = prev_out_status[orig_dev] & 0x0f;
299
300	if (chn == channel && ((msg == 0x90 && velocity == 64) \|\| msg == 0x80))
301	{ /*
302	* Use running status
303	*/
304	if (!prefix_cmd(orig_dev, note))
305	return 0;
306
307	midi_outc(orig_dev, note);
308
309	if (msg == 0x90) /*
310	* Running status = Note on
311	*/
312	midi_outc(orig_dev, 0); /*
313	* Note on with velocity 0 == note
314	* off
315	*/
316	else
317	midi_outc(orig_dev, velocity);
318	} else
319	{
320	if (velocity == 64)
321	{
322	if (!prefix_cmd(orig_dev, 0x90 \| (channel & 0x0f)))
323	return 0;
324	midi_outc(orig_dev, 0x90 \| (channel & 0x0f)); /*
325	* Note on
326	*/
327	midi_outc(orig_dev, note);
328	midi_outc(orig_dev, 0); /*
329	* Zero G
330	*/
331	} else
332	{
333	if (!prefix_cmd(orig_dev, 0x80 \| (channel & 0x0f)))
334	return 0;
335	midi_outc(orig_dev, 0x80 \| (channel & 0x0f)); /*
336	* Note off
337	*/
338	midi_outc(orig_dev, note);
339	midi_outc(orig_dev, velocity);
340	}
341	}
342
343	return 0;
344	}
345
346	int
347	midi_synth_set_instr(int dev, int channel, int instr_no)
348	{
349	int orig_dev = synth_devs[dev]->midi_dev;
350
351	if (instr_no < 0 \|\| instr_no > 127)
352	instr_no = 0;
353	if (channel < 0 \|\| channel > 15)
354	return 0;
355
356	leave_sysex(dev);
357
358	if (!prefix_cmd(orig_dev, 0xc0 \| (channel & 0x0f)))
359	return 0;
360	midi_outc(orig_dev, 0xc0 \| (channel & 0x0f)); /*
361	* Program change
362	*/
363	midi_outc(orig_dev, instr_no);
364
365	return 0;
366	}
367
368	int
369	midi_synth_start_note(int dev, int channel, int note, int velocity)
370	{
371	int orig_dev = synth_devs[dev]->midi_dev;
372	int msg, chn;
373
374	if (note < 0 \|\| note > 127)
375	return 0;
376	if (channel < 0 \|\| channel > 15)
377	return 0;
378	if (velocity < 0)
379	velocity = 0;
380	if (velocity > 127)
381	velocity = 127;
382
383	leave_sysex(dev);
384
385	msg = prev_out_status[orig_dev] & 0xf0;
386	chn = prev_out_status[orig_dev] & 0x0f;
387
388	if (chn == channel && msg == 0x90)
389	{ /*
390	* Use running status
391	*/
392	if (!prefix_cmd(orig_dev, note))
393	return 0;
394	midi_outc(orig_dev, note);
395	midi_outc(orig_dev, velocity);
396	} else
397	{
398	if (!prefix_cmd(orig_dev, 0x90 \| (channel & 0x0f)))
399	return 0;
400	midi_outc(orig_dev, 0x90 \| (channel & 0x0f)); /*
401	* Note on
402	*/
403	midi_outc(orig_dev, note);
404	midi_outc(orig_dev, velocity);
405	}
406	return 0;
407	}
408
409	void
410	midi_synth_reset(int dev)
411	{
412
413	leave_sysex(dev);
414	}
415
416	int
417	midi_synth_open(int dev, int mode)
418	{
419	int orig_dev = synth_devs[dev]->midi_dev;
420	int err;
421	struct midi_input_info *inc;
422
423	if (orig_dev < 0 \|\| orig_dev > num_midis \|\| midi_devs[orig_dev] == NULL)
424	return -ENXIO;
425
426	midi2synth[orig_dev] = dev;
427	sysex_state[dev] = 0;
428	prev_out_status[orig_dev] = 0;
429
430	if ((err = midi_devs[orig_dev]->open(orig_dev, mode,
431	midi_synth_input, midi_synth_output)) < 0)
432	return err;
433	inc = &midi_devs[orig_dev]->in_info;
434
435	/* save_flags(flags);
436	cli();
437	don't know against what irqhandler to protect*/
438	inc->m_busy = 0;
439	inc->m_state = MST_INIT;
440	inc->m_ptr = 0;
441	inc->m_left = 0;
442	inc->m_prev_status = 0x00;
443	/* restore_flags(flags); */
444
445	return 1;
446	}
447
448	void
449	midi_synth_close(int dev)
450	{
451	int orig_dev = synth_devs[dev]->midi_dev;
452
453	leave_sysex(dev);
454
455	/*
456	* Shut up the synths by sending just single active sensing message.
457	*/
458	midi_devs[orig_dev]->outputc(orig_dev, 0xfe);
459
460	midi_devs[orig_dev]->close(orig_dev);
461	}
462
463	void
464	midi_synth_hw_control(int dev, unsigned char *event)
465	{
466	}
467
468	int
469	midi_synth_load_patch(int dev, int format, const char __user *addr,
470	int offs, int count, int pmgr_flag)
471	{
472	int orig_dev = synth_devs[dev]->midi_dev;
473
474	struct sysex_info sysex;
475	int i;
476	unsigned long left, src_offs, eox_seen = 0;
477	int first_byte = 1;
478	int hdr_size = (unsigned long) &sysex.data[0] - (unsigned long) &sysex;
479
480	leave_sysex(dev);
481
482	if (!prefix_cmd(orig_dev, 0xf0))
483	return 0;
484
485	if (format != SYSEX_PATCH)
486	{
487	/* printk("MIDI Error: Invalid patch format (key) 0x%x\n", format);*/
488	return -EINVAL;
489	}
490	if (count < hdr_size)
491	{
492	/* printk("MIDI Error: Patch header too short\n");*/
493	return -EINVAL;
494	}
495	count -= hdr_size;
496
497	/*
498	* Copy the header from user space but ignore the first bytes which have
499	* been transferred already.
500	*/
501
502	if(copy_from_user(&((char *) &sysex)[offs], &(addr)[offs], hdr_size - offs))
503	return -EFAULT;
504
505	if (count < sysex.len)
506	{
507	/* printk(KERN_WARNING "MIDI Warning: Sysex record too short (%d<%d)\n", count, (int) sysex.len);*/
508	sysex.len = count;
509	}
510	left = sysex.len;
511	src_offs = 0;
512
513	for (i = 0; i < left && !signal_pending(current); i++)
514	{
515	unsigned char data;
516
517	get_user((unsigned char ) &data, (unsigned char __user *) &((addr)[hdr_size + i]));
518
519	eox_seen = (i > 0 && data & 0x80); /* End of sysex */
520
521	if (eox_seen && data != 0xf7)
522	data = 0xf7;
523
524	if (i == 0)
525	{
526	if (data != 0xf0)
527	{
528	printk(KERN_WARNING "midi_synth: Sysex start missing\n");
529	return -EINVAL;
530	}
531	}
532	while (!midi_devs[orig_dev]->outputc(orig_dev, (unsigned char) (data & 0xff)) &&
533	!signal_pending(current))
534	schedule();
535
536	if (!first_byte && data & 0x80)
537	return 0;
538	first_byte = 0;
539	}
540
541	if (!eox_seen)
542	midi_outc(orig_dev, 0xf7);
543	return 0;
544	}
545
546	void midi_synth_panning(int dev, int channel, int pressure)
547	{
548	}
549
550	void midi_synth_aftertouch(int dev, int channel, int pressure)
551	{
552	int orig_dev = synth_devs[dev]->midi_dev;
553	int msg, chn;
554
555	if (pressure < 0 \|\| pressure > 127)
556	return;
557	if (channel < 0 \|\| channel > 15)
558	return;
559
560	leave_sysex(dev);
561
562	msg = prev_out_status[orig_dev] & 0xf0;
563	chn = prev_out_status[orig_dev] & 0x0f;
564
565	if (msg != 0xd0 \|\| chn != channel) /*
566	* Test for running status
567	*/
568	{
569	if (!prefix_cmd(orig_dev, 0xd0 \| (channel & 0x0f)))
570	return;
571	midi_outc(orig_dev, 0xd0 \| (channel & 0x0f)); /*
572	* Channel pressure
573	*/
574	} else if (!prefix_cmd(orig_dev, pressure))
575	return;
576
577	midi_outc(orig_dev, pressure);
578	}
579
580	void
581	midi_synth_controller(int dev, int channel, int ctrl_num, int value)
582	{
583	int orig_dev = synth_devs[dev]->midi_dev;
584	int chn, msg;
585
586	if (ctrl_num < 0 \|\| ctrl_num > 127)
587	return;
588	if (channel < 0 \|\| channel > 15)
589	return;
590
591	leave_sysex(dev);
592
593	msg = prev_out_status[orig_dev] & 0xf0;
594	chn = prev_out_status[orig_dev] & 0x0f;
595
596	if (msg != 0xb0 \|\| chn != channel)
597	{
598	if (!prefix_cmd(orig_dev, 0xb0 \| (channel & 0x0f)))
599	return;
600	midi_outc(orig_dev, 0xb0 \| (channel & 0x0f));
601	} else if (!prefix_cmd(orig_dev, ctrl_num))
602	return;
603
604	midi_outc(orig_dev, ctrl_num);
605	midi_outc(orig_dev, value & 0x7f);
606	}
607
608	void
609	midi_synth_bender(int dev, int channel, int value)
610	{
611	int orig_dev = synth_devs[dev]->midi_dev;
612	int msg, prev_chn;
613
614	if (channel < 0 \|\| channel > 15)
615	return;
616
617	if (value < 0 \|\| value > 16383)
618	return;
619
620	leave_sysex(dev);
621
622	msg = prev_out_status[orig_dev] & 0xf0;
623	prev_chn = prev_out_status[orig_dev] & 0x0f;
624
625	if (msg != 0xd0 \|\| prev_chn != channel) /*
626	* Test for running status
627	*/
628	{
629	if (!prefix_cmd(orig_dev, 0xe0 \| (channel & 0x0f)))
630	return;
631	midi_outc(orig_dev, 0xe0 \| (channel & 0x0f));
632	} else if (!prefix_cmd(orig_dev, value & 0x7f))
633	return;
634
635	midi_outc(orig_dev, value & 0x7f);
636	midi_outc(orig_dev, (value >> 7) & 0x7f);
637	}
638
639	void
640	midi_synth_setup_voice(int dev, int voice, int channel)
641	{
642	}
643
644	int
645	midi_synth_send_sysex(int dev, unsigned char *bytes, int len)
646	{
647	int orig_dev = synth_devs[dev]->midi_dev;
648	int i;
649
650	for (i = 0; i < len; i++)
651	{
652	switch (bytes[i])
653	{
654	case 0xf0: /* Start sysex */
655	if (!prefix_cmd(orig_dev, 0xf0))
656	return 0;
657	sysex_state[dev] = 1;
658	break;
659
660	case 0xf7: /* End sysex */
661	if (!sysex_state[dev]) /* Orphan sysex end */
662	return 0;
663	sysex_state[dev] = 0;
664	break;
665
666	default:
667	if (!sysex_state[dev])
668	return 0;
669
670	if (bytes[i] & 0x80) /* Error. Another message before sysex end */
671	{
672	bytes[i] = 0xf7; /* Sysex end */
673	sysex_state[dev] = 0;
674	}
675	}
676
677	if (!midi_devs[orig_dev]->outputc(orig_dev, bytes[i]))
678	{
679	/*
680	* Hardware level buffer is full. Abort the sysex message.
681	*/
682
683	int timeout = 0;
684
685	bytes[i] = 0xf7;
686	sysex_state[dev] = 0;
687
688	while (!midi_devs[orig_dev]->outputc(orig_dev, bytes[i]) &&
689	timeout < 1000)
690	timeout++;
691	}
692	if (!sysex_state[dev])
693	return 0;
694	}
695
696	return 0;
697	}