patch-2.1.78 linux/drivers/sound/sequencer.c
Next file: linux/drivers/sound/softoss.c
Previous file: linux/drivers/sound/sb_mixer.c
Back to the patch index
Back to the overall index
- Lines: 2370
- Date:
Sun Jan 4 10:40:16 1998
- Orig file:
v2.1.77/linux/drivers/sound/sequencer.c
- Orig date:
Fri Jan 2 14:37:02 1998
diff -u --recursive --new-file v2.1.77/linux/drivers/sound/sequencer.c linux/drivers/sound/sequencer.c
@@ -12,6 +12,7 @@
*/
/*
* Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
+ * Alan Cox : reformatted and fixed a pair of null pointer bugs
*/
#include <linux/config.h>
@@ -89,12 +90,11 @@
#error Too many synthesizer devices enabled.
#endif
-int
-sequencer_read(int dev, struct fileinfo *file, char *buf, int count)
+int sequencer_read(int dev, struct fileinfo *file, char *buf, int count)
{
- int c = count, p = 0;
- int ev_len;
- unsigned long flags;
+ int c = count, p = 0;
+ int ev_len;
+ unsigned long flags;
dev = dev >> 4;
@@ -103,70 +103,65 @@
save_flags(flags);
cli();
if (!iqlen)
- {
- 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;
- };
-
- if (!iqlen)
- {
- restore_flags(flags);
- return 0;
- }
- }
- while (iqlen && c >= ev_len)
- {
+ {
+ if ((file->flags & (O_NONBLOCK) ? 1 : 0))
+ {
+ restore_flags(flags);
+ return -EAGAIN;
+ }
+ {
+ unsigned long tlimit;
- {
- char *fixit = (char *) &iqueue[iqhead * IEV_SZ];
+ 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;
+ };
+
+ if (!iqlen)
+ {
+ restore_flags(flags);
+ return 0;
+ }
+ }
+ while (iqlen && c >= ev_len)
+ {
+ {
+ 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--;
- }
+ iqhead = (iqhead + 1) % SEQ_MAX_QUEUE;
+ iqlen--;
+ }
restore_flags(flags);
return count - c;
}
-static void
-sequencer_midi_output(int dev)
+static void sequencer_midi_output(int dev)
{
/*
* Currently NOP
*/
}
-void
-seq_copy_to_input(unsigned char *event_rec, int len)
+void seq_copy_to_input(unsigned char *event_rec, int len)
{
unsigned long flags;
/*
- * Verify that the len is valid for the current mode.
+ * Verify that the len is valid for the current mode.
*/
if (len != 4 && len != 8)
@@ -184,20 +179,17 @@
iqtail = (iqtail + 1) % SEQ_MAX_QUEUE;
if ((midi_sleep_flag.opts & WK_SLEEP))
- {
- {
- midi_sleep_flag.opts = WK_WAKEUP;
- wake_up(&midi_sleeper);
- };
- }
+ {
+ midi_sleep_flag.opts = WK_WAKEUP;
+ wake_up(&midi_sleeper);
+ }
restore_flags(flags);
}
-static void
-sequencer_midi_input(int dev, unsigned char data)
+static void sequencer_midi_input(int dev, unsigned char data)
{
- unsigned int tstamp;
- unsigned char event_rec[4];
+ unsigned int tstamp;
+ unsigned char event_rec[4];
if (data == 0xfe) /* Ignore active sensing */
return;
@@ -208,12 +200,12 @@
tstamp = jiffies - seq_time;
if (tstamp != prev_input_time)
- {
- tstamp = (tstamp << 8) | SEQ_WAIT;
+ {
+ tstamp = (tstamp << 8) | SEQ_WAIT;
- seq_copy_to_input((unsigned char *) &tstamp, 4);
- prev_input_time = tstamp;
- }
+ 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;
@@ -222,10 +214,9 @@
seq_copy_to_input(event_rec, 4);
}
-void
-seq_input_event(unsigned char *event_rec, int len)
+void seq_input_event(unsigned char *event_rec, int len)
{
- unsigned long this_time;
+ unsigned long this_time;
if (seq_mode == SEQ_2)
this_time = tmr->get_time(tmr_no);
@@ -235,28 +226,27 @@
this_time = jiffies - seq_time;
if (this_time != prev_input_time)
- {
- unsigned char tmp_event[8];
+ {
+ unsigned char tmp_event[8];
+
+ 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;
- 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;
-
- seq_copy_to_input(tmp_event, 8);
- prev_input_time = this_time;
- }
+ seq_copy_to_input(tmp_event, 8);
+ prev_input_time = this_time;
+ }
seq_copy_to_input(event_rec, len);
}
-int
-sequencer_write(int dev, struct fileinfo *file, const char *buf, int count)
+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;
+ 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;
@@ -268,100 +258,98 @@
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;
-
- 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];
+ {
+ copy_from_user((char *) event_rec, &(buf)[p], 4);
+ ev_code = event_rec[0];
- if (dev >= max_mididev)
- {
- printk("Sequencer Error: Nonexistent MIDI device %d\n", dev);
- return -ENXIO;
- }
- mode = file->mode & O_ACCMODE;
+ 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;
- 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;
- }
+ return err;
+ }
+ if (ev_code >= 128)
+ {
+ if (seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED)
+ {
+ printk(KERN_WARNING "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(KERN_WARNING "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 || midi_devs[dev]==NULL)
+ {
+ /*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(KERN_WARNING "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();
@@ -369,8 +357,7 @@
return count;
}
-static int
-seq_queue(unsigned char *note, char nonblock)
+static int seq_queue(unsigned char *note, char nonblock)
{
/*
@@ -384,21 +371,21 @@
*/
if (!nonblock && qlen >= SEQ_MAX_QUEUE && !(seq_sleep_flag.opts & WK_SLEEP))
- {
- /*
- * Sleep until there is enough space on the queue
- */
-
- seq_sleep_flag.opts = WK_SLEEP;
- interruptible_sleep_on(&seq_sleeper);
- seq_sleep_flag.opts &= ~WK_SLEEP;;
- }
+ {
+ /*
+ * Sleep until there is enough space on the queue
+ */
+
+ seq_sleep_flag.opts = WK_SLEEP;
+ interruptible_sleep_on(&seq_sleeper);
+ seq_sleep_flag.opts &= ~WK_SLEEP;;
+ }
if (qlen >= SEQ_MAX_QUEUE)
- {
- return 0; /*
+ {
+ return 0; /*
* To be sure
*/
- }
+ }
memcpy(&queue[qtail * EV_SZ], note, EV_SZ);
qtail = (qtail + 1) % SEQ_MAX_QUEUE;
@@ -407,8 +394,7 @@
return 1;
}
-static int
-extended_event(unsigned char *q)
+static int extended_event(unsigned char *q)
{
int dev = q[2];
@@ -419,53 +405,51 @@
return -ENXIO;
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_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;
+ }
return 0;
}
-static int
-find_voice(int dev, int chn, int note)
+static int find_voice(int dev, int chn, int note)
{
unsigned short key;
int i;
@@ -479,8 +463,7 @@
return -1;
}
-static int
-alloc_voice(int dev, int chn, int note)
+static int alloc_voice(int dev, int chn, int note)
{
unsigned short key;
int voice;
@@ -495,8 +478,7 @@
return voice;
}
-static void
-seq_chn_voice_event(unsigned char *event_rec)
+static void seq_chn_voice_event(unsigned char *event_rec)
{
#define dev event_rec[1]
#define cmd event_rec[2]
@@ -504,7 +486,7 @@
#define note event_rec[4]
#define parm event_rec[5]
- int voice = -1;
+ int voice = -1;
if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
return;
@@ -514,60 +496,62 @@
return;
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;
- }
- }
+ {
+ 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;
+ {
+ 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:;
- }
+ default:
+ }
#undef dev
#undef cmd
#undef chn
@@ -576,8 +560,7 @@
}
-static void
-seq_chn_common_event(unsigned char *event_rec)
+static void seq_chn_common_event(unsigned char *event_rec)
{
unsigned char dev = event_rec[1];
unsigned char cmd = event_rec[2];
@@ -595,208 +578,208 @@
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;
+ {
+ 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 */
+ 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);
+ | (synth_devs[dev]->
+ chn_info[chn].controllers[p1 | 32] & 0x7f);
p1 &= ~32;
}
- /* Handle all playing notes on this channel */
+ /* Handle all playing notes on this channel */
- key = ((int) chn << 8);
+ 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;
+ 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:;
- }
+ default:
+ }
}
-static int
-seq_timing_event(unsigned char *event_rec)
+static int 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;
+ {
+ 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;
- }
+ 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))
+ {
+ 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);
- };
+ 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;
+ 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:;
- }
+ default:
+ }
return TIMER_NOT_ARMED;
}
-static void
-seq_local_event(unsigned char *event_rec)
+static void seq_local_event(unsigned char *event_rec)
{
unsigned char cmd = event_rec[1];
unsigned int parm = *((unsigned int *) &event_rec[4]);
switch (cmd)
- {
- case LOCL_STARTAUDIO:
+ {
+ 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)
+static void seq_sysex_message(unsigned char *event_rec)
{
int dev = event_rec[1];
int i, l = 0;
@@ -819,261 +802,259 @@
synth_devs[dev]->send_sysex(dev, buf, l);
}
-static int
-play_event(unsigned char *q)
+static int 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
+ * 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;
+ 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;
+ {
+ 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))
+ 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
- */
- 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
+ restore_flags(flags);
+ }
+ /*
+ * The timer is now active and will reinvoke this function
+ * after the timer expires. Return to the caller now.
*/
- 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;
+ 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
+ */
+ 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 || 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;
+ 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:;
- }
+ default:;
+ }
return 0;
}
-static void
-seq_startplay(void)
+static void seq_startplay(void)
{
- unsigned long flags;
- int this_one, action;
+ 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);
- 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;
- }
- }
+ 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;
+ }
+ }
seq_playing = 0;
if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
- {
- unsigned long 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);
- }
+ 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)
{
- int i;
+ int i;
for (i = 0; i < 128; i++)
controller[i] = ctrl_def_values[i];
}
-static void
-setup_mode2(void)
+static void setup_mode2(void)
{
- int dev;
+ int dev;
max_synthdev = num_synths;
for (dev = 0; dev < num_midis; dev++)
+ {
if (midi_devs[dev] && midi_devs[dev]->converter != NULL)
- {
- synth_devs[max_synthdev++] =
- midi_devs[dev]->converter;
- }
+ {
+ synth_devs[max_synthdev++] = midi_devs[dev]->converter;
+ }
+ }
+
for (dev = 0; dev < max_synthdev; dev++)
- {
- int chn;
+ {
+ int chn;
- synth_devs[dev]->sysex_ptr = 0;
- synth_devs[dev]->emulation = 0;
+ 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;
}
-int
-sequencer_open(int dev, struct fileinfo *file)
+int sequencer_open(int dev, struct fileinfo *file)
{
int retval, mode, i;
int level, tmp;
@@ -1090,28 +1071,30 @@
DEB(printk("sequencer_open(dev=%d)\n", dev));
if (!sequencer_ok)
- {
- printk("Soundcard: Sequencer not initialized\n");
- return -ENXIO;
- }
+ {
+/* 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");
+ {
+ /*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;
- }
+ {
+ restore_flags(flags);
+ return -EBUSY;
+ }
sequencer_busy = 1;
obsolete_api_used = 0;
restore_flags(flags);
@@ -1122,61 +1105,65 @@
seq_mode = SEQ_1;
if (pending_timer != -1)
- {
- tmr_no = pending_timer;
- pending_timer = -1;
- }
+ {
+ tmr_no = pending_timer;
+ pending_timer = -1;
+ }
if (tmr_no == -1) /* Not selected yet */
- {
- int i, best;
+ {
+ int i, best;
- best = -1;
- for (i = 0; i < num_sound_timers; i++)
- if (sound_timer_devs[i] && sound_timer_devs[i]->priority > 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;
- }
+ }
+ if (tmr_no == -1) /* Should not be */
+ tmr_no = 0;
+ }
tmr = sound_timer_devs[tmr_no];
if (level == 2)
- {
- if (tmr == NULL)
- {
- printk("sequencer: No timer for level 2\n");
- sequencer_busy = 0;
- return -ENXIO;
- }
- setup_mode2();
- }
+ {
+ 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;
- }
+ {
+ 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;
- }
- }
+ {
+ if (synth_devs[i]==NULL)
+ continue;
+
+ if ((tmp = synth_devs[i]->open(i, mode)) < 0)
+ {
+ printk(KERN_WARNING "Sequencer: Warning! Cannot open synth device #%d (%d)\n", i, tmp);
+ if (synth_devs[i]->midi_dev)
+ printk(KERN_WARNING "(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;
+ }
+ }
if (softsynthp != NULL)
seq_time = 0;
@@ -1189,21 +1176,25 @@
softsynthp(SSYN_START, 0, 0, 0);
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])
- {
- if ((retval = midi_devs[i]->open(i, mode,
- sequencer_midi_input, sequencer_midi_output)) >= 0)
- midi_opened[i] = 1;
- }
- }
+ {
+ /*
+ * Initialize midi input devices
+ */
+
+ 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)
- {
- tmr->open(tmr_no, seq_mode);
- }
+ {
+ tmr->open(tmr_no, seq_mode);
+ }
seq_sleep_flag.opts = WK_NONE;
midi_sleep_flag.opts = WK_NONE;
output_threshold = SEQ_MAX_QUEUE / 2;
@@ -1211,8 +1202,7 @@
return 0;
}
-void
-seq_drain_midi_queues(void)
+void seq_drain_midi_queues(void)
{
int i, n;
@@ -1223,43 +1213,42 @@
n = 1;
while (!signal_pending(current) && n)
- {
- n = 0;
+ {
+ 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++;
- 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;
- };
- }
- }
+ /*
+ * 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)
+void sequencer_release(int dev, struct fileinfo *file)
{
int i;
int mode = file->mode & O_ACCMODE;
@@ -1274,27 +1263,30 @@
if (mode != OPEN_READ && !(file->flags & (O_NONBLOCK) ?
1 : 0))
+ {
while (!signal_pending(current) && qlen > 0)
- {
- seq_sync();
+ {
+ seq_sync();
- {
- unsigned long tlimit;
+ {
+ 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 (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
@@ -1306,35 +1298,34 @@
*/
for (i = 0; i < max_synthdev; i++)
- {
- 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;
- }
- }
+ {
+ 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])
+ {
+ if (midi_opened[i])
midi_devs[i]->close(i);
- }
+ }
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");
+ printk(KERN_WARNING "/dev/music: Obsolete (4 byte) API was used by %s\n", current->comm);
sequencer_busy = 0;
}
-static int
-seq_sync(void)
+static int seq_sync(void)
{
unsigned long flags;
@@ -1344,32 +1335,30 @@
save_flags(flags);
cli();
if (qlen > 0)
- {
-
- {
- unsigned long tlimit;
+ {
+ {
+ 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;
- };
- }
+ 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;
+ };
+ }
restore_flags(flags);
return qlen;
}
-static void
-midi_outc(int dev, unsigned char data)
+static void midi_outc(int dev, unsigned char data)
{
/*
* NOTE! Calls sleep(). Don't call this from interrupt.
@@ -1389,31 +1378,29 @@
save_flags(flags);
cli();
while (n && !midi_devs[dev]->outputc(dev, data))
- {
-
- {
- unsigned long tlimit;
+ {
+ {
+ 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--;
- }
+ 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--;
+ }
restore_flags(flags);
}
-static void
-seq_reset(void)
+static void seq_reset(void)
{
/*
* NOTE! Calls sleep(). Don't call this from interrupt.
@@ -1441,82 +1428,79 @@
synth_devs[i]->reset(i);
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]) /*
+ {
+ 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;
- }
- }
+ {
+ /*
+ * 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))
- {
- /* printk( "Sequencer Warning: Unexpected sleeping process - Waking up\n"); */
- {
- seq_sleep_flag.opts = WK_WAKEUP;
- wake_up(&seq_sleeper);
- };
- }
+ {
+ /* printk( "Sequencer Warning: Unexpected sleeping process - Waking up\n"); */
+ {
+ seq_sleep_flag.opts = WK_WAKEUP;
+ wake_up(&seq_sleeper);
+ };
+ }
restore_flags(flags);
-
}
-static void
-seq_panic(void)
+static void seq_panic(void)
{
/*
- * This routine is called by the application in case the user
- * wants to reset the system to the default state.
+ * 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
+ * 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
+ * Also return the controllers to their default states
*/
}
@@ -1724,69 +1708,61 @@
return -EINVAL;
}
-int
-sequencer_select(int dev, struct fileinfo *file, int sel_type, poll_table * wait)
+int sequencer_select(int dev, struct fileinfo *file, int sel_type, poll_table * wait)
{
unsigned long flags;
dev = dev >> 4;
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;
- }
+ {
+ 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;
+
+ 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;
+ case SEL_EX:
+ return 0;
+ }
return 0;
}
-void
-sequencer_timer(unsigned long dummy)
+void sequencer_timer(unsigned long dummy)
{
seq_startplay();
}
-int
-note_to_freq(int note_num)
+int note_to_freq(int note_num)
{
/*
* This routine converts a midi note to a frequency (multiplied by 1000)
*/
- int note, octave, note_freq;
- static int notes[] =
+ int note, octave, note_freq;
+ static int notes[] =
{
261632, 277189, 293671, 311132, 329632, 349232,
369998, 391998, 415306, 440000, 466162, 493880
@@ -1811,12 +1787,11 @@
return note_freq;
}
-unsigned long
-compute_finetune(unsigned long base_freq, int bend, int range,
+unsigned long compute_finetune(unsigned long base_freq, int bend, int range,
int vibrato_cents)
{
- unsigned long amount;
- int negative, semitones, cents, multiplier = 1;
+ unsigned long amount;
+ int negative, semitones, cents, multiplier = 1;
if (!bend)
return base_freq;
@@ -1847,18 +1822,17 @@
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;
+ amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents]) / 10000;
if (negative)
return (base_freq * 10000) / amount; /* Bend down */
@@ -1867,8 +1841,7 @@
}
-void
-sequencer_init(void)
+void sequencer_init(void)
{
if (sequencer_ok)
return;
@@ -1883,19 +1856,19 @@
if (sound_nblocks < 1024)
sound_nblocks++;;
if (queue == NULL)
- {
- printk("Sound: Can't allocate memory for sequencer output queue\n");
+ {
+ printk(KERN_ERR "sequencer: 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++;;
+ sound_nblocks++;
if (iqueue == NULL)
- {
- printk("Sound: Can't allocate memory for sequencer input queue\n");
- return;
- }
+ {
+ printk(KERN_ERR "sequencer: Can't allocate memory for sequencer input queue\n");
+ return;
+ }
sequencer_ok = 1;
}
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov