?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.1pre2
[davej-history.git] / drivers / sound / sequencer.c
blob8fee21c6bd94047eb70701d33291001faa041a81
1 /*
2 * sound/sequencer.c
3 *
4 * The sequencer personality manager.
5 */
6 /*
7 * Copyright (C) by Hannu Savolainen 1993-1997
8 *
9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
11 * for more info.
12 */
13 /*
14 * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
15 * Alan Cox : reformatted and fixed a pair of null pointer bugs
16 */
17 #include <linux/config.h>
18
19 #include <linux/kmod.h>
20
21
22 #define SEQUENCER_C
23 #include "sound_config.h"
24
25 #ifdef CONFIG_SEQUENCER
26 #include "softoss.h"
27 int (*softsynthp) (int cmd, int parm1, int parm2, unsigned long parm3) = NULL;
28
29 #include "midi_ctrl.h"
30
31 static int sequencer_ok = 0;
32 static struct sound_timer_operations *tmr;
33 static int tmr_no = -1; /* Currently selected timer */
34 static int pending_timer = -1; /* For timer change operation */
35 extern unsigned long seq_time;
36
37 static int obsolete_api_used = 0;
38
39 /*
40 * Local counts for number of synth and MIDI devices. These are initialized
41 * by the sequencer_open.
42 */
43 static int max_mididev = 0;
44 static int max_synthdev = 0;
45
46 /*
47 * The seq_mode gives the operating mode of the sequencer:
48 * 1 = level1 (the default)
49 * 2 = level2 (extended capabilities)
50 */
51
52 #define SEQ_1 1
53 #define SEQ_2 2
54 static int seq_mode = SEQ_1;
55
56 static DECLARE_WAIT_QUEUE_HEAD(seq_sleeper);
57 static DECLARE_WAIT_QUEUE_HEAD(midi_sleeper);
58
59 static int midi_opened[MAX_MIDI_DEV] = {
60 0
61 };
62
63 static int midi_written[MAX_MIDI_DEV] = {
64 0
65 };
66
67 static unsigned long prev_input_time = 0;
68 static int prev_event_time;
69
70 #include "tuning.h"
71
72 #define EV_SZ 8
73 #define IEV_SZ 8
74
75 static unsigned char *queue = NULL;
76 static unsigned char *iqueue = NULL;
77
78 static volatile int qhead = 0, qtail = 0, qlen = 0;
79 static volatile int iqhead = 0, iqtail = 0, iqlen = 0;
80 static volatile int seq_playing = 0;
81 static volatile int sequencer_busy = 0;
82 static int output_threshold;
83 static long pre_event_timeout;
84 static unsigned synth_open_mask;
85
86 static int seq_queue(unsigned char *note, char nonblock);
87 static void seq_startplay(void);
88 static int seq_sync(void);
89 static void seq_reset(void);
90
91 #if MAX_SYNTH_DEV > 15
92 #error Too many synthesizer devices enabled.
93 #endif
94
95 int sequencer_read(int dev, struct file *file, char *buf, int count)
96 {
97 int c = count, p = 0;
98 int ev_len;
99 unsigned long flags;
100
101 dev = dev >> 4;
102
103 ev_len = seq_mode == SEQ_1 ? 4 : 8;
104
105 save_flags(flags);
106 cli();
107
108 if (!iqlen)
109 {
110 if (file->f_flags & O_NONBLOCK) {
111 restore_flags(flags);
112 return -EAGAIN;
113 }
114
115 interruptible_sleep_on_timeout(&midi_sleeper,
116 pre_event_timeout);
117 if (!iqlen)
118 {
119 restore_flags(flags);
120 return 0;
121 }
122 }
123 while (iqlen && c >= ev_len)
124 {
125 char *fixit = (char *) &iqueue[iqhead * IEV_SZ];
126 copy_to_user(&(buf)[p], fixit, ev_len);
127 p += ev_len;
128 c -= ev_len;
129
130 iqhead = (iqhead + 1) % SEQ_MAX_QUEUE;
131 iqlen--;
132 }
133 restore_flags(flags);
134 return count - c;
135 }
136
137 static void sequencer_midi_output(int dev)
138 {
139 /*
140 * Currently NOP
141 */
142 }
143
144 void seq_copy_to_input(unsigned char *event_rec, int len)
145 {
146 unsigned long flags;
147
148 /*
149 * Verify that the len is valid for the current mode.
150 */
151
152 if (len != 4 && len != 8)
153 return;
154 if ((seq_mode == SEQ_1) != (len == 4))
155 return;
156
157 if (iqlen >= (SEQ_MAX_QUEUE - 1))
158 return; /* Overflow */
159
160 save_flags(flags);
161 cli();
162 memcpy(&iqueue[iqtail * IEV_SZ], event_rec, len);
163 iqlen++;
164 iqtail = (iqtail + 1) % SEQ_MAX_QUEUE;
165 wake_up(&midi_sleeper);
166 restore_flags(flags);
167 }
168
169 static void sequencer_midi_input(int dev, unsigned char data)
170 {
171 unsigned int tstamp;
172 unsigned char event_rec[4];
173
174 if (data == 0xfe) /* Ignore active sensing */
175 return;
176
177 if (softsynthp != NULL)
178 tstamp = softsynthp(SSYN_GETTIME, 0, 0, 0);
179 else
180 tstamp = jiffies - seq_time;
181
182 if (tstamp != prev_input_time)
183 {
184 tstamp = (tstamp << 8) | SEQ_WAIT;
185 seq_copy_to_input((unsigned char *) &tstamp, 4);
186 prev_input_time = tstamp;
187 }
188 event_rec[0] = SEQ_MIDIPUTC;
189 event_rec[1] = data;
190 event_rec[2] = dev;
191 event_rec[3] = 0;
192
193 seq_copy_to_input(event_rec, 4);
194 }
195
196 void seq_input_event(unsigned char *event_rec, int len)
197 {
198 unsigned long this_time;
199
200 if (seq_mode == SEQ_2)
201 this_time = tmr->get_time(tmr_no);
202 else if (softsynthp != NULL)
203 this_time = softsynthp(SSYN_GETTIME, 0, 0, 0);
204 else
205 this_time = jiffies - seq_time;
206
207 if (this_time != prev_input_time)
208 {
209 unsigned char tmp_event[8];
210
211 tmp_event[0] = EV_TIMING;
212 tmp_event[1] = TMR_WAIT_ABS;
213 tmp_event[2] = 0;
214 tmp_event[3] = 0;
215 *(unsigned int *) &tmp_event[4] = this_time;
216
217 seq_copy_to_input(tmp_event, 8);
218 prev_input_time = this_time;
219 }
220 seq_copy_to_input(event_rec, len);
221 }
222
223 int sequencer_write(int dev, struct file *file, const char *buf, int count)
224 {
225 unsigned char event_rec[EV_SZ], ev_code;
226 int p = 0, c, ev_size;
227 int err;
228 int mode = translate_mode(file);
229
230 dev = dev >> 4;
231
232 DEB(printk("sequencer_write(dev=%d, count=%d)\n", dev, count));
233
234 if (mode == OPEN_READ)
235 return -EIO;
236
237 c = count;
238
239 while (c >= 4)
240 {
241 copy_from_user((char *) event_rec, &(buf)[p], 4);
242 ev_code = event_rec[0];
243
244 if (ev_code == SEQ_FULLSIZE)
245 {
246 int err, fmt;
247
248 dev = *(unsigned short *) &event_rec[2];
249 if (dev < 0 || dev >= max_synthdev || synth_devs[dev] == NULL)
250 return -ENXIO;
251
252 if (!(synth_open_mask & (1 << dev)))
253 return -ENXIO;
254
255 fmt = (*(short *) &event_rec[0]) & 0xffff;
256 err = synth_devs[dev]->load_patch(dev, fmt, buf, p + 4, c, 0);
257 if (err < 0)
258 return err;
259
260 return err;
261 }
262 if (ev_code >= 128)
263 {
264 if (seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED)
265 {
266 printk(KERN_WARNING "Sequencer: Invalid level 2 event %x\n", ev_code);
267 return -EINVAL;
268 }
269 ev_size = 8;
270
271 if (c < ev_size)
272 {
273 if (!seq_playing)
274 seq_startplay();
275 return count - c;
276 }
277 copy_from_user((char *) &event_rec[4], &(buf)[p + 4], 4);
278
279 }
280 else
281 {
282 if (seq_mode == SEQ_2)
283 {
284 printk(KERN_WARNING "Sequencer: 4 byte event in level 2 mode\n");
285 return -EINVAL;
286 }
287 ev_size = 4;
288
289 if (event_rec[0] != SEQ_MIDIPUTC)
290 obsolete_api_used = 1;
291 }
292
293 if (event_rec[0] == SEQ_MIDIPUTC)
294 {
295 if (!midi_opened[event_rec[2]])
296 {
297 int mode;
298 int dev = event_rec[2];
299
300 if (dev >= max_mididev || midi_devs[dev]==NULL)
301 {
302 /*printk("Sequencer Error: Nonexistent MIDI device %d\n", dev);*/
303 return -ENXIO;
304 }
305 mode = translate_mode(file);
306
307 if ((err = midi_devs[dev]->open(dev, mode,
308 sequencer_midi_input, sequencer_midi_output)) < 0)
309 {
310 seq_reset();
311 printk(KERN_WARNING "Sequencer Error: Unable to open Midi #%d\n", dev);
312 return err;
313 }
314 midi_opened[dev] = 1;
315 }
316 }
317 if (!seq_queue(event_rec, (file->f_flags & (O_NONBLOCK) ? 1 : 0)))
318 {
319 int processed = count - c;
320
321 if (!seq_playing)
322 seq_startplay();
323
324 if (!processed && (file->f_flags & O_NONBLOCK))
325 return -EAGAIN;
326 else
327 return processed;
328 }
329 p += ev_size;
330 c -= ev_size;
331 }
332
333 if (!seq_playing)
334 seq_startplay();
335
336 return count;
337 }
338
339 static int seq_queue(unsigned char *note, char nonblock)
340 {
341
342 /*
343 * Test if there is space in the queue
344 */
345
346 if (qlen >= SEQ_MAX_QUEUE)
347 if (!seq_playing)
348 seq_startplay(); /*
349 * Give chance to drain the queue
350 */
351
352 if (!nonblock && qlen >= SEQ_MAX_QUEUE && !waitqueue_active(&seq_sleeper)) {
353 /*
354 * Sleep until there is enough space on the queue
355 */
356 interruptible_sleep_on(&seq_sleeper);
357 }
358 if (qlen >= SEQ_MAX_QUEUE)
359 {
360 return 0; /*
361 * To be sure
362 */
363 }
364 memcpy(&queue[qtail * EV_SZ], note, EV_SZ);
365
366 qtail = (qtail + 1) % SEQ_MAX_QUEUE;
367 qlen++;
368
369 return 1;
370 }
371
372 static int extended_event(unsigned char *q)
373 {
374 int dev = q[2];
375
376 if (dev < 0 || dev >= max_synthdev)
377 return -ENXIO;
378
379 if (!(synth_open_mask & (1 << dev)))
380 return -ENXIO;
381
382 switch (q[1])
383 {
384 case SEQ_NOTEOFF:
385 synth_devs[dev]->kill_note(dev, q[3], q[4], q[5]);
386 break;
387
388 case SEQ_NOTEON:
389 if (q[4] > 127 && q[4] != 255)
390 return 0;
391
392 if (q[5] == 0)
393 {
394 synth_devs[dev]->kill_note(dev, q[3], q[4], q[5]);
395 break;
396 }
397 synth_devs[dev]->start_note(dev, q[3], q[4], q[5]);
398 break;
399
400 case SEQ_PGMCHANGE:
401 synth_devs[dev]->set_instr(dev, q[3], q[4]);
402 break;
403
404 case SEQ_AFTERTOUCH:
405 synth_devs[dev]->aftertouch(dev, q[3], q[4]);
406 break;
407
408 case SEQ_BALANCE:
409 synth_devs[dev]->panning(dev, q[3], (char) q[4]);
410 break;
411
412 case SEQ_CONTROLLER:
413 synth_devs[dev]->controller(dev, q[3], q[4], (short) (q[5] | (q[6] << 8)));
414 break;
415
416 case SEQ_VOLMODE:
417 if (synth_devs[dev]->volume_method != NULL)
418 synth_devs[dev]->volume_method(dev, q[3]);
419 break;
420
421 default:
422 return -EINVAL;
423 }
424 return 0;
425 }
426
427 static int find_voice(int dev, int chn, int note)
428 {
429 unsigned short key;
430 int i;
431
432 key = (chn << 8) | (note + 1);
433 for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
434 if (synth_devs[dev]->alloc.map[i] == key)
435 return i;
436 return -1;
437 }
438
439 static int alloc_voice(int dev, int chn, int note)
440 {
441 unsigned short key;
442 int voice;
443
444 key = (chn << 8) | (note + 1);
445
446 voice = synth_devs[dev]->alloc_voice(dev, chn, note,
447 &synth_devs[dev]->alloc);
448 synth_devs[dev]->alloc.map[voice] = key;
449 synth_devs[dev]->alloc.alloc_times[voice] =
450 synth_devs[dev]->alloc.timestamp++;
451 return voice;
452 }
453
454 static void seq_chn_voice_event(unsigned char *event_rec)
455 {
456 #define dev event_rec[1]
457 #define cmd event_rec[2]
458 #define chn event_rec[3]
459 #define note event_rec[4]
460 #define parm event_rec[5]
461
462 int voice = -1;
463
464 if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
465 return;
466 if (!(synth_open_mask & (1 << dev)))
467 return;
468 if (!synth_devs[dev])
469 return;
470
471 if (seq_mode == SEQ_2)
472 {
473 if (synth_devs[dev]->alloc_voice)
474 voice = find_voice(dev, chn, note);
475
476 if (cmd == MIDI_NOTEON && parm == 0)
477 {
478 cmd = MIDI_NOTEOFF;
479 parm = 64;
480 }
481 }
482
483 switch (cmd)
484 {
485 case MIDI_NOTEON:
486 if (note > 127 && note != 255) /* Not a seq2 feature */
487 return;
488
489 if (voice == -1 && seq_mode == SEQ_2 && synth_devs[dev]->alloc_voice)
490 {
491 /* Internal synthesizer (FM, GUS, etc) */
492 voice = alloc_voice(dev, chn, note);
493 }
494 if (voice == -1)
495 voice = chn;
496
497 if (seq_mode == SEQ_2 && (int) dev < num_synths)
498 {
499 /*
500 * The MIDI channel 10 is a percussive channel. Use the note
501 * number to select the proper patch (128 to 255) to play.
502 */
503
504 if (chn == 9)
505 {
506 synth_devs[dev]->set_instr(dev, voice, 128 + note);
507 synth_devs[dev]->chn_info[chn].pgm_num = 128 + note;
508 }
509 synth_devs[dev]->setup_voice(dev, voice, chn);
510 }
511 synth_devs[dev]->start_note(dev, voice, note, parm);
512 break;
513
514 case MIDI_NOTEOFF:
515 if (voice == -1)
516 voice = chn;
517 synth_devs[dev]->kill_note(dev, voice, note, parm);
518 break;
519
520 case MIDI_KEY_PRESSURE:
521 if (voice == -1)
522 voice = chn;
523 synth_devs[dev]->aftertouch(dev, voice, parm);
524 break;
525
526 default:
527 }
528 #undef dev
529 #undef cmd
530 #undef chn
531 #undef note
532 #undef parm
533 }
534
535
536 static void seq_chn_common_event(unsigned char *event_rec)
537 {
538 unsigned char dev = event_rec[1];
539 unsigned char cmd = event_rec[2];
540 unsigned char chn = event_rec[3];
541 unsigned char p1 = event_rec[4];
542
543 /* unsigned char p2 = event_rec[5]; */
544 unsigned short w14 = *(short *) &event_rec[6];
545
546 if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
547 return;
548 if (!(synth_open_mask & (1 << dev)))
549 return;
550 if (!synth_devs[dev])
551 return;
552
553 switch (cmd)
554 {
555 case MIDI_PGM_CHANGE:
556 if (seq_mode == SEQ_2)
557 {
558 synth_devs[dev]->chn_info[chn].pgm_num = p1;
559 if ((int) dev >= num_synths)
560 synth_devs[dev]->set_instr(dev, chn, p1);
561 }
562 else
563 synth_devs[dev]->set_instr(dev, chn, p1);
564
565 break;
566
567 case MIDI_CTL_CHANGE:
568 if (seq_mode == SEQ_2)
569 {
570 if (chn > 15 || p1 > 127)
571 break;
572
573 synth_devs[dev]->chn_info[chn].controllers[p1] = w14 & 0x7f;
574
575 if (p1 < 32) /* Setting MSB should clear LSB to 0 */
576 synth_devs[dev]->chn_info[chn].controllers[p1 + 32] = 0;
577
578 if ((int) dev < num_synths)
579 {
580 int val = w14 & 0x7f;
581 int i, key;
582
583 if (p1 < 64) /* Combine MSB and LSB */
584 {
585 val = ((synth_devs[dev]->
586 chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
587 | (synth_devs[dev]->
588 chn_info[chn].controllers[p1 | 32] & 0x7f);
589 p1 &= ~32;
590 }
591 /* Handle all playing notes on this channel */
592
593 key = ((int) chn << 8);
594
595 for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
596 if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
597 synth_devs[dev]->controller(dev, i, p1, val);
598 }
599 else
600 synth_devs[dev]->controller(dev, chn, p1, w14);
601 }
602 else /* Mode 1 */
603 synth_devs[dev]->controller(dev, chn, p1, w14);
604 break;
605
606 case MIDI_PITCH_BEND:
607 if (seq_mode == SEQ_2)
608 {
609 synth_devs[dev]->chn_info[chn].bender_value = w14;
610
611 if ((int) dev < num_synths)
612 {
613 /* Handle all playing notes on this channel */
614 int i, key;
615
616 key = (chn << 8);
617
618 for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
619 if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
620 synth_devs[dev]->bender(dev, i, w14);
621 }
622 else
623 synth_devs[dev]->bender(dev, chn, w14);
624 }
625 else /* MODE 1 */
626 synth_devs[dev]->bender(dev, chn, w14);
627 break;
628
629 default:
630 }
631 }
632
633 static int seq_timing_event(unsigned char *event_rec)
634 {
635 unsigned char cmd = event_rec[1];
636 unsigned int parm = *(int *) &event_rec[4];
637
638 if (seq_mode == SEQ_2)
639 {
640 int ret;
641
642 if ((ret = tmr->event(tmr_no, event_rec)) == TIMER_ARMED)
643 if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
644 wake_up(&seq_sleeper);
645 return ret;
646 }
647 switch (cmd)
648 {
649 case TMR_WAIT_REL:
650 parm += prev_event_time;
651
652 /*
653 * NOTE! No break here. Execution of TMR_WAIT_REL continues in the
654 * next case (TMR_WAIT_ABS)
655 */
656
657 case TMR_WAIT_ABS:
658 if (parm > 0)
659 {
660 long time;
661
662 time = parm;
663 prev_event_time = time;
664
665 seq_playing = 1;
666 if (softsynthp != NULL)
667 softsynthp(SSYN_REQUEST, time, 0, 0);
668 else
669 request_sound_timer(time);
670
671 if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
672 wake_up(&seq_sleeper);
673 return TIMER_ARMED;
674 }
675 break;
676
677 case TMR_START:
678 if (softsynthp != NULL)
679 {
680 softsynthp(SSYN_START, 0, 0, 0);
681 seq_time = 0;
682 }
683 else
684 seq_time = jiffies;
685 prev_input_time = 0;
686 prev_event_time = 0;
687 break;
688
689 case TMR_STOP:
690 break;
691
692 case TMR_CONTINUE:
693 break;
694
695 case TMR_TEMPO:
696 break;
697
698 case TMR_ECHO:
699 if (seq_mode == SEQ_2)
700 seq_copy_to_input(event_rec, 8);
701 else
702 {
703 parm = (parm << 8 | SEQ_ECHO);
704 seq_copy_to_input((unsigned char *) &parm, 4);
705 }
706 break;
707
708 default:
709 }
710
711 return TIMER_NOT_ARMED;
712 }
713
714 static void seq_local_event(unsigned char *event_rec)
715 {
716 unsigned char cmd = event_rec[1];
717 unsigned int parm = *((unsigned int *) &event_rec[4]);
718
719 switch (cmd)
720 {
721 case LOCL_STARTAUDIO:
722 #ifdef CONFIG_AUDIO
723 DMAbuf_start_devices(parm);
724 #endif
725 break;
726
727 default:
728 }
729 }
730
731 static void seq_sysex_message(unsigned char *event_rec)
732 {
733 int dev = event_rec[1];
734 int i, l = 0;
735 unsigned char *buf = &event_rec[2];
736
737 if ((int) dev > max_synthdev)
738 return;
739 if (!(synth_open_mask & (1 << dev)))
740 return;
741 if (!synth_devs[dev])
742 return;
743
744 l = 0;
745 for (i = 0; i < 6 && buf[i] != 0xff; i++)
746 l = i + 1;
747
748 if (!synth_devs[dev]->send_sysex)
749 return;
750 if (l > 0)
751 synth_devs[dev]->send_sysex(dev, buf, l);
752 }
753
754 static int play_event(unsigned char *q)
755 {
756 /*
757 * NOTE! This routine returns
758 * 0 = normal event played.
759 * 1 = Timer armed. Suspend playback until timer callback.
760 * 2 = MIDI output buffer full. Restore queue and suspend until timer
761 */
762 unsigned int *delay;
763
764 switch (q[0])
765 {
766 case SEQ_NOTEOFF:
767 if (synth_open_mask & (1 << 0))
768 if (synth_devs[0])
769 synth_devs[0]->kill_note(0, q[1], 255, q[3]);
770 break;
771
772 case SEQ_NOTEON:
773 if (q[4] < 128 || q[4] == 255)
774 if (synth_open_mask & (1 << 0))
775 if (synth_devs[0])
776 synth_devs[0]->start_note(0, q[1], q[2], q[3]);
777 break;
778
779 case SEQ_WAIT:
780 delay = (unsigned int *) q; /*
781 * Bytes 1 to 3 are containing the *
782 * delay in 'ticks'
783 */
784 *delay = (*delay >> 8) & 0xffffff;
785
786 if (*delay > 0)
787 {
788 long time;
789
790 seq_playing = 1;
791 time = *delay;
792 prev_event_time = time;
793
794 if (softsynthp != NULL)
795 softsynthp(SSYN_REQUEST, time, 0, 0);
796 else
797 request_sound_timer(time);
798
799 if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
800 wake_up(&seq_sleeper);
801 /*
802 * The timer is now active and will reinvoke this function
803 * after the timer expires. Return to the caller now.
804 */
805 return 1;
806 }
807 break;
808
809 case SEQ_PGMCHANGE:
810 if (synth_open_mask & (1 << 0))
811 if (synth_devs[0])
812 synth_devs[0]->set_instr(0, q[1], q[2]);
813 break;
814
815 case SEQ_SYNCTIMER: /*
816 * Reset timer
817 */
818 if (softsynthp != NULL)
819 seq_time = 0;
820 else
821 seq_time = jiffies;
822 prev_input_time = 0;
823 prev_event_time = 0;
824 if (softsynthp != NULL)
825 softsynthp(SSYN_START, 0, 0, 0);
826 break;
827
828 case SEQ_MIDIPUTC: /*
829 * Put a midi character
830 */
831 if (midi_opened[q[2]])
832 {
833 int dev;
834
835 dev = q[2];
836
837 if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
838 break;
839
840 if (!midi_devs[dev]->outputc(dev, q[1]))
841 {
842 /*
843 * Output FIFO is full. Wait one timer cycle and try again.
844 */
845
846 seq_playing = 1;
847 if (softsynthp != NULL)
848 softsynthp(SSYN_REQUEST, -1, 0, 0);
849 else
850 request_sound_timer(-1);
851 return 2;
852 }
853 else
854 midi_written[dev] = 1;
855 }
856 break;
857
858 case SEQ_ECHO:
859 seq_copy_to_input(q, 4); /*
860 * Echo back to the process
861 */
862 break;
863
864 case SEQ_PRIVATE:
865 if ((int) q[1] < max_synthdev)
866 synth_devs[q[1]]->hw_control(q[1], q);
867 break;
868
869 case SEQ_EXTENDED:
870 extended_event(q);
871 break;
872
873 case EV_CHN_VOICE:
874 seq_chn_voice_event(q);
875 break;
876
877 case EV_CHN_COMMON:
878 seq_chn_common_event(q);
879 break;
880
881 case EV_TIMING:
882 if (seq_timing_event(q) == TIMER_ARMED)
883 {
884 return 1;
885 }
886 break;
887
888 case EV_SEQ_LOCAL:
889 seq_local_event(q);
890 break;
891
892 case EV_SYSEX:
893 seq_sysex_message(q);
894 break;
895
896 default:
897 }
898 return 0;
899 }
900
901 static void seq_startplay(void)
902 {
903 unsigned long flags;
904 int this_one, action;
905
906 while (qlen > 0)
907 {
908
909 save_flags(flags);
910 cli();
911 qhead = ((this_one = qhead) + 1) % SEQ_MAX_QUEUE;
912 qlen--;
913 restore_flags(flags);
914
915 seq_playing = 1;
916
917 if ((action = play_event(&queue[this_one * EV_SZ])))
918 { /* Suspend playback. Next timer routine invokes this routine again */
919 if (action == 2)
920 {
921 qlen++;
922 qhead = this_one;
923 }
924 return;
925 }
926 }
927
928 seq_playing = 0;
929
930 if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
931 wake_up(&seq_sleeper);
932 }
933
934 static void reset_controllers(int dev, unsigned char *controller, int update_dev)
935 {
936 int i;
937 for (i = 0; i < 128; i++)
938 controller[i] = ctrl_def_values[i];
939 }
940
941 static void setup_mode2(void)
942 {
943 int dev;
944
945 max_synthdev = num_synths;
946
947 for (dev = 0; dev < num_midis; dev++)
948 {
949 if (midi_devs[dev] && midi_devs[dev]->converter != NULL)
950 {
951 synth_devs[max_synthdev++] = midi_devs[dev]->converter;
952 }
953 }
954
955 for (dev = 0; dev < max_synthdev; dev++)
956 {
957 int chn;
958
959 synth_devs[dev]->sysex_ptr = 0;
960 synth_devs[dev]->emulation = 0;
961
962 for (chn = 0; chn < 16; chn++)
963 {
964 synth_devs[dev]->chn_info[chn].pgm_num = 0;
965 reset_controllers(dev,
966 synth_devs[dev]->chn_info[chn].controllers,0);
967 synth_devs[dev]->chn_info[chn].bender_value = (1 << 7); /* Neutral */
968 synth_devs[dev]->chn_info[chn].bender_range = 200;
969 }
970 }
971 max_mididev = 0;
972 seq_mode = SEQ_2;
973 }
974
975 int sequencer_open(int dev, struct file *file)
976 {
977 int retval, mode, i;
978 int level, tmp;
979 unsigned long flags;
980
981 if (!sequencer_ok)
982 sequencer_init();
983
984 level = ((dev & 0x0f) == SND_DEV_SEQ2) ? 2 : 1;
985
986 dev = dev >> 4;
987 mode = translate_mode(file);
988
989 DEB(printk("sequencer_open(dev=%d)\n", dev));
990
991 if (!sequencer_ok)
992 {
993 /* printk("Sound card: sequencer not initialized\n");*/
994 return -ENXIO;
995 }
996 if (dev) /* Patch manager device (obsolete) */
997 return -ENXIO;
998
999 if(synth_devs[dev] == NULL)
1000 request_module("synth0");
1001
1002 if (mode == OPEN_READ)
1003 {
1004 if (!num_midis)
1005 {
1006 /*printk("Sequencer: No MIDI devices. Input not possible\n");*/
1007 sequencer_busy = 0;
1008 return -ENXIO;
1009 }
1010 }
1011 save_flags(flags);
1012 cli();
1013 if (sequencer_busy)
1014 {
1015 restore_flags(flags);
1016 return -EBUSY;
1017 }
1018 sequencer_busy = 1;
1019 obsolete_api_used = 0;
1020 restore_flags(flags);
1021
1022 max_mididev = num_midis;
1023 max_synthdev = num_synths;
1024 pre_event_timeout = MAX_SCHEDULE_TIMEOUT;
1025 seq_mode = SEQ_1;
1026
1027 if (pending_timer != -1)
1028 {
1029 tmr_no = pending_timer;
1030 pending_timer = -1;
1031 }
1032 if (tmr_no == -1) /* Not selected yet */
1033 {
1034 int i, best;
1035
1036 best = -1;
1037 for (i = 0; i < num_sound_timers; i++)
1038 if (sound_timer_devs[i] && sound_timer_devs[i]->priority > best)
1039 {
1040 tmr_no = i;
1041 best = sound_timer_devs[i]->priority;
1042 }
1043 if (tmr_no == -1) /* Should not be */
1044 tmr_no = 0;
1045 }
1046 tmr = sound_timer_devs[tmr_no];
1047
1048 if (level == 2)
1049 {
1050 if (tmr == NULL)
1051 {
1052 /*printk("sequencer: No timer for level 2\n");*/
1053 sequencer_busy = 0;
1054 return -ENXIO;
1055 }
1056 setup_mode2();
1057 }
1058 if (!max_synthdev && !max_mididev)
1059 {
1060 sequencer_busy=0;
1061 return -ENXIO;
1062 }
1063
1064 synth_open_mask = 0;
1065
1066 for (i = 0; i < max_mididev; i++)
1067 {
1068 midi_opened[i] = 0;
1069 midi_written[i] = 0;
1070 }
1071
1072 for (i = 0; i < max_synthdev; i++)
1073 {
1074 if (synth_devs[i]==NULL)
1075 continue;
1076
1077 if ((tmp = synth_devs[i]->open(i, mode)) < 0)
1078 {
1079 printk(KERN_WARNING "Sequencer: Warning! Cannot open synth device #%d (%d)\n", i, tmp);
1080 if (synth_devs[i]->midi_dev)
1081 printk(KERN_WARNING "(Maps to MIDI dev #%d)\n", synth_devs[i]->midi_dev);
1082 }
1083 else
1084 {
1085 synth_open_mask |= (1 << i);
1086 if (synth_devs[i]->midi_dev)
1087 midi_opened[synth_devs[i]->midi_dev] = 1;
1088 }
1089 }
1090
1091 if (softsynthp != NULL)
1092 seq_time = 0;
1093 else
1094 seq_time = jiffies;
1095
1096 prev_input_time = 0;
1097 prev_event_time = 0;
1098 if (softsynthp != NULL)
1099 softsynthp(SSYN_START, 0, 0, 0);
1100
1101 if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
1102 {
1103 /*
1104 * Initialize midi input devices
1105 */
1106
1107 for (i = 0; i < max_mididev; i++)
1108 if (!midi_opened[i] && midi_devs[i])
1109 {
1110 if ((retval = midi_devs[i]->open(i, mode,
1111 sequencer_midi_input, sequencer_midi_output)) >= 0)
1112 {
1113 midi_opened[i] = 1;
1114 }
1115 }
1116 }
1117 if (seq_mode == SEQ_2)
1118 tmr->open(tmr_no, seq_mode);
1119
1120 init_waitqueue_head(&seq_sleeper);
1121 init_waitqueue_head(&midi_sleeper);
1122 output_threshold = SEQ_MAX_QUEUE / 2;
1123
1124 return 0;
1125 }
1126
1127 void seq_drain_midi_queues(void)
1128 {
1129 int i, n;
1130
1131 /*
1132 * Give the Midi drivers time to drain their output queues
1133 */
1134
1135 n = 1;
1136
1137 while (!signal_pending(current) && n)
1138 {
1139 n = 0;
1140
1141 for (i = 0; i < max_mididev; i++)
1142 if (midi_opened[i] && midi_written[i])
1143 if (midi_devs[i]->buffer_status != NULL)
1144 if (midi_devs[i]->buffer_status(i))
1145 n++;
1146
1147 /*
1148 * Let's have a delay
1149 */
1150
1151 if (n)
1152 interruptible_sleep_on_timeout(&seq_sleeper,
1153 HZ/10);
1154 }
1155 }
1156
1157 void sequencer_release(int dev, struct file *file)
1158 {
1159 int i;
1160 int mode = translate_mode(file);
1161
1162 dev = dev >> 4;
1163
1164 DEB(printk("sequencer_release(dev=%d)\n", dev));
1165
1166 /*
1167 * Wait until the queue is empty (if we don't have nonblock)
1168 */
1169
1170 if (mode != OPEN_READ && !(file->f_flags & O_NONBLOCK))
1171 {
1172 while (!signal_pending(current) && qlen > 0)
1173 {
1174 seq_sync();
1175 interruptible_sleep_on_timeout(&seq_sleeper,
1176 3*HZ);
1177 /* Extra delay */
1178 }
1179 }
1180
1181 if (mode != OPEN_READ)
1182 seq_drain_midi_queues(); /*
1183 * Ensure the output queues are empty
1184 */
1185 seq_reset();
1186 if (mode != OPEN_READ)
1187 seq_drain_midi_queues(); /*
1188 * Flush the all notes off messages
1189 */
1190
1191 for (i = 0; i < max_synthdev; i++)
1192 {
1193 if (synth_open_mask & (1 << i)) /*
1194 * Actually opened
1195 */
1196 if (synth_devs[i])
1197 {
1198 synth_devs[i]->close(i);
1199
1200 if (synth_devs[i]->midi_dev)
1201 midi_opened[synth_devs[i]->midi_dev] = 0;
1202 }
1203 }
1204
1205 for (i = 0; i < max_mididev; i++)
1206 {
1207 if (midi_opened[i])
1208 midi_devs[i]->close(i);
1209 }
1210
1211 if (seq_mode == SEQ_2)
1212 tmr->close(tmr_no);
1213
1214 if (obsolete_api_used)
1215 printk(KERN_WARNING "/dev/music: Obsolete (4 byte) API was used by %s\n", current->comm);
1216 sequencer_busy = 0;
1217 }
1218
1219 static int seq_sync(void)
1220 {
1221 unsigned long flags;
1222
1223 if (qlen && !seq_playing && !signal_pending(current))
1224 seq_startplay();
1225
1226 save_flags(flags);
1227 cli();
1228 if (qlen > 0)
1229 interruptible_sleep_on_timeout(&seq_sleeper, HZ);
1230 restore_flags(flags);
1231 return qlen;
1232 }
1233
1234 static void midi_outc(int dev, unsigned char data)
1235 {
1236 /*
1237 * NOTE! Calls sleep(). Don't call this from interrupt.
1238 */
1239
1240 int n;
1241 unsigned long flags;
1242
1243 /*
1244 * This routine sends one byte to the Midi channel.
1245 * If the output FIFO is full, it waits until there
1246 * is space in the queue
1247 */
1248
1249 n = 3 * HZ; /* Timeout */
1250
1251 save_flags(flags);
1252 cli();
1253 while (n && !midi_devs[dev]->outputc(dev, data)) {
1254 interruptible_sleep_on_timeout(&seq_sleeper, HZ/25);
1255 n--;
1256 }
1257 restore_flags(flags);
1258 }
1259
1260 static void seq_reset(void)
1261 {
1262 /*
1263 * NOTE! Calls sleep(). Don't call this from interrupt.
1264 */
1265
1266 int i;
1267 int chn;
1268 unsigned long flags;
1269
1270 if (softsynthp != NULL)
1271 softsynthp(SSYN_STOP, 0, 0, 0);
1272 else
1273 sound_stop_timer();
1274
1275 seq_time = jiffies;
1276 prev_input_time = 0;
1277 prev_event_time = 0;
1278
1279 qlen = qhead = qtail = 0;
1280 iqlen = iqhead = iqtail = 0;
1281
1282 for (i = 0; i < max_synthdev; i++)
1283 if (synth_open_mask & (1 << i))
1284 if (synth_devs[i])
1285 synth_devs[i]->reset(i);
1286
1287 if (seq_mode == SEQ_2)
1288 {
1289 for (chn = 0; chn < 16; chn++)
1290 for (i = 0; i < max_synthdev; i++)
1291 if (synth_open_mask & (1 << i))
1292 if (synth_devs[i])
1293 {
1294 synth_devs[i]->controller(i, chn, 123, 0); /* All notes off */
1295 synth_devs[i]->controller(i, chn, 121, 0); /* Reset all ctl */
1296 synth_devs[i]->bender(i, chn, 1 << 13); /* Bender off */
1297 }
1298 }
1299 else /* seq_mode == SEQ_1 */
1300 {
1301 for (i = 0; i < max_mididev; i++)
1302 if (midi_written[i]) /*
1303 * Midi used. Some notes may still be playing
1304 */
1305 {
1306 /*
1307 * Sending just a ACTIVE SENSING message should be enough to stop all
1308 * playing notes. Since there are devices not recognizing the
1309 * active sensing, we have to send some all notes off messages also.
1310 */
1311 midi_outc(i, 0xfe);
1312
1313 for (chn = 0; chn < 16; chn++)
1314 {
1315 midi_outc(i, (unsigned char) (0xb0 + (chn & 0x0f))); /* control change */
1316 midi_outc(i, 0x7b); /* All notes off */
1317 midi_outc(i, 0); /* Dummy parameter */
1318 }
1319
1320 midi_devs[i]->close(i);
1321
1322 midi_written[i] = 0;
1323 midi_opened[i] = 0;
1324 }
1325 }
1326
1327 seq_playing = 0;
1328
1329 save_flags(flags);
1330 cli();
1331
1332 if (waitqueue_active(&seq_sleeper)) {
1333 /* printk( "Sequencer Warning: Unexpected sleeping process - Waking up\n"); */
1334 wake_up(&seq_sleeper);
1335 }
1336 restore_flags(flags);
1337 }
1338
1339 static void seq_panic(void)
1340 {
1341 /*
1342 * This routine is called by the application in case the user
1343 * wants to reset the system to the default state.
1344 */
1345
1346 seq_reset();
1347
1348 /*
1349 * Since some of the devices don't recognize the active sensing and
1350 * all notes off messages, we have to shut all notes manually.
1351 *
1352 * TO BE IMPLEMENTED LATER
1353 */
1354
1355 /*
1356 * Also return the controllers to their default states
1357 */
1358 }
1359
1360 int sequencer_ioctl(int dev, struct file *file, unsigned int cmd, caddr_t arg)
1361 {
1362 int midi_dev, orig_dev, val, err;
1363 int mode = translate_mode(file);
1364 struct synth_info inf;
1365 struct seq_event_rec event_rec;
1366 unsigned long flags;
1367
1368 orig_dev = dev = dev >> 4;
1369
1370 switch (cmd)
1371 {
1372 case SNDCTL_TMR_TIMEBASE:
1373 case SNDCTL_TMR_TEMPO:
1374 case SNDCTL_TMR_START:
1375 case SNDCTL_TMR_STOP:
1376 case SNDCTL_TMR_CONTINUE:
1377 case SNDCTL_TMR_METRONOME:
1378 case SNDCTL_TMR_SOURCE:
1379 if (seq_mode != SEQ_2)
1380 return -EINVAL;
1381 return tmr->ioctl(tmr_no, cmd, arg);
1382
1383 case SNDCTL_TMR_SELECT:
1384 if (seq_mode != SEQ_2)
1385 return -EINVAL;
1386 if (get_user(pending_timer, (int *)arg))
1387 return -EFAULT;
1388 if (pending_timer < 0 || pending_timer >= num_sound_timers || sound_timer_devs[pending_timer] == NULL)
1389 {
1390 pending_timer = -1;
1391 return -EINVAL;
1392 }
1393 val = pending_timer;
1394 break;
1395
1396 case SNDCTL_SEQ_PANIC:
1397 seq_panic();
1398 return -EINVAL;
1399
1400 case SNDCTL_SEQ_SYNC:
1401 if (mode == OPEN_READ)
1402 return 0;
1403 while (qlen > 0 && !signal_pending(current))
1404 seq_sync();
1405 return qlen ? -EINTR : 0;
1406
1407 case SNDCTL_SEQ_RESET:
1408 seq_reset();
1409 return 0;
1410
1411 case SNDCTL_SEQ_TESTMIDI:
1412 if (__get_user(midi_dev, (int *)arg))
1413 return -EFAULT;
1414 if (midi_dev < 0 || midi_dev >= max_mididev || !midi_devs[midi_dev])
1415 return -ENXIO;
1416
1417 if (!midi_opened[midi_dev] &&
1418 (err = midi_devs[midi_dev]->open(midi_dev, mode, sequencer_midi_input,
1419 sequencer_midi_output)) < 0)
1420 return err;
1421 midi_opened[midi_dev] = 1;
1422 return 0;
1423
1424 case SNDCTL_SEQ_GETINCOUNT:
1425 if (mode == OPEN_WRITE)
1426 return 0;
1427 val = iqlen;
1428 break;
1429
1430 case SNDCTL_SEQ_GETOUTCOUNT:
1431 if (mode == OPEN_READ)
1432 return 0;
1433 val = SEQ_MAX_QUEUE - qlen;
1434 break;
1435
1436 case SNDCTL_SEQ_GETTIME:
1437 if (seq_mode == SEQ_2)
1438 return tmr->ioctl(tmr_no, cmd, arg);
1439 if (softsynthp != NULL)
1440 val = softsynthp(SSYN_GETTIME, 0, 0, 0);
1441 else
1442 val = jiffies - seq_time;
1443 break;
1444
1445 case SNDCTL_SEQ_CTRLRATE:
1446 /*
1447 * If *arg == 0, just return the current rate
1448 */
1449 if (seq_mode == SEQ_2)
1450 return tmr->ioctl(tmr_no, cmd, arg);
1451
1452 if (get_user(val, (int *)arg))
1453 return -EFAULT;
1454 if (val != 0)
1455 return -EINVAL;
1456 val = HZ;
1457 break;
1458
1459 case SNDCTL_SEQ_RESETSAMPLES:
1460 case SNDCTL_SYNTH_REMOVESAMPLE:
1461 case SNDCTL_SYNTH_CONTROL:
1462 if (get_user(dev, (int *)arg))
1463 return -EFAULT;
1464 if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
1465 return -ENXIO;
1466 if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1467 return -EBUSY;
1468 return synth_devs[dev]->ioctl(dev, cmd, arg);
1469
1470 case SNDCTL_SEQ_NRSYNTHS:
1471 val = max_synthdev;
1472 break;
1473
1474 case SNDCTL_SEQ_NRMIDIS:
1475 val = max_mididev;
1476 break;
1477
1478 case SNDCTL_SYNTH_MEMAVL:
1479 if (get_user(dev, (int *)arg))
1480 return -EFAULT;
1481 if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
1482 return -ENXIO;
1483 if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1484 return -EBUSY;
1485 val = synth_devs[dev]->ioctl(dev, cmd, arg);
1486 break;
1487
1488 case SNDCTL_FM_4OP_ENABLE:
1489 if (get_user(dev, (int *)arg))
1490 return -EFAULT;
1491 if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
1492 return -ENXIO;
1493 if (!(synth_open_mask & (1 << dev)))
1494 return -ENXIO;
1495 synth_devs[dev]->ioctl(dev, cmd, arg);
1496 return 0;
1497
1498 case SNDCTL_SYNTH_INFO:
1499 if (get_user(dev, (int *)(&(((struct synth_info *)arg)->device))))
1500 return -EFAULT;
1501 if (dev < 0 || dev >= max_synthdev)
1502 return -ENXIO;
1503 if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1504 return -EBUSY;
1505 return synth_devs[dev]->ioctl(dev, cmd, arg);
1506
1507 /* Like SYNTH_INFO but returns ID in the name field */
1508 case SNDCTL_SYNTH_ID:
1509 if (get_user(dev, (int *)(&(((struct synth_info *)arg)->device))))
1510 return -EFAULT;
1511 if (dev < 0 || dev >= max_synthdev)
1512 return -ENXIO;
1513 if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1514 return -EBUSY;
1515 memcpy(&inf, synth_devs[dev]->info, sizeof(inf));
1516 strncpy(inf.name, synth_devs[dev]->id, sizeof(inf.name));
1517 inf.device = dev;
1518 return copy_to_user(arg, &inf, sizeof(inf))?-EFAULT:0;
1519
1520 case SNDCTL_SEQ_OUTOFBAND:
1521 if (copy_from_user(&event_rec, arg, sizeof(event_rec)))
1522 return -EFAULT;
1523 save_flags(flags);
1524 cli();
1525 play_event(event_rec.arr);
1526 restore_flags(flags);
1527 return 0;
1528
1529 case SNDCTL_MIDI_INFO:
1530 if (get_user(dev, (int *)(&(((struct midi_info *)arg)->device))))
1531 return -EFAULT;
1532 if (dev < 0 || dev >= max_mididev || !midi_devs[dev])
1533 return -ENXIO;
1534 midi_devs[dev]->info.device = dev;
1535 return copy_to_user(arg, &midi_devs[dev]->info, sizeof(struct midi_info))?-EFAULT:0;
1536
1537 case SNDCTL_SEQ_THRESHOLD:
1538 if (get_user(val, (int *)arg))
1539 return -EFAULT;
1540 if (val < 1)
1541 val = 1;
1542 if (val >= SEQ_MAX_QUEUE)
1543 val = SEQ_MAX_QUEUE - 1;
1544 output_threshold = val;
1545 return 0;
1546
1547 case SNDCTL_MIDI_PRETIME:
1548 if (get_user(val, (int *)arg))
1549 return -EFAULT;
1550 if (val < 0)
1551 val = 0;
1552 val = (HZ * val) / 10;
1553 pre_event_timeout = val;
1554 break;
1555
1556 default:
1557 if (mode == OPEN_READ)
1558 return -EIO;
1559 if (!synth_devs[0])
1560 return -ENXIO;
1561 if (!(synth_open_mask & (1 << 0)))
1562 return -ENXIO;
1563 if (!synth_devs[0]->ioctl)
1564 return -EINVAL;
1565 return synth_devs[0]->ioctl(0, cmd, arg);
1566 }
1567 return put_user(val, (int *)arg);
1568 }
1569
1570 unsigned int sequencer_poll(int dev, struct file *file, poll_table * wait)
1571 {
1572 unsigned long flags;
1573 unsigned int mask = 0;
1574
1575 dev = dev >> 4;
1576
1577 save_flags(flags);
1578 cli();
1579 /* input */
1580 poll_wait(file, &midi_sleeper, wait);
1581 if (iqlen)
1582 mask |= POLLIN | POLLRDNORM;
1583
1584 /* output */
1585 poll_wait(file, &seq_sleeper, wait);
1586 if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
1587 mask |= POLLOUT | POLLWRNORM;
1588 restore_flags(flags);
1589 return mask;
1590 }
1591
1592
1593 void sequencer_timer(unsigned long dummy)
1594 {
1595 seq_startplay();
1596 }
1597
1598 int note_to_freq(int note_num)
1599 {
1600
1601 /*
1602 * This routine converts a midi note to a frequency (multiplied by 1000)
1603 */
1604
1605 int note, octave, note_freq;
1606 static int notes[] =
1607 {
1608 261632, 277189, 293671, 311132, 329632, 349232,
1609 369998, 391998, 415306, 440000, 466162, 493880
1610 };
1611
1612 #define BASE_OCTAVE 5
1613
1614 octave = note_num / 12;
1615 note = note_num % 12;
1616
1617 note_freq = notes[note];
1618
1619 if (octave < BASE_OCTAVE)
1620 note_freq >>= (BASE_OCTAVE - octave);
1621 else if (octave > BASE_OCTAVE)
1622 note_freq <<= (octave - BASE_OCTAVE);
1623
1624 /*
1625 * note_freq >>= 1;
1626 */
1627
1628 return note_freq;
1629 }
1630
1631 unsigned long compute_finetune(unsigned long base_freq, int bend, int range,
1632 int vibrato_cents)
1633 {
1634 unsigned long amount;
1635 int negative, semitones, cents, multiplier = 1;
1636
1637 if (!bend)
1638 return base_freq;
1639 if (!range)
1640 return base_freq;
1641
1642 if (!base_freq)
1643 return base_freq;
1644
1645 if (range >= 8192)
1646 range = 8192;
1647
1648 bend = bend * range / 8192; /* Convert to cents */
1649 bend += vibrato_cents;
1650
1651 if (!bend)
1652 return base_freq;
1653
1654 negative = bend < 0 ? 1 : 0;
1655
1656 if (bend < 0)
1657 bend *= -1;
1658 if (bend > range)
1659 bend = range;
1660
1661 /*
1662 if (bend > 2399)
1663 bend = 2399;
1664 */
1665 while (bend > 2399)
1666 {
1667 multiplier *= 4;
1668 bend -= 2400;
1669 }
1670
1671 semitones = bend / 100;
1672 if (semitones > 99)
1673 semitones = 99;
1674 cents = bend % 100;
1675
1676 amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents]) / 10000;
1677
1678 if (negative)
1679 return (base_freq * 10000) / amount; /* Bend down */
1680 else
1681 return (base_freq * amount) / 10000; /* Bend up */
1682 }
1683
1684
1685 void sequencer_init(void)
1686 {
1687 /* drag in sequencer_syms.o */
1688 {
1689 extern char sequencer_syms_symbol;
1690 sequencer_syms_symbol = 0;
1691 }
1692
1693 if (sequencer_ok)
1694 return;
1695 #ifdef CONFIG_MIDI
1696 MIDIbuf_init();
1697 #endif
1698 queue = (unsigned char *)vmalloc(SEQ_MAX_QUEUE * EV_SZ);
1699 if (queue == NULL)
1700 {
1701 printk(KERN_ERR "sequencer: Can't allocate memory for sequencer output queue\n");
1702 return;
1703 }
1704 iqueue = (unsigned char *)vmalloc(SEQ_MAX_QUEUE * IEV_SZ);
1705 if (iqueue == NULL)
1706 {
1707 printk(KERN_ERR "sequencer: Can't allocate memory for sequencer input queue\n");
1708 vfree(queue);
1709 return;
1710 }
1711 sequencer_ok = 1;
1712 }
1713
1714 void sequencer_unload(void)
1715 {
1716 if(queue)
1717 {
1718 vfree(queue);
1719 queue=NULL;
1720 }
1721 if(iqueue)
1722 {
1723 vfree(iqueue);
1724 iqueue=NULL;
1725 }
1726 }
1727
1728 #endif
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux