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