Merge with Linux 2.1.67.

1 files changed, 1590 insertions, 1601 deletions

diff --git a/drivers/sound/sequencer.c b/drivers/sound/sequencer.c
index 14d2f24de..8995e0072 100644
--- a/drivers/sound/sequencer.c
+++ b/drivers/sound/sequencer.c
@@ -16,7 +16,9 @@
 #define SEQUENCER_C
 #include "sound_config.h"
 
-#ifdef CONFIG_SEQUENCER
+#if defined(CONFIG_SEQUENCER) || defined(MODULE)
+#include "softoss.h"
+int             (*softsynthp) (int cmd, int parm1, int parm2, unsigned long parm3) = NULL;
 
 #include "midi_ctrl.h"
 
@@ -57,8 +59,8 @@ static int      midi_opened[MAX_MIDI_DEV] =
 static int      midi_written[MAX_MIDI_DEV] =
 {0};
 
-unsigned long   prev_input_time = 0;
-int             prev_event_time;
+static unsigned long prev_input_time = 0;
+static int      prev_event_time;
 
 #include "tuning.h"
 
@@ -75,433 +77,423 @@ static int      output_threshold;
 static int      pre_event_timeout;
 static unsigned synth_open_mask;
 
-static int      seq_queue (unsigned char *note, char nonblock);
-static void     seq_startplay (void);
-static int      seq_sync (void);
-static void     seq_reset (void);
+static int      seq_queue(unsigned char *note, char nonblock);
+static void     seq_startplay(void);
+static int      seq_sync(void);
+static void     seq_reset(void);
 
 #if MAX_SYNTH_DEV > 15
 #error Too many synthesizer devices enabled.
 #endif
 
 int
-sequencer_read (int dev, struct fileinfo *file, char *buf, int count)
+sequencer_read(int dev, struct fileinfo *file, char *buf, int count)
 {
-  int             c = count, p = 0;
-  int             ev_len;
-  unsigned long   flags;
-
-  dev = dev >> 4;
-
-  ev_len = seq_mode == SEQ_1 ? 4 : 8;
-
-  save_flags (flags);
-  cli ();
-  if (!iqlen)
-    {
-      if ((file->flags & (O_NONBLOCK) ?
-	   1 : 0))
-	{
-	  restore_flags (flags);
-	  return -EAGAIN;
-	}
+	int             c = count, p = 0;
+	int             ev_len;
+	unsigned long   flags;
 
+	dev = dev >> 4;
 
-      {
-	unsigned long   tlimit;
+	ev_len = seq_mode == SEQ_1 ? 4 : 8;
 
-	if (pre_event_timeout)
-	  current->timeout = tlimit = jiffies + (pre_event_timeout);
-	else
-	  tlimit = (unsigned long) -1;
-	midi_sleep_flag.opts = WK_SLEEP;
-	interruptible_sleep_on (&midi_sleeper);
-	if (!(midi_sleep_flag.opts & WK_WAKEUP))
+	save_flags(flags);
+	cli();
+	if (!iqlen)
 	  {
-	    if (jiffies >= tlimit)
-	      midi_sleep_flag.opts |= WK_TIMEOUT;
-	  }
-	midi_sleep_flag.opts &= ~WK_SLEEP;
-      };
-
-      if (!iqlen)
-	{
-	  restore_flags (flags);
-	  return 0;
-	}
-    }
+		  if ((file->flags & (O_NONBLOCK) ?
+		       1 : 0))
+		    {
+			    restore_flags(flags);
+			    return -EAGAIN;
+		    }
+		  {
+			  unsigned long   tlimit;
+
+			  if (pre_event_timeout)
+				  current->timeout = tlimit = jiffies + (pre_event_timeout);
+			  else
+				  tlimit = (unsigned long) -1;
+			  midi_sleep_flag.opts = WK_SLEEP;
+			  interruptible_sleep_on(&midi_sleeper);
+			  if (!(midi_sleep_flag.opts & WK_WAKEUP))
+			    {
+				    if (jiffies >= tlimit)
+					    midi_sleep_flag.opts |= WK_TIMEOUT;
+			    }
+			  midi_sleep_flag.opts &= ~WK_SLEEP;
+		  };
 
-  while (iqlen && c >= ev_len)
-    {
+		  if (!iqlen)
+		    {
+			    restore_flags(flags);
+			    return 0;
+		    }
+	  }
+	while (iqlen && c >= ev_len)
+	  {
 
-      {
-	char           *fixit = (char *) &iqueue[iqhead * IEV_SZ];
+		  {
+			  char           *fixit = (char *) &iqueue[iqhead * IEV_SZ];
 
-	copy_to_user (&(buf)[p], fixit, ev_len);
-      };
-      p += ev_len;
-      c -= ev_len;
+			  copy_to_user(&(buf)[p], fixit, ev_len);
+		  };
+		  p += ev_len;
+		  c -= ev_len;
 
-      iqhead = (iqhead + 1) % SEQ_MAX_QUEUE;
-      iqlen--;
-    }
-  restore_flags (flags);
+		  iqhead = (iqhead + 1) % SEQ_MAX_QUEUE;
+		  iqlen--;
+	  }
+	restore_flags(flags);
 
-  return count - c;
+	return count - c;
 }
 
 static void
-sequencer_midi_output (int dev)
+sequencer_midi_output(int dev)
 {
-  /*
-   * Currently NOP
-   */
+	/*
+	 * Currently NOP
+	 */
 }
 
 void
-seq_copy_to_input (unsigned char *event_rec, int len)
-{
-  unsigned long   flags;
-
-  /*
-     * Verify that the len is valid for the current mode.
-   */
-
-  if (len != 4 && len != 8)
-    return;
-  if ((seq_mode == SEQ_1) != (len == 4))
-    return;
-
-  if (iqlen >= (SEQ_MAX_QUEUE - 1))
-    return;			/* Overflow */
-
-  save_flags (flags);
-  cli ();
-  memcpy (&iqueue[iqtail * IEV_SZ], event_rec, len);
-  iqlen++;
-  iqtail = (iqtail + 1) % SEQ_MAX_QUEUE;
-
-  if ((midi_sleep_flag.opts & WK_SLEEP))
-    {
-      {
-	midi_sleep_flag.opts = WK_WAKEUP;
-	wake_up (&midi_sleeper);
-      };
-    }
-  restore_flags (flags);
-}
-
-static void
-sequencer_midi_input (int dev, unsigned char data)
+seq_copy_to_input(unsigned char *event_rec, int len)
 {
-  unsigned int    tstamp;
-  unsigned char   event_rec[4];
-
-  if (data == 0xfe)		/* Ignore active sensing */
-    return;
+	unsigned long   flags;
 
-  tstamp = jiffies - seq_time;
+	/*
+	   * Verify that the len is valid for the current mode.
+	 */
 
-  if (tstamp != prev_input_time)
-    {
-      tstamp = (tstamp << 8) | SEQ_WAIT;
+	if (len != 4 && len != 8)
+		return;
+	if ((seq_mode == SEQ_1) != (len == 4))
+		return;
 
-      seq_copy_to_input ((unsigned char *) &tstamp, 4);
-      prev_input_time = tstamp;
-    }
+	if (iqlen >= (SEQ_MAX_QUEUE - 1))
+		return;		/* Overflow */
 
-  event_rec[0] = SEQ_MIDIPUTC;
-  event_rec[1] = data;
-  event_rec[2] = dev;
-  event_rec[3] = 0;
+	save_flags(flags);
+	cli();
+	memcpy(&iqueue[iqtail * IEV_SZ], event_rec, len);
+	iqlen++;
+	iqtail = (iqtail + 1) % SEQ_MAX_QUEUE;
 
-  seq_copy_to_input (event_rec, 4);
+	if ((midi_sleep_flag.opts & WK_SLEEP))
+	  {
+		  {
+			  midi_sleep_flag.opts = WK_WAKEUP;
+			  wake_up(&midi_sleeper);
+		  };
+	  }
+	restore_flags(flags);
 }
 
-void
-seq_input_event (unsigned char *event_rec, int len)
+static void
+sequencer_midi_input(int dev, unsigned char data)
 {
-  unsigned long   this_time;
+	unsigned int    tstamp;
+	unsigned char   event_rec[4];
 
-  if (seq_mode == SEQ_2)
-    this_time = tmr->get_time (tmr_no);
-  else
-    this_time = jiffies - seq_time;
+	if (data == 0xfe)	/* Ignore active sensing */
+		return;
 
-  if (this_time != prev_input_time)
-    {
-      unsigned char   tmp_event[8];
+	if (softsynthp != NULL)
+		tstamp = softsynthp(SSYN_GETTIME, 0, 0, 0);
+	else
+		tstamp = jiffies - seq_time;
 
-      tmp_event[0] = EV_TIMING;
-      tmp_event[1] = TMR_WAIT_ABS;
-      tmp_event[2] = 0;
-      tmp_event[3] = 0;
-      *(unsigned int *) &tmp_event[4] = this_time;
+	if (tstamp != prev_input_time)
+	  {
+		  tstamp = (tstamp << 8) | SEQ_WAIT;
 
-      seq_copy_to_input (tmp_event, 8);
-      prev_input_time = this_time;
-    }
+		  seq_copy_to_input((unsigned char *) &tstamp, 4);
+		  prev_input_time = tstamp;
+	  }
+	event_rec[0] = SEQ_MIDIPUTC;
+	event_rec[1] = data;
+	event_rec[2] = dev;
+	event_rec[3] = 0;
 
-  seq_copy_to_input (event_rec, len);
+	seq_copy_to_input(event_rec, 4);
 }
 
-int
-sequencer_write (int dev, struct fileinfo *file, const char *buf, int count)
+void
+seq_input_event(unsigned char *event_rec, int len)
 {
-  unsigned char   event_rec[EV_SZ], ev_code;
-  int             p = 0, c, ev_size;
-  int             err;
-  int             mode = file->mode & O_ACCMODE;
-
-  dev = dev >> 4;
-
-  DEB (printk ("sequencer_write(dev=%d, count=%d)\n", dev, count));
-
-  if (mode == OPEN_READ)
-    return -EIO;
-
-  c = count;
-
-  while (c >= 4)
-    {
-      copy_from_user ((char *) event_rec, &(buf)[p], 4);
-      ev_code = event_rec[0];
-
-      if (ev_code == SEQ_FULLSIZE)
-	{
-	  int             err, fmt;
+	unsigned long   this_time;
 
-	  dev = *(unsigned short *) &event_rec[2];
-	  if (dev < 0 || dev >= max_synthdev)
-	    return -ENXIO;
-
-	  if (!(synth_open_mask & (1 << dev)))
-	    return -ENXIO;
-
-	  fmt = (*(short *) &event_rec[0]) & 0xffff;
-	  err = synth_devs[dev]->load_patch (dev, fmt, buf, p + 4, c, 0);
-	  if (err < 0)
-	    return err;
-
-	  return err;
-	}
-
-      if (ev_code >= 128)
-	{
-	  if (seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED)
-	    {
-	      printk ("Sequencer: Invalid level 2 event %x\n", ev_code);
-	      return -EINVAL;
-	    }
-
-	  ev_size = 8;
-
-	  if (c < ev_size)
-	    {
-	      if (!seq_playing)
-		seq_startplay ();
-	      return count - c;
-	    }
-
-	  copy_from_user ((char *) &event_rec[4], &(buf)[p + 4], 4);
-
-	}
-      else
-	{
-	  if (seq_mode == SEQ_2)
-	    {
-	      printk ("Sequencer: 4 byte event in level 2 mode\n");
-	      return -EINVAL;
-	    }
-	  ev_size = 4;
-
-	  if (event_rec[0] != SEQ_MIDIPUTC)
-	    obsolete_api_used = 1;
-	}
-
-      if (event_rec[0] == SEQ_MIDIPUTC)
-	{
+	if (seq_mode == SEQ_2)
+		this_time = tmr->get_time(tmr_no);
+	else if (softsynthp != NULL)
+		this_time = softsynthp(SSYN_GETTIME, 0, 0, 0);
+	else
+		this_time = jiffies - seq_time;
 
-	  if (!midi_opened[event_rec[2]])
-	    {
-	      int             mode;
-	      int             dev = event_rec[2];
+	if (this_time != prev_input_time)
+	  {
+		  unsigned char   tmp_event[8];
 
-	      if (dev >= max_mididev)
-		{
-		  printk ("Sequencer Error: Nonexistent MIDI device %d\n", dev);
-		  return -ENXIO;
-		}
+		  tmp_event[0] = EV_TIMING;
+		  tmp_event[1] = TMR_WAIT_ABS;
+		  tmp_event[2] = 0;
+		  tmp_event[3] = 0;
+		  *(unsigned int *) &tmp_event[4] = this_time;
 
-	      mode = file->mode & O_ACCMODE;
+		  seq_copy_to_input(tmp_event, 8);
+		  prev_input_time = this_time;
+	  }
+	seq_copy_to_input(event_rec, len);
+}
 
-	      if ((err = midi_devs[dev]->open (dev, mode,
-			  sequencer_midi_input, sequencer_midi_output)) < 0)
-		{
-		  seq_reset ();
-		  printk ("Sequencer Error: Unable to open Midi #%d\n", dev);
-		  return err;
-		}
+int
+sequencer_write(int dev, struct fileinfo *file, const char *buf, int count)
+{
+	unsigned char   event_rec[EV_SZ], ev_code;
+	int             p = 0, c, ev_size;
+	int             err;
+	int             mode = file->mode & O_ACCMODE;
 
-	      midi_opened[dev] = 1;
-	    }
+	dev = dev >> 4;
 
-	}
+	DEB(printk("sequencer_write(dev=%d, count=%d)\n", dev, count));
 
-      if (!seq_queue (event_rec, (file->flags & (O_NONBLOCK) ?
-				  1 : 0)))
-	{
-	  int             processed = count - c;
+	if (mode == OPEN_READ)
+		return -EIO;
 
-	  if (!seq_playing)
-	    seq_startplay ();
+	c = count;
 
-	  if (!processed && (file->flags & (O_NONBLOCK) ?
-			     1 : 0))
-	    return -EAGAIN;
-	  else
-	    return processed;
-	}
-
-      p += ev_size;
-      c -= ev_size;
-    }
+	while (c >= 4)
+	  {
+		  copy_from_user((char *) event_rec, &(buf)[p], 4);
+		  ev_code = event_rec[0];
+
+		  if (ev_code == SEQ_FULLSIZE)
+		    {
+			    int             err, fmt;
+
+			    dev = *(unsigned short *) &event_rec[2];
+			    if (dev < 0 || dev >= max_synthdev || synth_devs[dev] == NULL)
+				    return -ENXIO;
+
+			    if (!(synth_open_mask & (1 << dev)))
+				    return -ENXIO;
+
+			    fmt = (*(short *) &event_rec[0]) & 0xffff;
+			    err = synth_devs[dev]->load_patch(dev, fmt, buf, p + 4, c, 0);
+			    if (err < 0)
+				    return err;
+
+			    return err;
+		    }
+		  if (ev_code >= 128)
+		    {
+			    if (seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED)
+			      {
+				      printk("Sequencer: Invalid level 2 event %x\n", ev_code);
+				      return -EINVAL;
+			      }
+			    ev_size = 8;
+
+			    if (c < ev_size)
+			      {
+				      if (!seq_playing)
+					      seq_startplay();
+				      return count - c;
+			      }
+			    copy_from_user((char *) &event_rec[4], &(buf)[p + 4], 4);
+
+		  } else
+		    {
+			    if (seq_mode == SEQ_2)
+			      {
+				      printk("Sequencer: 4 byte event in level 2 mode\n");
+				      return -EINVAL;
+			      }
+			    ev_size = 4;
+
+			    if (event_rec[0] != SEQ_MIDIPUTC)
+				    obsolete_api_used = 1;
+		    }
+
+		  if (event_rec[0] == SEQ_MIDIPUTC)
+		    {
+
+			    if (!midi_opened[event_rec[2]])
+			      {
+				      int             mode;
+				      int             dev = event_rec[2];
+
+				      if (dev >= max_mididev)
+					{
+						printk("Sequencer Error: Nonexistent MIDI device %d\n", dev);
+						return -ENXIO;
+					}
+				      mode = file->mode & O_ACCMODE;
+
+				      if ((err = midi_devs[dev]->open(dev, mode,
+								      sequencer_midi_input, sequencer_midi_output)) < 0)
+					{
+						seq_reset();
+						printk("Sequencer Error: Unable to open Midi #%d\n", dev);
+						return err;
+					}
+				      midi_opened[dev] = 1;
+			      }
+		    }
+		  if (!seq_queue(event_rec, (file->flags & (O_NONBLOCK) ?
+					     1 : 0)))
+		    {
+			    int             processed = count - c;
+
+			    if (!seq_playing)
+				    seq_startplay();
+
+			    if (!processed && (file->flags & (O_NONBLOCK) ?
+					       1 : 0))
+				    return -EAGAIN;
+			    else
+				    return processed;
+		    }
+		  p += ev_size;
+		  c -= ev_size;
+	  }
 
-  if (!seq_playing)
-    seq_startplay ();
+	if (!seq_playing)
+		seq_startplay();
 
-  return count;
+	return count;
 }
 
 static int
-seq_queue (unsigned char *note, char nonblock)
+seq_queue(unsigned char *note, char nonblock)
 {
 
-  /*
-   * Test if there is space in the queue
-   */
-
-  if (qlen >= SEQ_MAX_QUEUE)
-    if (!seq_playing)
-      seq_startplay ();		/*
-				 * Give chance to drain the queue
-				 */
+	/*
+	 * Test if there is space in the queue
+	 */
 
-  if (!nonblock && qlen >= SEQ_MAX_QUEUE && !(seq_sleep_flag.opts & WK_SLEEP))
-    {
-      /*
-       * Sleep until there is enough space on the queue
-       */
+	if (qlen >= SEQ_MAX_QUEUE)
+		if (!seq_playing)
+			seq_startplay();	/*
+						 * Give chance to drain the queue
+						 */
 
-      seq_sleep_flag.opts = WK_SLEEP;
-      interruptible_sleep_on (&seq_sleeper);
-      seq_sleep_flag.opts &= ~WK_SLEEP;;
-    }
+	if (!nonblock && qlen >= SEQ_MAX_QUEUE && !(seq_sleep_flag.opts & WK_SLEEP))
+	  {
+		  /*
+		   * Sleep until there is enough space on the queue
+		   */
 
-  if (qlen >= SEQ_MAX_QUEUE)
-    {
-      return 0;			/*
+		  seq_sleep_flag.opts = WK_SLEEP;
+		  interruptible_sleep_on(&seq_sleeper);
+		  seq_sleep_flag.opts &= ~WK_SLEEP;;
+	  }
+	if (qlen >= SEQ_MAX_QUEUE)
+	  {
+		  return 0;	/*
 				 * To be sure
 				 */
-    }
-  memcpy (&queue[qtail * EV_SZ], note, EV_SZ);
+	  }
+	memcpy(&queue[qtail * EV_SZ], note, EV_SZ);
 
-  qtail = (qtail + 1) % SEQ_MAX_QUEUE;
-  qlen++;
+	qtail = (qtail + 1) % SEQ_MAX_QUEUE;
+	qlen++;
 
-  return 1;
+	return 1;
 }
 
 static int
-extended_event (unsigned char *q)
+extended_event(unsigned char *q)
 {
-  int             dev = q[2];
+	int             dev = q[2];
 
-  if (dev < 0 || dev >= max_synthdev)
-    return -ENXIO;
+	if (dev < 0 || dev >= max_synthdev)
+		return -ENXIO;
 
-  if (!(synth_open_mask & (1 << dev)))
-    return -ENXIO;
+	if (!(synth_open_mask & (1 << dev)))
+		return -ENXIO;
 
-  switch (q[1])
-    {
-    case SEQ_NOTEOFF:
-      synth_devs[dev]->kill_note (dev, q[3], q[4], q[5]);
-      break;
+	switch (q[1])
+	  {
+	  case SEQ_NOTEOFF:
+		  synth_devs[dev]->kill_note(dev, q[3], q[4], q[5]);
+		  break;
+
+	  case SEQ_NOTEON:
+		  if (q[4] > 127 && q[4] != 255)
+			  return 0;
+
+		  if (q[5] == 0)
+		    {
+			    synth_devs[dev]->kill_note(dev, q[3], q[4], q[5]);
+			    break;
+		    }
+		  synth_devs[dev]->start_note(dev, q[3], q[4], q[5]);
+		  break;
+
+	  case SEQ_PGMCHANGE:
+		  synth_devs[dev]->set_instr(dev, q[3], q[4]);
+		  break;
+
+	  case SEQ_AFTERTOUCH:
+		  synth_devs[dev]->aftertouch(dev, q[3], q[4]);
+		  break;
+
+	  case SEQ_BALANCE:
+		  synth_devs[dev]->panning(dev, q[3], (char) q[4]);
+		  break;
+
+	  case SEQ_CONTROLLER:
+		  synth_devs[dev]->controller(dev, q[3], q[4], (short) (q[5] | (q[6] << 8)));
+		  break;
+
+	  case SEQ_VOLMODE:
+		  if (synth_devs[dev]->volume_method != NULL)
+			  synth_devs[dev]->volume_method(dev, q[3]);
+		  break;
+
+	  default:
+		  return -EINVAL;
+	  }
 
-    case SEQ_NOTEON:
-      if (q[4] > 127 && q[4] != 255)
 	return 0;
-
-      if (q[5] == 0)
-	{
-	  synth_devs[dev]->kill_note (dev, q[3], q[4], q[5]);
-	  break;
-	}
-      synth_devs[dev]->start_note (dev, q[3], q[4], q[5]);
-      break;
-
-    case SEQ_PGMCHANGE:
-      synth_devs[dev]->set_instr (dev, q[3], q[4]);
-      break;
-
-    case SEQ_AFTERTOUCH:
-      synth_devs[dev]->aftertouch (dev, q[3], q[4]);
-      break;
-
-    case SEQ_BALANCE:
-      synth_devs[dev]->panning (dev, q[3], (char) q[4]);
-      break;
-
-    case SEQ_CONTROLLER:
-      synth_devs[dev]->controller (dev, q[3], q[4], (short) (q[5] | (q[6] << 8)));
-      break;
-
-    case SEQ_VOLMODE:
-      if (synth_devs[dev]->volume_method != NULL)
-	synth_devs[dev]->volume_method (dev, q[3]);
-      break;
-
-    default:
-      return -EINVAL;
-    }
-
-  return 0;
 }
 
 static int
-find_voice (int dev, int chn, int note)
+find_voice(int dev, int chn, int note)
 {
-  unsigned short  key;
-  int             i;
+	unsigned short  key;
+	int             i;
 
-  key = (chn << 8) | (note + 1);
+	key = (chn << 8) | (note + 1);
 
-  for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
-    if (synth_devs[dev]->alloc.map[i] == key)
-      return i;
+	for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
+		if (synth_devs[dev]->alloc.map[i] == key)
+			return i;
 
-  return -1;
+	return -1;
 }
 
 static int
-alloc_voice (int dev, int chn, int note)
+alloc_voice(int dev, int chn, int note)
 {
-  unsigned short  key;
-  int             voice;
+	unsigned short  key;
+	int             voice;
 
-  key = (chn << 8) | (note + 1);
+	key = (chn << 8) | (note + 1);
 
-  voice = synth_devs[dev]->alloc_voice (dev, chn, note,
-					&synth_devs[dev]->alloc);
-  synth_devs[dev]->alloc.map[voice] = key;
-  synth_devs[dev]->alloc.alloc_times[voice] =
-    synth_devs[dev]->alloc.timestamp++;
-  return voice;
+	voice = synth_devs[dev]->alloc_voice(dev, chn, note,
+					     &synth_devs[dev]->alloc);
+	synth_devs[dev]->alloc.map[voice] = key;
+	synth_devs[dev]->alloc.alloc_times[voice] =
+	    synth_devs[dev]->alloc.timestamp++;
+	return voice;
 }
 
 static void
-seq_chn_voice_event (unsigned char *event_rec)
+seq_chn_voice_event(unsigned char *event_rec)
 {
 #define dev event_rec[1]
 #define cmd event_rec[2]
@@ -509,73 +501,70 @@ seq_chn_voice_event (unsigned char *event_rec)
 #define note event_rec[4]
 #define parm event_rec[5]
 
-  int             voice = -1;
+	int             voice = -1;
 
-  if ((int) dev > max_synthdev)
-    return;
-  if (!(synth_open_mask & (1 << dev)))
-    return;
-  if (!synth_devs[dev])
-    return;
-
-  if (seq_mode == SEQ_2)
-    {
-      if (synth_devs[dev]->alloc_voice)
-	voice = find_voice (dev, chn, note);
+	if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
+		return;
+	if (!(synth_open_mask & (1 << dev)))
+		return;
+	if (!synth_devs[dev])
+		return;
 
-      if (cmd == MIDI_NOTEON && parm == 0)
-	{
-	  cmd = MIDI_NOTEOFF;
-	  parm = 64;
-	}
-    }
-
-  switch (cmd)
-    {
-    case MIDI_NOTEON:
-      if (note > 127 && note != 255)	/* Not a seq2 feature */
-	return;
-
-      if (voice == -1 && seq_mode == SEQ_2 && synth_devs[dev]->alloc_voice)
-	{			/* Internal synthesizer (FM, GUS, etc) */
-	  voice = alloc_voice (dev, chn, note);
-	}
-
-      if (voice == -1)
-	voice = chn;
-
-      if (seq_mode == SEQ_2 && (int) dev < num_synths)
-	{
-	  /*
-	     * The MIDI channel 10 is a percussive channel. Use the note
-	     * number to select the proper patch (128 to 255) to play.
-	   */
-
-	  if (chn == 9)
-	    {
-	      synth_devs[dev]->set_instr (dev, voice, 128 + note);
-	      synth_devs[dev]->chn_info[chn].pgm_num = 128 + note;
-	    }
-	  synth_devs[dev]->setup_voice (dev, voice, chn);
-	}
-
-      synth_devs[dev]->start_note (dev, voice, note, parm);
-      break;
-
-    case MIDI_NOTEOFF:
-      if (voice == -1)
-	voice = chn;
-      synth_devs[dev]->kill_note (dev, voice, note, parm);
-      break;
-
-    case MIDI_KEY_PRESSURE:
-      if (voice == -1)
-	voice = chn;
-      synth_devs[dev]->aftertouch (dev, voice, parm);
-      break;
-
-    default:;
-    }
+	if (seq_mode == SEQ_2)
+	  {
+		  if (synth_devs[dev]->alloc_voice)
+			  voice = find_voice(dev, chn, note);
+
+		  if (cmd == MIDI_NOTEON && parm == 0)
+		    {
+			    cmd = MIDI_NOTEOFF;
+			    parm = 64;
+		    }
+	  }
+	switch (cmd)
+	  {
+	  case MIDI_NOTEON:
+		  if (note > 127 && note != 255)	/* Not a seq2 feature */
+			  return;
+
+		  if (voice == -1 && seq_mode == SEQ_2 && synth_devs[dev]->alloc_voice)
+		    {		/* Internal synthesizer (FM, GUS, etc) */
+			    voice = alloc_voice(dev, chn, note);
+		    }
+		  if (voice == -1)
+			  voice = chn;
+
+		  if (seq_mode == SEQ_2 && (int) dev < num_synths)
+		    {
+			    /*
+			       * The MIDI channel 10 is a percussive channel. Use the note
+			       * number to select the proper patch (128 to 255) to play.
+			     */
+
+			    if (chn == 9)
+			      {
+				      synth_devs[dev]->set_instr(dev, voice, 128 + note);
+				      synth_devs[dev]->chn_info[chn].pgm_num = 128 + note;
+			      }
+			    synth_devs[dev]->setup_voice(dev, voice, chn);
+		    }
+		  synth_devs[dev]->start_note(dev, voice, note, parm);
+		  break;
+
+	  case MIDI_NOTEOFF:
+		  if (voice == -1)
+			  voice = chn;
+		  synth_devs[dev]->kill_note(dev, voice, note, parm);
+		  break;
+
+	  case MIDI_KEY_PRESSURE:
+		  if (voice == -1)
+			  voice = chn;
+		  synth_devs[dev]->aftertouch(dev, voice, parm);
+		  break;
+
+	  default:;
+	  }
 #undef dev
 #undef cmd
 #undef chn
@@ -585,1422 +574,1422 @@ seq_chn_voice_event (unsigned char *event_rec)
 
 
 static void
-seq_chn_common_event (unsigned char *event_rec)
+seq_chn_common_event(unsigned char *event_rec)
 {
-  unsigned char   dev = event_rec[1];
-  unsigned char   cmd = event_rec[2];
-  unsigned char   chn = event_rec[3];
-  unsigned char   p1 = event_rec[4];
-
-  /* unsigned char   p2 = event_rec[5]; */
-  unsigned short  w14 = *(short *) &event_rec[6];
-
-  if ((int) dev > max_synthdev)
-    return;
-  if (!(synth_open_mask & (1 << dev)))
-    return;
-  if (!synth_devs[dev])
-    return;
-
-  switch (cmd)
-    {
-    case MIDI_PGM_CHANGE:
-      if (seq_mode == SEQ_2)
-	{
-	  synth_devs[dev]->chn_info[chn].pgm_num = p1;
-	  if ((int) dev >= num_synths)
-	    synth_devs[dev]->set_instr (dev, chn, p1);
-	}
-      else
-	synth_devs[dev]->set_instr (dev, chn, p1);
+	unsigned char   dev = event_rec[1];
+	unsigned char   cmd = event_rec[2];
+	unsigned char   chn = event_rec[3];
+	unsigned char   p1 = event_rec[4];
 
-      break;
+	/* unsigned char   p2 = event_rec[5]; */
+	unsigned short  w14 = *(short *) &event_rec[6];
 
-    case MIDI_CTL_CHANGE:
-      if (seq_mode == SEQ_2)
-	{
-	  if (chn > 15 || p1 > 127)
-	    break;
-
-	  synth_devs[dev]->chn_info[chn].controllers[p1] = w14 & 0x7f;
-
-	  if (p1 < 32)		/* Setting MSB should clear LSB to 0 */
-	    synth_devs[dev]->chn_info[chn].controllers[p1 + 32] = 0;
-
-	  if ((int) dev < num_synths)
-	    {
-	      int             val = w14 & 0x7f;
-	      int             i, key;
-
-	      if (p1 < 64)	/* Combine MSB and LSB */
-		{
-		  val = ((synth_devs[dev]->
-			  chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
-		    | (synth_devs[dev]->
-		       chn_info[chn].controllers[p1 | 32] & 0x7f);
-		  p1 &= ~32;
-		}
-
-	      /* Handle all playing notes on this channel */
-
-	      key = ((int) chn << 8);
-
-	      for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
-		if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
-		  synth_devs[dev]->controller (dev, i, p1, val);
-	    }
-	  else
-	    synth_devs[dev]->controller (dev, chn, p1, w14);
-	}
-      else			/* Mode 1 */
-	synth_devs[dev]->controller (dev, chn, p1, w14);
-      break;
-
-    case MIDI_PITCH_BEND:
-      if (seq_mode == SEQ_2)
-	{
-	  synth_devs[dev]->chn_info[chn].bender_value = w14;
-
-	  if ((int) dev < num_synths)
-	    {			/* Handle all playing notes on this channel */
-	      int             i, key;
-
-	      key = (chn << 8);
-
-	      for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
-		if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
-		  synth_devs[dev]->bender (dev, i, w14);
-	    }
-	  else
-	    synth_devs[dev]->bender (dev, chn, w14);
-	}
-      else			/* MODE 1 */
-	synth_devs[dev]->bender (dev, chn, w14);
-      break;
-
-    default:;
-    }
+	if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
+		return;
+	if (!(synth_open_mask & (1 << dev)))
+		return;
+	if (!synth_devs[dev])
+		return;
+
+	switch (cmd)
+	  {
+	  case MIDI_PGM_CHANGE:
+		  if (seq_mode == SEQ_2)
+		    {
+			    synth_devs[dev]->chn_info[chn].pgm_num = p1;
+			    if ((int) dev >= num_synths)
+				    synth_devs[dev]->set_instr(dev, chn, p1);
+		  } else
+			  synth_devs[dev]->set_instr(dev, chn, p1);
+
+		  break;
+
+	  case MIDI_CTL_CHANGE:
+		  if (seq_mode == SEQ_2)
+		    {
+			    if (chn > 15 || p1 > 127)
+				    break;
+
+			    synth_devs[dev]->chn_info[chn].controllers[p1] = w14 & 0x7f;
+
+			    if (p1 < 32)	/* Setting MSB should clear LSB to 0 */
+				    synth_devs[dev]->chn_info[chn].controllers[p1 + 32] = 0;
+
+			    if ((int) dev < num_synths)
+			      {
+				      int             val = w14 & 0x7f;
+				      int             i, key;
+
+				      if (p1 < 64)	/* Combine MSB and LSB */
+					{
+						val = ((synth_devs[dev]->
+							chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
+						    | (synth_devs[dev]->
+						       chn_info[chn].controllers[p1 | 32] & 0x7f);
+						p1 &= ~32;
+					}
+				      /* Handle all playing notes on this channel */
+
+				      key = ((int) chn << 8);
+
+				      for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
+					      if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
+						      synth_devs[dev]->controller(dev, i, p1, val);
+			    } else
+				    synth_devs[dev]->controller(dev, chn, p1, w14);
+		  } else	/* Mode 1 */
+			  synth_devs[dev]->controller(dev, chn, p1, w14);
+		  break;
+
+	  case MIDI_PITCH_BEND:
+		  if (seq_mode == SEQ_2)
+		    {
+			    synth_devs[dev]->chn_info[chn].bender_value = w14;
+
+			    if ((int) dev < num_synths)
+			      {	/* Handle all playing notes on this channel */
+				      int             i, key;
+
+				      key = (chn << 8);
+
+				      for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
+					      if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
+						      synth_devs[dev]->bender(dev, i, w14);
+			    } else
+				    synth_devs[dev]->bender(dev, chn, w14);
+		  } else	/* MODE 1 */
+			  synth_devs[dev]->bender(dev, chn, w14);
+		  break;
+
+	  default:;
+	  }
 }
 
 static int
-seq_timing_event (unsigned char *event_rec)
+seq_timing_event(unsigned char *event_rec)
 {
-  unsigned char   cmd = event_rec[1];
-  unsigned int    parm = *(int *) &event_rec[4];
-
-  if (seq_mode == SEQ_2)
-    {
-      int             ret;
-
-      if ((ret = tmr->event (tmr_no, event_rec)) == TIMER_ARMED)
-	{
-	  if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
-	    {
-	      unsigned long   flags;
-
-	      save_flags (flags);
-	      cli ();
-	      if ((seq_sleep_flag.opts & WK_SLEEP))
-		{
-		  {
-		    seq_sleep_flag.opts = WK_WAKEUP;
-		    wake_up (&seq_sleeper);
-		  };
-		}
-	      restore_flags (flags);
-	    }
-	}
-      return ret;
-    }
-
-  switch (cmd)
-    {
-    case TMR_WAIT_REL:
-      parm += prev_event_time;
-
-      /*
-         * NOTE!  No break here. Execution of TMR_WAIT_REL continues in the
-         * next case (TMR_WAIT_ABS)
-       */
-
-    case TMR_WAIT_ABS:
-      if (parm > 0)
-	{
-	  long            time;
-
-	  time = parm;
-	  prev_event_time = time;
-
-	  seq_playing = 1;
-	  request_sound_timer (time);
-
-	  if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
-	    {
-	      unsigned long   flags;
+	unsigned char   cmd = event_rec[1];
+	unsigned int    parm = *(int *) &event_rec[4];
 
-	      save_flags (flags);
-	      cli ();
-	      if ((seq_sleep_flag.opts & WK_SLEEP))
-		{
-		  {
-		    seq_sleep_flag.opts = WK_WAKEUP;
-		    wake_up (&seq_sleeper);
-		  };
-		}
-	      restore_flags (flags);
-	    }
-
-	  return TIMER_ARMED;
-	}
-      break;
-
-    case TMR_START:
-      seq_time = jiffies;
-      prev_input_time = 0;
-      prev_event_time = 0;
-      break;
-
-    case TMR_STOP:
-      break;
-
-    case TMR_CONTINUE:
-      break;
-
-    case TMR_TEMPO:
-      break;
-
-    case TMR_ECHO:
-      if (seq_mode == SEQ_2)
-	seq_copy_to_input (event_rec, 8);
-      else
-	{
-	  parm = (parm << 8 | SEQ_ECHO);
-	  seq_copy_to_input ((unsigned char *) &parm, 4);
-	}
-      break;
-
-    default:;
-    }
+	if (seq_mode == SEQ_2)
+	  {
+		  int             ret;
+
+		  if ((ret = tmr->event(tmr_no, event_rec)) == TIMER_ARMED)
+		    {
+			    if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
+			      {
+				      unsigned long   flags;
+
+				      save_flags(flags);
+				      cli();
+				      if ((seq_sleep_flag.opts & WK_SLEEP))
+					{
+						{
+							seq_sleep_flag.opts = WK_WAKEUP;
+							wake_up(&seq_sleeper);
+						};
+					}
+				      restore_flags(flags);
+			      }
+		    }
+		  return ret;
+	  }
+	switch (cmd)
+	  {
+	  case TMR_WAIT_REL:
+		  parm += prev_event_time;
+
+		  /*
+		     * NOTE!  No break here. Execution of TMR_WAIT_REL continues in the
+		     * next case (TMR_WAIT_ABS)
+		   */
+
+	  case TMR_WAIT_ABS:
+		  if (parm > 0)
+		    {
+			    long            time;
+
+			    time = parm;
+			    prev_event_time = time;
+
+			    seq_playing = 1;
+			    if (softsynthp != NULL)
+				    softsynthp(SSYN_REQUEST, time, 0, 0);
+			    else
+				    request_sound_timer(time);
+
+			    if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
+			      {
+				      unsigned long   flags;
+
+				      save_flags(flags);
+				      cli();
+				      if ((seq_sleep_flag.opts & WK_SLEEP))
+					{
+						{
+							seq_sleep_flag.opts = WK_WAKEUP;
+							wake_up(&seq_sleeper);
+						};
+					}
+				      restore_flags(flags);
+			      }
+			    return TIMER_ARMED;
+		    }
+		  break;
+
+	  case TMR_START:
+		  if (softsynthp != NULL)
+		    {
+			    softsynthp(SSYN_START, 0, 0, 0);
+			    seq_time = 0;
+		  } else
+			  seq_time = jiffies;
+		  prev_input_time = 0;
+		  prev_event_time = 0;
+		  break;
+
+	  case TMR_STOP:
+		  break;
+
+	  case TMR_CONTINUE:
+		  break;
+
+	  case TMR_TEMPO:
+		  break;
+
+	  case TMR_ECHO:
+		  if (seq_mode == SEQ_2)
+			  seq_copy_to_input(event_rec, 8);
+		  else
+		    {
+			    parm = (parm << 8 | SEQ_ECHO);
+			    seq_copy_to_input((unsigned char *) &parm, 4);
+		    }
+		  break;
+
+	  default:;
+	  }
 
-  return TIMER_NOT_ARMED;
+	return TIMER_NOT_ARMED;
 }
 
 static void
-seq_local_event (unsigned char *event_rec)
+seq_local_event(unsigned char *event_rec)
 {
-  unsigned char   cmd = event_rec[1];
-  unsigned int    parm = *((unsigned int *) &event_rec[4]);
+	unsigned char   cmd = event_rec[1];
+	unsigned int    parm = *((unsigned int *) &event_rec[4]);
 
-  switch (cmd)
-    {
-    case LOCL_STARTAUDIO:
+	switch (cmd)
+	  {
+	  case LOCL_STARTAUDIO:
 #ifdef CONFIG_AUDIO
-      DMAbuf_start_devices (parm);
+		  DMAbuf_start_devices(parm);
 #endif
-      break;
+		  break;
 
-    default:;
-    }
+	  default:;
+	  }
 }
 
 static void
-seq_sysex_message (unsigned char *event_rec)
+seq_sysex_message(unsigned char *event_rec)
 {
-  int             dev = event_rec[1];
-  int             i, l = 0;
-  unsigned char  *buf = &event_rec[2];
-
-  if ((int) dev > max_synthdev)
-    return;
-  if (!(synth_open_mask & (1 << dev)))
-    return;
-  if (!synth_devs[dev])
-    return;
-
-  l = 0;
-  for (i = 0; i < 6 && buf[i] != 0xff; i++)
-    l = i + 1;
-
-  if (!synth_devs[dev]->send_sysex)
-    return;
-  if (l > 0)
-    synth_devs[dev]->send_sysex (dev, buf, l);
+	int             dev = event_rec[1];
+	int             i, l = 0;
+	unsigned char  *buf = &event_rec[2];
+
+	if ((int) dev > max_synthdev)
+		return;
+	if (!(synth_open_mask & (1 << dev)))
+		return;
+	if (!synth_devs[dev])
+		return;
+
+	l = 0;
+	for (i = 0; i < 6 && buf[i] != 0xff; i++)
+		l = i + 1;
+
+	if (!synth_devs[dev]->send_sysex)
+		return;
+	if (l > 0)
+		synth_devs[dev]->send_sysex(dev, buf, l);
 }
 
 static int
-play_event (unsigned char *q)
+play_event(unsigned char *q)
 {
-  /*
-     * NOTE! This routine returns
-     *   0 = normal event played.
-     *   1 = Timer armed. Suspend playback until timer callback.
-     *   2 = MIDI output buffer full. Restore queue and suspend until timer
-   */
-  unsigned int   *delay;
-
-  switch (q[0])
-    {
-    case SEQ_NOTEOFF:
-      if (synth_open_mask & (1 << 0))
-	if (synth_devs[0])
-	  synth_devs[0]->kill_note (0, q[1], 255, q[3]);
-      break;
-
-    case SEQ_NOTEON:
-      if (q[4] < 128 || q[4] == 255)
-	if (synth_open_mask & (1 << 0))
-	  if (synth_devs[0])
-	    synth_devs[0]->start_note (0, q[1], q[2], q[3]);
-      break;
-
-    case SEQ_WAIT:
-      delay = (unsigned int *) q;	/*
-					 * Bytes 1 to 3 are containing the *
-					 * delay in 'ticks'
-					 */
-      *delay = (*delay >> 8) & 0xffffff;
-
-      if (*delay > 0)
-	{
-	  long            time;
-
-	  seq_playing = 1;
-	  time = *delay;
-	  prev_event_time = time;
-
-	  request_sound_timer (time);
-
-	  if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
-	    {
-	      unsigned long   flags;
-
-	      save_flags (flags);
-	      cli ();
-	      if ((seq_sleep_flag.opts & WK_SLEEP))
-		{
-		  {
-		    seq_sleep_flag.opts = WK_WAKEUP;
-		    wake_up (&seq_sleeper);
-		  };
-		}
-	      restore_flags (flags);
-	    }
-	  /*
-	     * The timer is now active and will reinvoke this function
-	     * after the timer expires. Return to the caller now.
-	   */
-	  return 1;
-	}
-      break;
-
-    case SEQ_PGMCHANGE:
-      if (synth_open_mask & (1 << 0))
-	if (synth_devs[0])
-	  synth_devs[0]->set_instr (0, q[1], q[2]);
-      break;
-
-    case SEQ_SYNCTIMER:	/*
-				 * Reset timer
+	/*
+	   * NOTE! This routine returns
+	   *   0 = normal event played.
+	   *   1 = Timer armed. Suspend playback until timer callback.
+	   *   2 = MIDI output buffer full. Restore queue and suspend until timer
+	 */
+	unsigned int   *delay;
+
+	switch (q[0])
+	  {
+	  case SEQ_NOTEOFF:
+		  if (synth_open_mask & (1 << 0))
+			  if (synth_devs[0])
+				  synth_devs[0]->kill_note(0, q[1], 255, q[3]);
+		  break;
+
+	  case SEQ_NOTEON:
+		  if (q[4] < 128 || q[4] == 255)
+			  if (synth_open_mask & (1 << 0))
+				  if (synth_devs[0])
+					  synth_devs[0]->start_note(0, q[1], q[2], q[3]);
+		  break;
+
+	  case SEQ_WAIT:
+		  delay = (unsigned int *) q;	/*
+						 * Bytes 1 to 3 are containing the *
+						 * delay in 'ticks'
+						 */
+		  *delay = (*delay >> 8) & 0xffffff;
+
+		  if (*delay > 0)
+		    {
+			    long            time;
+
+			    seq_playing = 1;
+			    time = *delay;
+			    prev_event_time = time;
+
+			    if (softsynthp != NULL)
+				    softsynthp(SSYN_REQUEST, time, 0, 0);
+			    else
+				    request_sound_timer(time);
+
+			    if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
+			      {
+				      unsigned long   flags;
+
+				      save_flags(flags);
+				      cli();
+				      if ((seq_sleep_flag.opts & WK_SLEEP))
+					{
+						{
+							seq_sleep_flag.opts = WK_WAKEUP;
+							wake_up(&seq_sleeper);
+						};
+					}
+				      restore_flags(flags);
+			      }
+			    /*
+			       * The timer is now active and will reinvoke this function
+			       * after the timer expires. Return to the caller now.
+			     */
+			    return 1;
+		    }
+		  break;
+
+	  case SEQ_PGMCHANGE:
+		  if (synth_open_mask & (1 << 0))
+			  if (synth_devs[0])
+				  synth_devs[0]->set_instr(0, q[1], q[2]);
+		  break;
+
+	  case SEQ_SYNCTIMER:	/*
+				   * Reset timer
 				 */
-      seq_time = jiffies;
-      prev_input_time = 0;
-      prev_event_time = 0;
-      break;
-
-    case SEQ_MIDIPUTC:		/*
+		  if (softsynthp != NULL)
+			  seq_time = 0;
+		  else
+			  seq_time = jiffies;
+		  prev_input_time = 0;
+		  prev_event_time = 0;
+		  if (softsynthp != NULL)
+			  softsynthp(SSYN_START, 0, 0, 0);
+		  break;
+
+	  case SEQ_MIDIPUTC:	/*
 				 * Put a midi character
 				 */
-      if (midi_opened[q[2]])
-	{
-	  int             dev;
-
-	  dev = q[2];
-
-	  if (dev < 0 || dev >= num_midis)
-	    break;
-
-	  if (!midi_devs[dev]->outputc (dev, q[1]))
-	    {
-	      /*
-	         * Output FIFO is full. Wait one timer cycle and try again.
-	       */
-
-	      seq_playing = 1;
-	      request_sound_timer (-1);
-	      return 2;
-	    }
-	  else
-	    midi_written[dev] = 1;
-	}
-      break;
-
-    case SEQ_ECHO:
-      seq_copy_to_input (q, 4);	/*
-				 * Echo back to the process
-				 */
-      break;
-
-    case SEQ_PRIVATE:
-      if ((int) q[1] < max_synthdev)
-	synth_devs[q[1]]->hw_control (q[1], q);
-      break;
-
-    case SEQ_EXTENDED:
-      extended_event (q);
-      break;
-
-    case EV_CHN_VOICE:
-      seq_chn_voice_event (q);
-      break;
-
-    case EV_CHN_COMMON:
-      seq_chn_common_event (q);
-      break;
-
-    case EV_TIMING:
-      if (seq_timing_event (q) == TIMER_ARMED)
-	{
-	  return 1;
-	}
-      break;
-
-    case EV_SEQ_LOCAL:
-      seq_local_event (q);
-      break;
-
-    case EV_SYSEX:
-      seq_sysex_message (q);
-      break;
-
-    default:;
-    }
+		  if (midi_opened[q[2]])
+		    {
+			    int             dev;
+
+			    dev = q[2];
+
+			    if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
+				    break;
+
+			    if (!midi_devs[dev]->outputc(dev, q[1]))
+			      {
+				      /*
+				         * Output FIFO is full. Wait one timer cycle and try again.
+				       */
+
+				      seq_playing = 1;
+				      if (softsynthp != NULL)
+					      softsynthp(SSYN_REQUEST, -1, 0, 0);
+				      else
+					      request_sound_timer(-1);
+				      return 2;
+			    } else
+				    midi_written[dev] = 1;
+		    }
+		  break;
+
+	  case SEQ_ECHO:
+		  seq_copy_to_input(q, 4);	/*
+						 * Echo back to the process
+						 */
+		  break;
+
+	  case SEQ_PRIVATE:
+		  if ((int) q[1] < max_synthdev)
+			  synth_devs[q[1]]->hw_control(q[1], q);
+		  break;
+
+	  case SEQ_EXTENDED:
+		  extended_event(q);
+		  break;
+
+	  case EV_CHN_VOICE:
+		  seq_chn_voice_event(q);
+		  break;
+
+	  case EV_CHN_COMMON:
+		  seq_chn_common_event(q);
+		  break;
+
+	  case EV_TIMING:
+		  if (seq_timing_event(q) == TIMER_ARMED)
+		    {
+			    return 1;
+		    }
+		  break;
+
+	  case EV_SEQ_LOCAL:
+		  seq_local_event(q);
+		  break;
+
+	  case EV_SYSEX:
+		  seq_sysex_message(q);
+		  break;
+
+	  default:;
+	  }
 
-  return 0;
+	return 0;
 }
 
 static void
-seq_startplay (void)
+seq_startplay(void)
 {
-  unsigned long   flags;
-  int             this_one, action;
-
-  while (qlen > 0)
-    {
-
-      save_flags (flags);
-      cli ();
-      qhead = ((this_one = qhead) + 1) % SEQ_MAX_QUEUE;
-      qlen--;
-      restore_flags (flags);
-
-      seq_playing = 1;
-
-      if ((action = play_event (&queue[this_one * EV_SZ])))
-	{			/* Suspend playback. Next timer routine invokes this routine again */
-	  if (action == 2)
-	    {
-	      qlen++;
-	      qhead = this_one;
-	    }
-	  return;
-	}
+	unsigned long   flags;
+	int             this_one, action;
 
-    }
+	while (qlen > 0)
+	  {
 
-  seq_playing = 0;
+		  save_flags(flags);
+		  cli();
+		  qhead = ((this_one = qhead) + 1) % SEQ_MAX_QUEUE;
+		  qlen--;
+		  restore_flags(flags);
+
+		  seq_playing = 1;
+
+		  if ((action = play_event(&queue[this_one * EV_SZ])))
+		    {		/* Suspend playback. Next timer routine invokes this routine again */
+			    if (action == 2)
+			      {
+				      qlen++;
+				      qhead = this_one;
+			      }
+			    return;
+		    }
+	  }
 
-  if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
-    {
-      unsigned long   flags;
+	seq_playing = 0;
 
-      save_flags (flags);
-      cli ();
-      if ((seq_sleep_flag.opts & WK_SLEEP))
-	{
+	if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
 	  {
-	    seq_sleep_flag.opts = WK_WAKEUP;
-	    wake_up (&seq_sleeper);
-	  };
-	}
-      restore_flags (flags);
-    }
+		  unsigned long   flags;
+
+		  save_flags(flags);
+		  cli();
+		  if ((seq_sleep_flag.opts & WK_SLEEP))
+		    {
+			    {
+				    seq_sleep_flag.opts = WK_WAKEUP;
+				    wake_up(&seq_sleeper);
+			    };
+		    }
+		  restore_flags(flags);
+	  }
 }
 
 static void
-reset_controllers (int dev, unsigned char *controller, int update_dev)
+reset_controllers(int dev, unsigned char *controller, int update_dev)
 {
 
-  int             i;
+	int             i;
 
-  for (i = 0; i < 128; i++)
-    controller[i] = ctrl_def_values[i];
+	for (i = 0; i < 128; i++)
+		controller[i] = ctrl_def_values[i];
 }
 
 static void
-setup_mode2 (void)
+setup_mode2(void)
 {
-  int             dev;
-
-  max_synthdev = num_synths;
-
-  for (dev = 0; dev < num_midis; dev++)
-    if (midi_devs[dev]->converter != NULL)
-      {
-	synth_devs[max_synthdev++] =
-	  midi_devs[dev]->converter;
-      }
+	int             dev;
 
-  for (dev = 0; dev < max_synthdev; dev++)
-    {
-      int             chn;
+	max_synthdev = num_synths;
 
-      synth_devs[dev]->sysex_ptr = 0;
-      synth_devs[dev]->emulation = 0;
+	for (dev = 0; dev < num_midis; dev++)
+		if (midi_devs[dev] && midi_devs[dev]->converter != NULL)
+		  {
+			  synth_devs[max_synthdev++] =
+			      midi_devs[dev]->converter;
+		  }
+	for (dev = 0; dev < max_synthdev; dev++)
+	  {
+		  int             chn;
+
+		  synth_devs[dev]->sysex_ptr = 0;
+		  synth_devs[dev]->emulation = 0;
+
+		  for (chn = 0; chn < 16; chn++)
+		    {
+			    synth_devs[dev]->chn_info[chn].pgm_num = 0;
+			    reset_controllers(dev,
+			      synth_devs[dev]->chn_info[chn].controllers,
+					      0);
+			    synth_devs[dev]->chn_info[chn].bender_value = (1 << 7);	/* Neutral */
+			    synth_devs[dev]->chn_info[chn].bender_range = 200;
+		    }
+	  }
 
-      for (chn = 0; chn < 16; chn++)
-	{
-	  synth_devs[dev]->chn_info[chn].pgm_num = 0;
-	  reset_controllers (dev,
-			     synth_devs[dev]->chn_info[chn].controllers,
-			     0);
-	  synth_devs[dev]->chn_info[chn].bender_value = (1 << 7);	/* Neutral */
-	  synth_devs[dev]->chn_info[chn].bender_range = 200;
-	}
-    }
-
-  max_mididev = 0;
-  seq_mode = SEQ_2;
+	max_mididev = 0;
+	seq_mode = SEQ_2;
 }
 
 int
-sequencer_open (int dev, struct fileinfo *file)
+sequencer_open(int dev, struct fileinfo *file)
 {
-  int             retval, mode, i;
-  int             level, tmp;
-  unsigned long   flags;
+	int             retval, mode, i;
+	int             level, tmp;
+	unsigned long   flags;
 
-  if (!sequencer_ok)
-    sequencer_init ();
+	if (!sequencer_ok)
+		sequencer_init();
 
-  level = ((dev & 0x0f) == SND_DEV_SEQ2) ? 2 : 1;
+	level = ((dev & 0x0f) == SND_DEV_SEQ2) ? 2 : 1;
 
-  dev = dev >> 4;
-  mode = file->mode & O_ACCMODE;
+	dev = dev >> 4;
+	mode = file->mode & O_ACCMODE;
 
-  DEB (printk ("sequencer_open(dev=%d)\n", dev));
+	DEB(printk("sequencer_open(dev=%d)\n", dev));
+
+	if (!sequencer_ok)
+	  {
+		  printk("Soundcard: Sequencer not initialized\n");
+		  return -ENXIO;
+	  }
+	if (dev)		/* Patch manager device (obsolete) */
+	  {
+		  return -ENXIO;
+	  }
+	if (mode == OPEN_READ)
+		if (!num_midis)
+		  {
+			  printk("Sequencer: No MIDI devices. Input not possible\n");
+			  sequencer_busy = 0;
+			  return -ENXIO;
+		  }
+	save_flags(flags);
+	cli();
+	if (sequencer_busy)
+	  {
+		  restore_flags(flags);
+		  return -EBUSY;
+	  }
+	sequencer_busy = 1;
+	obsolete_api_used = 0;
+	restore_flags(flags);
 
-  if (!sequencer_ok)
-    {
-      printk ("Soundcard: Sequencer not initialized\n");
-      return -ENXIO;
-    }
+	max_mididev = num_midis;
+	max_synthdev = num_synths;
+	pre_event_timeout = 0;
+	seq_mode = SEQ_1;
 
-  if (dev)			/* Patch manager device (obsolete) */
-    {
-      return -ENXIO;
-    }
+	if (pending_timer != -1)
+	  {
+		  tmr_no = pending_timer;
+		  pending_timer = -1;
+	  }
+	if (tmr_no == -1)	/* Not selected yet */
+	  {
+		  int             i, best;
+
+		  best = -1;
+		  for (i = 0; i < num_sound_timers; i++)
+			  if (sound_timer_devs[i] && sound_timer_devs[i]->priority > best)
+			    {
+				    tmr_no = i;
+				    best = sound_timer_devs[i]->priority;
+			    }
+		  if (tmr_no == -1)	/* Should not be */
+			  tmr_no = 0;
+	  }
+	tmr = sound_timer_devs[tmr_no];
 
-  if (mode == OPEN_READ)
-    if (!num_midis)
-      {
-	printk ("Sequencer: No MIDI devices. Input not possible\n");
-	sequencer_busy = 0;
-	return -ENXIO;
-      }
-
-  save_flags (flags);
-  cli ();
-  if (sequencer_busy)
-    {
-      restore_flags (flags);
-      return -EBUSY;
-    }
-  sequencer_busy = 1;
-  obsolete_api_used = 0;
-  restore_flags (flags);
-
-  max_mididev = num_midis;
-  max_synthdev = num_synths;
-  pre_event_timeout = 0;
-  seq_mode = SEQ_1;
-
-  if (pending_timer != -1)
-    {
-      tmr_no = pending_timer;
-      pending_timer = -1;
-    }
-
-  if (tmr_no == -1)		/* Not selected yet */
-    {
-      int             i, best;
-
-      best = -1;
-      for (i = 0; i < num_sound_timers; i++)
-	if (sound_timer_devs[i]->priority > best)
+	if (level == 2)
 	  {
-	    tmr_no = i;
-	    best = sound_timer_devs[i]->priority;
+		  if (tmr == NULL)
+		    {
+			    printk("sequencer: No timer for level 2\n");
+			    sequencer_busy = 0;
+			    return -ENXIO;
+		    }
+		  setup_mode2();
 	  }
+	if (!max_synthdev && !max_mididev)
+		return -ENXIO;
 
-      if (tmr_no == -1)		/* Should not be */
-	tmr_no = 0;
-    }
+	synth_open_mask = 0;
 
-  tmr = sound_timer_devs[tmr_no];
+	for (i = 0; i < max_mididev; i++)
+	  {
+		  midi_opened[i] = 0;
+		  midi_written[i] = 0;
+	  }
 
-  if (level == 2)
-    {
-      if (tmr == NULL)
-	{
-	  printk ("sequencer: No timer for level 2\n");
-	  sequencer_busy = 0;
-	  return -ENXIO;
-	}
-      setup_mode2 ();
-    }
-
-  if (!max_synthdev && !max_mididev)
-    return -ENXIO;
-
-  synth_open_mask = 0;
-
-  for (i = 0; i < max_mididev; i++)
-    {
-      midi_opened[i] = 0;
-      midi_written[i] = 0;
-    }
-
-  for (i = 0; i < max_synthdev; i++)
-    {
-      if ((tmp = synth_devs[i]->open (i, mode)) < 0)
-	{
-	  printk ("Sequencer: Warning! Cannot open synth device #%d (%d)\n", i, tmp);
-	  if (synth_devs[i]->midi_dev)
-	    printk ("(Maps to MIDI dev #%d)\n", synth_devs[i]->midi_dev);
-	}
-      else
-	{
-	  synth_open_mask |= (1 << i);
-	  if (synth_devs[i]->midi_dev)
-	    midi_opened[synth_devs[i]->midi_dev] = 1;
-	}
-    }
+	for (i = 0; i < max_synthdev; i++)
+	  {
+		  if ((tmp = synth_devs[i]->open(i, mode)) < 0)
+		    {
+			    printk("Sequencer: Warning! Cannot open synth device #%d (%d)\n", i, tmp);
+			    if (synth_devs[i]->midi_dev)
+				    printk("(Maps to MIDI dev #%d)\n", synth_devs[i]->midi_dev);
+		  } else
+		    {
+			    synth_open_mask |= (1 << i);
+			    if (synth_devs[i]->midi_dev)
+				    midi_opened[synth_devs[i]->midi_dev] = 1;
+		    }
+	  }
 
-  seq_time = jiffies;
+	if (softsynthp != NULL)
+		seq_time = 0;
+	else
+		seq_time = jiffies;
 
-  prev_input_time = 0;
-  prev_event_time = 0;
+	prev_input_time = 0;
+	prev_event_time = 0;
+	if (softsynthp != NULL)
+		softsynthp(SSYN_START, 0, 0, 0);
 
-  if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
-    {				/*
+	if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
+	  {			/*
 				 * Initialize midi input devices
 				 */
-      for (i = 0; i < max_mididev; i++)
-	if (!midi_opened[i])
+		  for (i = 0; i < max_mididev; i++)
+			  if (!midi_opened[i])
+			    {
+				    if ((retval = midi_devs[i]->open(i, mode,
+								     sequencer_midi_input, sequencer_midi_output)) >= 0)
+					    midi_opened[i] = 1;
+			    }
+	  }
+	if (seq_mode == SEQ_2)
 	  {
-	    if ((retval = midi_devs[i]->open (i, mode,
-			 sequencer_midi_input, sequencer_midi_output)) >= 0)
-	      midi_opened[i] = 1;
+		  tmr->open(tmr_no, seq_mode);
 	  }
-    }
-
-  if (seq_mode == SEQ_2)
-    {
-      tmr->open (tmr_no, seq_mode);
-    }
-
-  seq_sleep_flag.opts = WK_NONE;
-  midi_sleep_flag.opts = WK_NONE;
-  output_threshold = SEQ_MAX_QUEUE / 2;
+	seq_sleep_flag.opts = WK_NONE;
+	midi_sleep_flag.opts = WK_NONE;
+	output_threshold = SEQ_MAX_QUEUE / 2;
 
-  return 0;
+	return 0;
 }
 
 void
-seq_drain_midi_queues (void)
+seq_drain_midi_queues(void)
 {
-  int             i, n;
-
-  /*
-   * Give the Midi drivers time to drain their output queues
-   */
-
-  n = 1;
+	int             i, n;
 
-  while (!(current->signal & ~current->blocked) && n)
-    {
-      n = 0;
+	/*
+	 * Give the Midi drivers time to drain their output queues
+	 */
 
-      for (i = 0; i < max_mididev; i++)
-	if (midi_opened[i] && midi_written[i])
-	  if (midi_devs[i]->buffer_status != NULL)
-	    if (midi_devs[i]->buffer_status (i))
-	      n++;
-
-      /*
-       * Let's have a delay
-       */
-      if (n)
-	{
+	n = 1;
 
+	while (!(current->signal & ~current->blocked) && n)
 	  {
-	    unsigned long   tlimit;
-
-	    if (HZ / 10)
-	      current->timeout = tlimit = jiffies + (HZ / 10);
-	    else
-	      tlimit = (unsigned long) -1;
-	    seq_sleep_flag.opts = WK_SLEEP;
-	    interruptible_sleep_on (&seq_sleeper);
-	    if (!(seq_sleep_flag.opts & WK_WAKEUP))
-	      {
-		if (jiffies >= tlimit)
-		  seq_sleep_flag.opts |= WK_TIMEOUT;
-	      }
-	    seq_sleep_flag.opts &= ~WK_SLEEP;
-	  };
-	}
-    }
+		  n = 0;
+
+		  for (i = 0; i < max_mididev; i++)
+			  if (midi_opened[i] && midi_written[i])
+				  if (midi_devs[i]->buffer_status != NULL)
+					  if (midi_devs[i]->buffer_status(i))
+						  n++;
+
+		  /*
+		   * Let's have a delay
+		   */
+		  if (n)
+		    {
+
+			    {
+				    unsigned long   tlimit;
+
+				    if (HZ / 10)
+					    current->timeout = tlimit = jiffies + (HZ / 10);
+				    else
+					    tlimit = (unsigned long) -1;
+				    seq_sleep_flag.opts = WK_SLEEP;
+				    interruptible_sleep_on(&seq_sleeper);
+				    if (!(seq_sleep_flag.opts & WK_WAKEUP))
+				      {
+					      if (jiffies >= tlimit)
+						      seq_sleep_flag.opts |= WK_TIMEOUT;
+				      }
+				    seq_sleep_flag.opts &= ~WK_SLEEP;
+			    };
+		    }
+	  }
 }
 
 void
-sequencer_release (int dev, struct fileinfo *file)
+sequencer_release(int dev, struct fileinfo *file)
 {
-  int             i;
-  int             mode = file->mode & O_ACCMODE;
-
-  dev = dev >> 4;
+	int             i;
+	int             mode = file->mode & O_ACCMODE;
 
-  DEB (printk ("sequencer_release(dev=%d)\n", dev));
+	dev = dev >> 4;
 
-  /*
-   * Wait until the queue is empty (if we don't have nonblock)
-   */
+	DEB(printk("sequencer_release(dev=%d)\n", dev));
 
-  if (mode != OPEN_READ && !(file->flags & (O_NONBLOCK) ?
-			     1 : 0))
-    while (!(current->signal & ~current->blocked) && qlen > 0)
-      {
-	seq_sync ();
+	/*
+	 * Wait until the queue is empty (if we don't have nonblock)
+	 */
 
-	{
-	  unsigned long   tlimit;
-
-	  if (3 * HZ)
-	    current->timeout = tlimit = jiffies + (3 * HZ);
-	  else
-	    tlimit = (unsigned long) -1;
-	  seq_sleep_flag.opts = WK_SLEEP;
-	  interruptible_sleep_on (&seq_sleeper);
-	  if (!(seq_sleep_flag.opts & WK_WAKEUP))
-	    {
-	      if (jiffies >= tlimit)
-		seq_sleep_flag.opts |= WK_TIMEOUT;
-	    }
-	  seq_sleep_flag.opts &= ~WK_SLEEP;
-	};			/* Extra delay */
-      }
-
-  if (mode != OPEN_READ)
-    seq_drain_midi_queues ();	/*
-				 * Ensure the output queues are empty
-				 */
-  seq_reset ();
-  if (mode != OPEN_READ)
-    seq_drain_midi_queues ();	/*
-				 * Flush the all notes off messages
-				 */
+	if (mode != OPEN_READ && !(file->flags & (O_NONBLOCK) ?
+				   1 : 0))
+		while (!(current->signal & ~current->blocked) && qlen > 0)
+		  {
+			  seq_sync();
+
+			  {
+				  unsigned long   tlimit;
+
+				  if (3 * HZ)
+					  current->timeout = tlimit = jiffies + (3 * HZ);
+				  else
+					  tlimit = (unsigned long) -1;
+				  seq_sleep_flag.opts = WK_SLEEP;
+				  interruptible_sleep_on(&seq_sleeper);
+				  if (!(seq_sleep_flag.opts & WK_WAKEUP))
+				    {
+					    if (jiffies >= tlimit)
+						    seq_sleep_flag.opts |= WK_TIMEOUT;
+				    }
+				  seq_sleep_flag.opts &= ~WK_SLEEP;
+			  };	/* Extra delay */
+		  }
+	if (mode != OPEN_READ)
+		seq_drain_midi_queues();	/*
+						 * Ensure the output queues are empty
+						 */
+	seq_reset();
+	if (mode != OPEN_READ)
+		seq_drain_midi_queues();	/*
+						 * Flush the all notes off messages
+						 */
 
-  for (i = 0; i < max_synthdev; i++)
-    {
-      if (synth_open_mask & (1 << i))	/*
-					 * Actually opened
-					 */
-	if (synth_devs[i])
+	for (i = 0; i < max_synthdev; i++)
 	  {
-	    synth_devs[i]->close (i);
-
-	    if (synth_devs[i]->midi_dev)
-	      midi_opened[synth_devs[i]->midi_dev] = 0;
+		  if (synth_open_mask & (1 << i))	/*
+							 * Actually opened
+							 */
+			  if (synth_devs[i])
+			    {
+				    synth_devs[i]->close(i);
+
+				    if (synth_devs[i]->midi_dev)
+					    midi_opened[synth_devs[i]->midi_dev] = 0;
+			    }
 	  }
-    }
 
-  for (i = 0; i < max_mididev; i++)
-    {
-      if (midi_opened[i])
-	midi_devs[i]->close (i);
-    }
+	for (i = 0; i < max_mididev; i++)
+	  {
+		  if (midi_opened[i])
+			  midi_devs[i]->close(i);
+	  }
 
-  if (seq_mode == SEQ_2)
-    tmr->close (tmr_no);
+	if (seq_mode == SEQ_2)
+		tmr->close(tmr_no);
 
-  if (obsolete_api_used)
-    printk ("/dev/music: Obsolete (4 byte) API was used by this program\n");
-  sequencer_busy = 0;
+	if (obsolete_api_used)
+		printk("/dev/music: Obsolete (4 byte) API was used by this program\n");
+	sequencer_busy = 0;
 }
 
 static int
-seq_sync (void)
+seq_sync(void)
 {
-  unsigned long   flags;
-
-  if (qlen && !seq_playing && !(current->signal & ~current->blocked))
-    seq_startplay ();
-
-  save_flags (flags);
-  cli ();
-  if (qlen > 0)
-    {
+	unsigned long   flags;
 
-      {
-	unsigned long   tlimit;
+	if (qlen && !seq_playing && !(current->signal & ~current->blocked))
+		seq_startplay();
 
-	if (HZ)
-	  current->timeout = tlimit = jiffies + (HZ);
-	else
-	  tlimit = (unsigned long) -1;
-	seq_sleep_flag.opts = WK_SLEEP;
-	interruptible_sleep_on (&seq_sleeper);
-	if (!(seq_sleep_flag.opts & WK_WAKEUP))
+	save_flags(flags);
+	cli();
+	if (qlen > 0)
 	  {
-	    if (jiffies >= tlimit)
-	      seq_sleep_flag.opts |= WK_TIMEOUT;
+
+		  {
+			  unsigned long   tlimit;
+
+			  if (HZ)
+				  current->timeout = tlimit = jiffies + (HZ);
+			  else
+				  tlimit = (unsigned long) -1;
+			  seq_sleep_flag.opts = WK_SLEEP;
+			  interruptible_sleep_on(&seq_sleeper);
+			  if (!(seq_sleep_flag.opts & WK_WAKEUP))
+			    {
+				    if (jiffies >= tlimit)
+					    seq_sleep_flag.opts |= WK_TIMEOUT;
+			    }
+			  seq_sleep_flag.opts &= ~WK_SLEEP;
+		  };
 	  }
-	seq_sleep_flag.opts &= ~WK_SLEEP;
-      };
-    }
-  restore_flags (flags);
+	restore_flags(flags);
 
-  return qlen;
+	return qlen;
 }
 
 static void
-midi_outc (int dev, unsigned char data)
+midi_outc(int dev, unsigned char data)
 {
-  /*
-   * NOTE! Calls sleep(). Don't call this from interrupt.
-   */
-
-  int             n;
-  unsigned long   flags;
-
-  /*
-   * This routine sends one byte to the Midi channel.
-   * If the output FIFO is full, it waits until there
-   * is space in the queue
-   */
+	/*
+	 * NOTE! Calls sleep(). Don't call this from interrupt.
+	 */
 
-  n = 3 * HZ;			/* Timeout */
+	int             n;
+	unsigned long   flags;
 
-  save_flags (flags);
-  cli ();
-  while (n && !midi_devs[dev]->outputc (dev, data))
-    {
+	/*
+	 * This routine sends one byte to the Midi channel.
+	 * If the output FIFO is full, it waits until there
+	 * is space in the queue
+	 */
 
-      {
-	unsigned long   tlimit;
+	n = 3 * HZ;		/* Timeout */
 
-	if (4)
-	  current->timeout = tlimit = jiffies + (4);
-	else
-	  tlimit = (unsigned long) -1;
-	seq_sleep_flag.opts = WK_SLEEP;
-	interruptible_sleep_on (&seq_sleeper);
-	if (!(seq_sleep_flag.opts & WK_WAKEUP))
+	save_flags(flags);
+	cli();
+	while (n && !midi_devs[dev]->outputc(dev, data))
 	  {
-	    if (jiffies >= tlimit)
-	      seq_sleep_flag.opts |= WK_TIMEOUT;
+
+		  {
+			  unsigned long   tlimit;
+
+			  if (4)
+				  current->timeout = tlimit = jiffies + (4);
+			  else
+				  tlimit = (unsigned long) -1;
+			  seq_sleep_flag.opts = WK_SLEEP;
+			  interruptible_sleep_on(&seq_sleeper);
+			  if (!(seq_sleep_flag.opts & WK_WAKEUP))
+			    {
+				    if (jiffies >= tlimit)
+					    seq_sleep_flag.opts |= WK_TIMEOUT;
+			    }
+			  seq_sleep_flag.opts &= ~WK_SLEEP;
+		  };
+		  n--;
 	  }
-	seq_sleep_flag.opts &= ~WK_SLEEP;
-      };
-      n--;
-    }
-  restore_flags (flags);
+	restore_flags(flags);
 }
 
 static void
-seq_reset (void)
+seq_reset(void)
 {
-  /*
-   * NOTE! Calls sleep(). Don't call this from interrupt.
-   */
+	/*
+	 * NOTE! Calls sleep(). Don't call this from interrupt.
+	 */
 
-  int             i;
-  int             chn;
-  unsigned long   flags;
+	int             i;
+	int             chn;
+	unsigned long   flags;
 
-  sound_stop_timer ();
+	if (softsynthp != NULL)
+		softsynthp(SSYN_STOP, 0, 0, 0);
+	else
+		sound_stop_timer();
 
-  seq_time = jiffies;
-  prev_input_time = 0;
-  prev_event_time = 0;
+	seq_time = jiffies;
+	prev_input_time = 0;
+	prev_event_time = 0;
 
-  qlen = qhead = qtail = 0;
-  iqlen = iqhead = iqtail = 0;
+	qlen = qhead = qtail = 0;
+	iqlen = iqhead = iqtail = 0;
 
-  for (i = 0; i < max_synthdev; i++)
-    if (synth_open_mask & (1 << i))
-      if (synth_devs[i])
-	synth_devs[i]->reset (i);
+	for (i = 0; i < max_synthdev; i++)
+		if (synth_open_mask & (1 << i))
+			if (synth_devs[i])
+				synth_devs[i]->reset(i);
 
-  if (seq_mode == SEQ_2)
-    {
+	if (seq_mode == SEQ_2)
+	  {
 
-      for (chn = 0; chn < 16; chn++)
-	for (i = 0; i < max_synthdev; i++)
-	  if (synth_open_mask & (1 << i))
-	    if (synth_devs[i])
-	      {
-		synth_devs[i]->controller (i, chn, 123, 0);	/* All notes off */
-		synth_devs[i]->controller (i, chn, 121, 0);	/* Reset all ctl */
-		synth_devs[i]->bender (i, chn, 1 << 13);	/* Bender off */
-	      }
-
-    }
-  else
-    /* seq_mode == SEQ_1 */
-    {
-      for (i = 0; i < max_mididev; i++)
-	if (midi_written[i])	/*
-				 * Midi used. Some notes may still be playing
-				 */
+		  for (chn = 0; chn < 16; chn++)
+			  for (i = 0; i < max_synthdev; i++)
+				  if (synth_open_mask & (1 << i))
+					  if (synth_devs[i])
+					    {
+						    synth_devs[i]->controller(i, chn, 123, 0);	/* All notes off */
+						    synth_devs[i]->controller(i, chn, 121, 0);	/* Reset all ctl */
+						    synth_devs[i]->bender(i, chn, 1 << 13);	/* Bender off */
+					    }
+	} else
+		/* seq_mode == SEQ_1 */
+	  {
+		  for (i = 0; i < max_mididev; i++)
+			  if (midi_written[i])	/*
+						 * Midi used. Some notes may still be playing
+						 */
+			    {
+				    /*
+				       *      Sending just a ACTIVE SENSING message should be enough to stop all
+				       *      playing notes. Since there are devices not recognizing the
+				       *      active sensing, we have to send some all notes off messages also.
+				     */
+				    midi_outc(i, 0xfe);
+
+				    for (chn = 0; chn < 16; chn++)
+				      {
+					      midi_outc(i,
+							(unsigned char) (0xb0 + (chn & 0x0f)));		/* control change */
+					      midi_outc(i, 0x7b);	/* All notes off */
+					      midi_outc(i, 0);	/* Dummy parameter */
+				      }
+
+				    midi_devs[i]->close(i);
+
+				    midi_written[i] = 0;
+				    midi_opened[i] = 0;
+			    }
+	  }
+
+	seq_playing = 0;
+
+	save_flags(flags);
+	cli();
+	if ((seq_sleep_flag.opts & WK_SLEEP))
 	  {
-	    /*
-	       *      Sending just a ACTIVE SENSING message should be enough to stop all
-	       *      playing notes. Since there are devices not recognizing the
-	       *      active sensing, we have to send some all notes off messages also.
-	     */
-	    midi_outc (i, 0xfe);
-
-	    for (chn = 0; chn < 16; chn++)
-	      {
-		midi_outc (i,
-			   (unsigned char) (0xb0 + (chn & 0x0f)));	/* control change */
-		midi_outc (i, 0x7b);	/* All notes off */
-		midi_outc (i, 0);	/* Dummy parameter */
-	      }
-
-	    midi_devs[i]->close (i);
-
-	    midi_written[i] = 0;
-	    midi_opened[i] = 0;
+		  /*      printk( "Sequencer Warning: Unexpected sleeping process - Waking up\n"); */
+		  {
+			  seq_sleep_flag.opts = WK_WAKEUP;
+			  wake_up(&seq_sleeper);
+		  };
 	  }
-    }
-
-  seq_playing = 0;
-
-  save_flags (flags);
-  cli ();
-  if ((seq_sleep_flag.opts & WK_SLEEP))
-    {
-      /*      printk ("Sequencer Warning: Unexpected sleeping process - Waking up\n"); */
-      {
-	seq_sleep_flag.opts = WK_WAKEUP;
-	wake_up (&seq_sleeper);
-      };
-    }
-  restore_flags (flags);
+	restore_flags(flags);
 
 }
 
 static void
-seq_panic (void)
+seq_panic(void)
 {
-  /*
-     * This routine is called by the application in case the user
-     * wants to reset the system to the default state.
-   */
-
-  seq_reset ();
-
-  /*
-     * Since some of the devices don't recognize the active sensing and
-     * all notes off messages, we have to shut all notes manually.
-     *
-     *      TO BE IMPLEMENTED LATER
-   */
-
-  /*
-     * Also return the controllers to their default states
-   */
+	/*
+	   * This routine is called by the application in case the user
+	   * wants to reset the system to the default state.
+	 */
+
+	seq_reset();
+
+	/*
+	   * Since some of the devices don't recognize the active sensing and
+	   * all notes off messages, we have to shut all notes manually.
+	   *
+	   *      TO BE IMPLEMENTED LATER
+	 */
+
+	/*
+	   * Also return the controllers to their default states
+	 */
 }
 
 int
-sequencer_ioctl (int dev, struct fileinfo *file,
-		 unsigned int cmd, caddr_t arg)
+sequencer_ioctl(int dev, struct fileinfo *file,
+		unsigned int cmd, caddr_t arg)
 {
-  int             midi_dev, orig_dev, val;
-  int             mode = file->mode & O_ACCMODE;
-
-  orig_dev = dev = dev >> 4;
-
-  switch (cmd)
-    {
-    case SNDCTL_TMR_TIMEBASE:
-    case SNDCTL_TMR_TEMPO:
-    case SNDCTL_TMR_START:
-    case SNDCTL_TMR_STOP:
-    case SNDCTL_TMR_CONTINUE:
-    case SNDCTL_TMR_METRONOME:
-    case SNDCTL_TMR_SOURCE:
-
-      if (seq_mode != SEQ_2)
-	return -EINVAL;
-      return tmr->ioctl (tmr_no, cmd, arg);
-      break;
-
-    case SNDCTL_TMR_SELECT:
-
-      if (seq_mode != SEQ_2)
-	return -EINVAL;
-      pending_timer = *(int *) arg;
-
-      if (pending_timer < 0 || pending_timer >= num_sound_timers)
-	{
-	  pending_timer = -1;
-	  return -EINVAL;
-	}
-
-      return (*(int *) arg = pending_timer);
-      break;
-
-    case SNDCTL_SEQ_PANIC:
-      seq_panic ();
-      break;
-
-    case SNDCTL_SEQ_SYNC:
-
-      if (mode == OPEN_READ)
-	return 0;
-      while (qlen > 0 && !(current->signal & ~current->blocked))
-	seq_sync ();
-      if (qlen)
-	return -EINTR;
-      else
-	return 0;
-      break;
+	int             midi_dev, orig_dev, val;
+	int             mode = file->mode & O_ACCMODE;
 
-    case SNDCTL_SEQ_RESET:
+	orig_dev = dev = dev >> 4;
 
-      seq_reset ();
-      return 0;
-      break;
-
-    case SNDCTL_SEQ_TESTMIDI:
-      midi_dev = *(int *) arg;
-      if (midi_dev < 0 || midi_dev >= max_mididev)
-	return -ENXIO;
-
-      if (!midi_opened[midi_dev])
-	{
-	  int             err, mode;
+	switch (cmd)
+	  {
+	  case SNDCTL_TMR_TIMEBASE:
+	  case SNDCTL_TMR_TEMPO:
+	  case SNDCTL_TMR_START:
+	  case SNDCTL_TMR_STOP:
+	  case SNDCTL_TMR_CONTINUE:
+	  case SNDCTL_TMR_METRONOME:
+	  case SNDCTL_TMR_SOURCE:
+
+		  if (seq_mode != SEQ_2)
+			  return -EINVAL;
+		  return tmr->ioctl(tmr_no, cmd, arg);
+		  break;
+
+	  case SNDCTL_TMR_SELECT:
+
+		  if (seq_mode != SEQ_2)
+			  return -EINVAL;
+		  pending_timer = *(int *) arg;
+
+		  if (pending_timer < 0 || pending_timer >= num_sound_timers || sound_timer_devs[pending_timer] == NULL)
+		    {
+			    pending_timer = -1;
+			    return -EINVAL;
+		    }
+		  return (*(int *) arg = pending_timer);
+		  break;
+
+	  case SNDCTL_SEQ_PANIC:
+		  seq_panic();
+		  break;
+
+	  case SNDCTL_SEQ_SYNC:
+
+		  if (mode == OPEN_READ)
+			  return 0;
+		  while (qlen > 0 && !(current->signal & ~current->blocked))
+			  seq_sync();
+		  if (qlen)
+			  return -EINTR;
+		  else
+			  return 0;
+		  break;
+
+	  case SNDCTL_SEQ_RESET:
+
+		  seq_reset();
+		  return 0;
+		  break;
+
+	  case SNDCTL_SEQ_TESTMIDI:
+		  midi_dev = *(int *) arg;
+		  if (midi_dev < 0 || midi_dev >= max_mididev)
+			  return -ENXIO;
+
+		  if (!midi_opened[midi_dev])
+		    {
+			    int             err, mode;
+
+			    mode = file->mode & O_ACCMODE;
+			    if ((err = midi_devs[midi_dev]->open(midi_dev, mode,
+						    sequencer_midi_input,
+					     sequencer_midi_output)) < 0)
+				    return err;
+		    }
+		  midi_opened[midi_dev] = 1;
+
+		  return 0;
+		  break;
+
+	  case SNDCTL_SEQ_GETINCOUNT:
+		  if (mode == OPEN_WRITE)
+			  return 0;
+		  return (*(int *) arg = iqlen);
+		  break;
+
+	  case SNDCTL_SEQ_GETOUTCOUNT:
+
+		  if (mode == OPEN_READ)
+			  return 0;
+		  return (*(int *) arg = SEQ_MAX_QUEUE - qlen);
+		  break;
+
+	  case SNDCTL_SEQ_GETTIME:
+		  if (seq_mode == SEQ_2)
+			  return tmr->ioctl(tmr_no, cmd, arg);
+
+		  if (softsynthp != NULL)
+			  return (*(int *) arg = softsynthp(SSYN_GETTIME, 0, 0, 0));
+		  else
+			  return (*(int *) arg = jiffies - seq_time);
+		  break;
+
+	  case SNDCTL_SEQ_CTRLRATE:
+		  /*
+		   * If *arg == 0, just return the current rate
+		   */
+		  if (seq_mode == SEQ_2)
+			  return tmr->ioctl(tmr_no, cmd, arg);
+
+		  val = *(int *) arg;
+		  if (val != 0)
+			  return -EINVAL;
+
+		  return (*(int *) arg = HZ);
+		  break;
+
+	  case SNDCTL_SEQ_RESETSAMPLES:
+	  case SNDCTL_SYNTH_REMOVESAMPLE:
+	  case SNDCTL_SYNTH_CONTROL:
+		  {
+			  int             err;
+
+			  dev = *(int *) arg;
+			  if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
+			    {
+				    return -ENXIO;
+			    }
+			  if (!(synth_open_mask & (1 << dev)) && !orig_dev)
+			    {
+				    return -EBUSY;
+			    }
+			  err = synth_devs[dev]->ioctl(dev, cmd, arg);
+			  return err;
+		  }
+		  break;
+
+	  case SNDCTL_SEQ_NRSYNTHS:
+		  return (*(int *) arg = max_synthdev);
+		  break;
+
+	  case SNDCTL_SEQ_NRMIDIS:
+		  return (*(int *) arg = max_mididev);
+		  break;
+
+	  case SNDCTL_SYNTH_MEMAVL:
+		  {
+			  int             dev;
 
-	  mode = file->mode & O_ACCMODE;
-	  if ((err = midi_devs[midi_dev]->open (midi_dev, mode,
-						sequencer_midi_input,
-						sequencer_midi_output)) < 0)
-	    return err;
-	}
+			  dev = *(int *) arg;
 
-      midi_opened[midi_dev] = 1;
+			  if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
+				  return -ENXIO;
 
-      return 0;
-      break;
+			  if (!(synth_open_mask & (1 << dev)) && !orig_dev)
+				  return -EBUSY;
 
-    case SNDCTL_SEQ_GETINCOUNT:
-      if (mode == OPEN_WRITE)
-	return 0;
-      return (*(int *) arg = iqlen);
-      break;
+			  return (*(int *) arg = synth_devs[dev]->ioctl(dev, cmd, arg));
+		  }
+		  break;
 
-    case SNDCTL_SEQ_GETOUTCOUNT:
+	  case SNDCTL_FM_4OP_ENABLE:
+		  {
+			  int             dev;
 
-      if (mode == OPEN_READ)
-	return 0;
-      return (*(int *) arg = SEQ_MAX_QUEUE - qlen);
-      break;
+			  dev = *(int *) arg;
 
-    case SNDCTL_SEQ_GETTIME:
-      if (seq_mode == SEQ_2)
-	return tmr->ioctl (tmr_no, cmd, arg);
+			  if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
+				  return -ENXIO;
 
-      return (*(int *) arg = jiffies - seq_time);
-      break;
+			  if (!(synth_open_mask & (1 << dev)))
+				  return -ENXIO;
 
-    case SNDCTL_SEQ_CTRLRATE:
-      /*
-       * If *arg == 0, just return the current rate
-       */
-      if (seq_mode == SEQ_2)
-	return tmr->ioctl (tmr_no, cmd, arg);
+			  synth_devs[dev]->ioctl(dev, cmd, arg);
+			  return 0;
+		  }
+		  break;
 
-      val = *(int *) arg;
-      if (val != 0)
-	return -EINVAL;
+	  case SNDCTL_SYNTH_INFO:
+		  {
+			  struct synth_info inf;
+			  int             dev;
 
-      return (*(int *) arg = HZ);
-      break;
+			  memcpy((char *) &inf, (&((char *) arg)[0]), sizeof(inf));
+			  dev = inf.device;
 
-    case SNDCTL_SEQ_RESETSAMPLES:
-    case SNDCTL_SYNTH_REMOVESAMPLE:
-    case SNDCTL_SYNTH_CONTROL:
-      {
-	int             err;
+			  if (dev < 0 || dev >= max_synthdev)
+				  return -ENXIO;
 
-	dev = *(int *) arg;
-	if (dev < 0 || dev >= num_synths)
-	  {
-	    return -ENXIO;
-	  }
+			  if (!(synth_open_mask & (1 << dev)) && !orig_dev)
+				  return -EBUSY;
 
-	if (!(synth_open_mask & (1 << dev)) && !orig_dev)
-	  {
-	    return -EBUSY;
-	  }
+			  return synth_devs[dev]->ioctl(dev, cmd, arg);
+		  }
+		  break;
 
-	err = synth_devs[dev]->ioctl (dev, cmd, arg);
-	return err;
-      }
-      break;
 
-    case SNDCTL_SEQ_NRSYNTHS:
-      return (*(int *) arg = max_synthdev);
-      break;
+		  /* Like SYNTH_INFO but returns ID in the name field */
+	  case SNDCTL_SYNTH_ID:
+		  {
+			  struct synth_info inf;
+			  int             dev;
 
-    case SNDCTL_SEQ_NRMIDIS:
-      return (*(int *) arg = max_mididev);
-      break;
+			  memcpy((char *) &inf, (&((char *) arg)[0]), sizeof(inf));
+			  dev = inf.device;
 
-    case SNDCTL_SYNTH_MEMAVL:
-      {
-	int             dev;
+			  if (dev < 0 || dev >= max_synthdev)
+				  return -ENXIO;
 
-	dev = *(int *) arg;
+			  if (!(synth_open_mask & (1 << dev)) && !orig_dev)
+				  return -EBUSY;
 
-	if (dev < 0 || dev >= num_synths)
-	  return -ENXIO;
+			  memcpy((char *) &inf, (char *) synth_devs[dev]->info, sizeof(inf));
+			  strcpy(inf.name, synth_devs[dev]->id);
+			  inf.device = dev;
+			  memcpy((&((char *) arg)[0]), (char *) &inf, sizeof(inf));
+			  return 0;
+		  }
+		  break;
 
-	if (!(synth_open_mask & (1 << dev)) && !orig_dev)
-	  return -EBUSY;
+	  case SNDCTL_SEQ_OUTOFBAND:
+		  {
+			  struct seq_event_rec event_rec;
+			  unsigned long   flags;
 
-	return (*(int *) arg = synth_devs[dev]->ioctl (dev, cmd, arg));
-      }
-      break;
+			  memcpy((char *) &event_rec, (&((char *) arg)[0]), sizeof(event_rec));
 
-    case SNDCTL_FM_4OP_ENABLE:
-      {
-	int             dev;
+			  save_flags(flags);
+			  cli();
+			  play_event(event_rec.arr);
+			  restore_flags(flags);
 
-	dev = *(int *) arg;
+			  return 0;
+		  }
+		  break;
 
-	if (dev < 0 || dev >= num_synths)
-	  return -ENXIO;
+	  case SNDCTL_MIDI_INFO:
+		  {
+			  struct midi_info inf;
+			  int             dev;
+			  char           *pp;
 
-	if (!(synth_open_mask & (1 << dev)))
-	  return -ENXIO;
+			  memcpy((char *) &inf, (&((char *) arg)[0]), sizeof(inf));
+			  dev = inf.device;
 
-	synth_devs[dev]->ioctl (dev, cmd, arg);
-	return 0;
-      }
-      break;
+			  if (dev < 0 || dev >= max_mididev)
+				  return -ENXIO;
 
-    case SNDCTL_SYNTH_INFO:
-      {
-	struct synth_info inf;
-	int             dev;
+			  midi_devs[dev]->info.device = dev;
+			  pp = (char *) &midi_devs[dev]->info;
+			  memcpy((&((char *) arg)[0]), pp, sizeof(inf));
+			  return 0;
+		  }
+		  break;
 
-	memcpy ((char *) &inf, (&((char *) arg)[0]), sizeof (inf));
-	dev = inf.device;
+	  case SNDCTL_SEQ_THRESHOLD:
+		  {
+			  int             tmp;
 
-	if (dev < 0 || dev >= max_synthdev)
-	  return -ENXIO;
+			  tmp = *(int *) arg;
 
-	if (!(synth_open_mask & (1 << dev)) && !orig_dev)
-	  return -EBUSY;
+			  if (tmp < 1)
+				  tmp = 1;
+			  if (tmp >= SEQ_MAX_QUEUE)
+				  tmp = SEQ_MAX_QUEUE - 1;
+			  output_threshold = tmp;
+			  return 0;
+		  }
+		  break;
 
-	return synth_devs[dev]->ioctl (dev, cmd, arg);
-      }
-      break;
+	  case SNDCTL_MIDI_PRETIME:
+		  {
+			  int             val;
 
+			  val = *(int *) arg;
 
-      /* Like SYNTH_INFO but returns ID in the name field */
-    case SNDCTL_SYNTH_ID:
-      {
-	struct synth_info inf;
-	int             dev;
+			  if (val < 0)
+				  val = 0;
 
-	memcpy ((char *) &inf, (&((char *) arg)[0]), sizeof (inf));
-	dev = inf.device;
+			  val = (HZ * val) / 10;
+			  pre_event_timeout = val;
+			  return (*(int *) arg = val);
+		  }
+		  break;
 
-	if (dev < 0 || dev >= max_synthdev)
-	  return -ENXIO;
+	  default:
+		  if (mode == OPEN_READ)
+			  return -EIO;
 
-	if (!(synth_open_mask & (1 << dev)) && !orig_dev)
-	  return -EBUSY;
+		  if (!synth_devs[0])
+			  return -ENXIO;
+		  if (!(synth_open_mask & (1 << 0)))
+			  return -ENXIO;
+		  return synth_devs[0]->ioctl(0, cmd, arg);
+		  break;
+	  }
 
-	memcpy ((char *) &inf, (char *) synth_devs[dev]->info, sizeof (inf));
-	strcpy (inf.name, synth_devs[dev]->id);
-	memcpy ((&((char *) arg)[0]), (char *) &inf, sizeof (inf));
-	return 0;
-      }
-      break;
+	return -EINVAL;
+}
 
-    case SNDCTL_SEQ_OUTOFBAND:
-      {
-	struct seq_event_rec event_rec;
+int
+sequencer_select(int dev, struct fileinfo *file, int sel_type, poll_table * wait)
+{
 	unsigned long   flags;
 
-	memcpy ((char *) &event_rec, (&((char *) arg)[0]), sizeof (event_rec));
-
-	save_flags (flags);
-	cli ();
-	play_event (event_rec.arr);
-	restore_flags (flags);
-
-	return 0;
-      }
-      break;
-
-    case SNDCTL_MIDI_INFO:
-      {
-	struct midi_info inf;
-	int             dev;
-	char           *pp;
+	dev = dev >> 4;
 
-	memcpy ((char *) &inf, (&((char *) arg)[0]), sizeof (inf));
-	dev = inf.device;
-
-	if (dev < 0 || dev >= max_mididev)
-	  return -ENXIO;
-
-	pp = (char *) &midi_devs[dev]->info;
-	memcpy ((&((char *) arg)[0]), pp, sizeof (inf));
-	return 0;
-      }
-      break;
-
-    case SNDCTL_SEQ_THRESHOLD:
-      {
-	int             tmp;
-
-	tmp = *(int *) arg;
+	switch (sel_type)
+	  {
+	  case SEL_IN:
+		  save_flags(flags);
+		  cli();
+		  if (!iqlen)
+		    {
+
+			    midi_sleep_flag.opts = WK_SLEEP;
+			    poll_wait(&midi_sleeper, wait);
+			    restore_flags(flags);
+			    return 0;
+		    }
+		  restore_flags(flags);
+		  return 1;
+		  break;
+
+	  case SEL_OUT:
+		  save_flags(flags);
+		  cli();
+		  if ((SEQ_MAX_QUEUE - qlen) < output_threshold)
+		    {
+
+			    seq_sleep_flag.opts = WK_SLEEP;
+			    poll_wait(&seq_sleeper, wait);
+			    restore_flags(flags);
+			    return 0;
+		    }
+		  restore_flags(flags);
+		  return 1;
+		  break;
+
+	  case SEL_EX:
+		  return 0;
+	  }
 
-	if (tmp < 1)
-	  tmp = 1;
-	if (tmp >= SEQ_MAX_QUEUE)
-	  tmp = SEQ_MAX_QUEUE - 1;
-	output_threshold = tmp;
 	return 0;
-      }
-      break;
-
-    case SNDCTL_MIDI_PRETIME:
-      {
-	int             val;
-
-	val = *(int *) arg;
-
-	if (val < 0)
-	  val = 0;
-
-	val = (HZ * val) / 10;
-	pre_event_timeout = val;
-	return (*(int *) arg = val);
-      }
-      break;
-
-    default:
-      if (mode == OPEN_READ)
-	return -EIO;
+}
 
-      if (!synth_devs[0])
-	return -ENXIO;
-      if (!(synth_open_mask & (1 << 0)))
-	return -ENXIO;
-      return synth_devs[0]->ioctl (0, cmd, arg);
-      break;
-    }
 
-  return -EINVAL;
+void
+sequencer_timer(unsigned long dummy)
+{
+	seq_startplay();
 }
 
 int
-sequencer_select (int dev, struct fileinfo *file, int sel_type, poll_table * wait)
+note_to_freq(int note_num)
 {
-  unsigned long   flags;
 
-  dev = dev >> 4;
+	/*
+	 * This routine converts a midi note to a frequency (multiplied by 1000)
+	 */
 
-  switch (sel_type)
-    {
-    case SEL_IN:
-      save_flags (flags);
-      cli ();
-      if (!iqlen)
+	int             note, octave, note_freq;
+	static int      notes[] =
 	{
+		261632, 277189, 293671, 311132, 329632, 349232,
+		369998, 391998, 415306, 440000, 466162, 493880
+	};
 
-	  midi_sleep_flag.opts = WK_SLEEP;
-	  poll_wait (&midi_sleeper, wait);
-	  restore_flags (flags);
-	  return 0;
-	}
-      restore_flags (flags);
-      return 1;
-      break;
-
-    case SEL_OUT:
-      save_flags (flags);
-      cli ();
-      if ((SEQ_MAX_QUEUE - qlen) < output_threshold)
-	{
+#define BASE_OCTAVE	5
 
-	  seq_sleep_flag.opts = WK_SLEEP;
-	  poll_wait (&seq_sleeper, wait);
-	  restore_flags (flags);
-	  return 0;
-	}
-      restore_flags (flags);
-      return 1;
-      break;
+	octave = note_num / 12;
+	note = note_num % 12;
 
-    case SEL_EX:
-      return 0;
-    }
+	note_freq = notes[note];
 
-  return 0;
-}
+	if (octave < BASE_OCTAVE)
+		note_freq >>= (BASE_OCTAVE - octave);
+	else if (octave > BASE_OCTAVE)
+		note_freq <<= (octave - BASE_OCTAVE);
 
+	/*
+	 * note_freq >>= 1;
+	 */
 
-void
-sequencer_timer (unsigned long dummy)
-{
-  seq_startplay ();
+	return note_freq;
 }
 
-int
-note_to_freq (int note_num)
+unsigned long
+compute_finetune(unsigned long base_freq, int bend, int range,
+		 int vibrato_cents)
 {
+	unsigned long   amount;
+	int             negative, semitones, cents, multiplier = 1;
 
-  /*
-   * This routine converts a midi note to a frequency (multiplied by 1000)
-   */
+	if (!bend)
+		return base_freq;
+	if (!range)
+		return base_freq;
 
-  int             note, octave, note_freq;
-  static int      notes[] =
-  {
-    261632, 277189, 293671, 311132, 329632, 349232,
-    369998, 391998, 415306, 440000, 466162, 493880
-  };
+	if (!base_freq)
+		return base_freq;
 
-#define BASE_OCTAVE	5
+	if (range >= 8192)
+		range = 8192;
 
-  octave = note_num / 12;
-  note = note_num % 12;
+	bend = bend * range / 8192;	/* Convert to cents */
+	bend += vibrato_cents;
 
-  note_freq = notes[note];
+	if (!bend)
+		return base_freq;
 
-  if (octave < BASE_OCTAVE)
-    note_freq >>= (BASE_OCTAVE - octave);
-  else if (octave > BASE_OCTAVE)
-    note_freq <<= (octave - BASE_OCTAVE);
+	negative = bend < 0 ? 1 : 0;
 
-  /*
-   * note_freq >>= 1;
-   */
+	if (bend < 0)
+		bend *= -1;
+	if (bend > range)
+		bend = range;
 
-  return note_freq;
-}
+	/*
+	   if (bend > 2399)
+	   bend = 2399;
+	 */
+	while (bend > 2399)
+	  {
+		  multiplier *= 4;
+		  bend -= 2400;
+	  }
 
-unsigned long
-compute_finetune (unsigned long base_freq, int bend, int range,
-		  int vibrato_cents)
-{
-  unsigned long   amount;
-  int             negative, semitones, cents, multiplier = 1;
-
-  if (!bend)
-    return base_freq;
-  if (!range)
-    return base_freq;
-
-  if (!base_freq)
-    return base_freq;
-
-  if (range >= 8192)
-    range = 8192;
-
-  bend = bend * range / 8192;	/* Convert to cents */
-  bend += vibrato_cents;
-
-  if (!bend)
-    return base_freq;
-
-  negative = bend < 0 ? 1 : 0;
-
-  if (bend < 0)
-    bend *= -1;
-  if (bend > range)
-    bend = range;
-
-  /*
-     if (bend > 2399)
-     bend = 2399;
-   */
-  while (bend > 2399)
-    {
-      multiplier *= 4;
-      bend -= 2400;
-    }
-
-  semitones = bend / 100;
-  if (semitones > 99)
-    semitones = 99;
-  cents = bend % 100;
-
-  amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents])
-    / 10000;
-
-  if (negative)
-    return (base_freq * 10000) / amount;	/* Bend down */
-  else
-    return (base_freq * amount) / 10000;	/* Bend up */
+	semitones = bend / 100;
+	if (semitones > 99)
+		semitones = 99;
+	cents = bend % 100;
+
+	amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents])
+	    / 10000;
+
+	if (negative)
+		return (base_freq * 10000) / amount;	/* Bend down */
+	else
+		return (base_freq * amount) / 10000;	/* Bend up */
 }
 
 
 void
-sequencer_init (void)
+sequencer_init(void)
 {
-  if (sequencer_ok)
-    return;
+	if (sequencer_ok)
+		return;
 
 #ifdef CONFIG_MIDI
-  MIDIbuf_init ();
+	MIDIbuf_init();
 #endif
 
 
-  queue = (unsigned char *) (sound_mem_blocks[sound_nblocks] = vmalloc (SEQ_MAX_QUEUE * EV_SZ));
-  sound_mem_sizes[sound_nblocks] = SEQ_MAX_QUEUE * EV_SZ;
-  if (sound_nblocks < 1024)
-    sound_nblocks++;;
-  if (queue == NULL)
-    {
-      printk ("Sound: Can't allocate memory for sequencer output queue\n");
-      return;
-    }
-
-
-  iqueue = (unsigned char *) (sound_mem_blocks[sound_nblocks] = vmalloc (SEQ_MAX_QUEUE * IEV_SZ));
-  sound_mem_sizes[sound_nblocks] = SEQ_MAX_QUEUE * IEV_SZ;
-  if (sound_nblocks < 1024)
-    sound_nblocks++;;
-  if (iqueue == NULL)
-    {
-      printk ("Sound: Can't allocate memory for sequencer input queue\n");
-      return;
-    }
-
-
-  sequencer_ok = 1;
+	queue = (unsigned char *) (sound_mem_blocks[sound_nblocks] = vmalloc(SEQ_MAX_QUEUE * EV_SZ));
+	sound_mem_sizes[sound_nblocks] = SEQ_MAX_QUEUE * EV_SZ;
+	if (sound_nblocks < 1024)
+		sound_nblocks++;;
+	if (queue == NULL)
+	  {
+		  printk("Sound: Can't allocate memory for sequencer output queue\n");
+		  return;
+	  }
+	iqueue = (unsigned char *) (sound_mem_blocks[sound_nblocks] = vmalloc(SEQ_MAX_QUEUE * IEV_SZ));
+	sound_mem_sizes[sound_nblocks] = SEQ_MAX_QUEUE * IEV_SZ;
+	if (sound_nblocks < 1024)
+		sound_nblocks++;;
+	if (iqueue == NULL)
+	  {
+		  printk("Sound: Can't allocate memory for sequencer input queue\n");
+		  return;
+	  }
+	sequencer_ok = 1;
 }
 
 #endif