This source file includes following definitions.
- sequencer_read
- sequencer_midi_output
- seq_copy_to_input
- sequencer_midi_input
- seq_input_event
- sequencer_write
- seq_queue
- extended_event
- find_voice
- alloc_voice
- seq_chn_voice_event
- seq_chn_common_event
- seq_timing_event
- seq_local_event
- seq_sysex_message
- play_event
- seq_startplay
- reset_controllers
- setup_mode2
- sequencer_open
- seq_drain_midi_queues
- sequencer_release
- seq_sync
- midi_outc
- seq_reset
- seq_panic
- sequencer_ioctl
- sequencer_select
- sequencer_timer
- note_to_freq
- compute_finetune
- sequencer_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30 #define SEQUENCER_C
31 #include "sound_config.h"
32
33 #ifdef CONFIGURE_SOUNDCARD
34
35 #ifndef EXCLUDE_SEQUENCER
36
37 #include "midi_ctrl.h"
38
39 static int sequencer_ok = 0;
40 static struct sound_timer_operations *tmr;
41 static int tmr_no = -1;
42 static int pending_timer = -1;
43
44
45
46
47
48 static int max_mididev = 0;
49 static int max_synthdev = 0;
50
51
52
53
54
55
56
57 #define SEQ_1 1
58 #define SEQ_2 2
59 static int seq_mode = SEQ_1;
60
61 static struct wait_queue *seq_sleeper = NULL;
62 static volatile struct snd_wait seq_sleep_flag =
63 {0};
64 static struct wait_queue *midi_sleeper = NULL;
65 static volatile struct snd_wait midi_sleep_flag =
66 {0};
67
68 static int midi_opened[MAX_MIDI_DEV] =
69 {0};
70 static int midi_written[MAX_MIDI_DEV] =
71 {0};
72
73 unsigned long prev_input_time = 0;
74 int prev_event_time;
75 unsigned long seq_time = 0;
76
77 #include "tuning.h"
78
79 #define EV_SZ 8
80 #define IEV_SZ 8
81 static unsigned char *queue = NULL;
82 static unsigned char *iqueue = NULL;
83
84 static volatile int qhead = 0, qtail = 0, qlen = 0;
85 static volatile int iqhead = 0, iqtail = 0, iqlen = 0;
86 static volatile int seq_playing = 0;
87 static int sequencer_busy = 0;
88 static int output_treshold;
89 static int pre_event_timeout;
90 static unsigned synth_open_mask;
91
92 static int seq_queue (unsigned char *note, char nonblock);
93 static void seq_startplay (void);
94 static int seq_sync (void);
95 static void seq_reset (void);
96 static int pmgr_present[MAX_SYNTH_DEV] =
97 {0};
98
99 #if MAX_SYNTH_DEV > 15
100 #error Too many synthesizer devices enabled.
101 #endif
102
103 int
104 sequencer_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
105 {
106 int c = count, p = 0;
107 int ev_len;
108 unsigned long flags;
109
110 dev = dev >> 4;
111
112 ev_len = seq_mode == SEQ_1 ? 4 : 8;
113
114 if (dev)
115
116
117 return pmgr_read (dev - 1, file, buf, count);
118
119 save_flags (flags);
120 cli ();
121 if (!iqlen)
122 {
123 if ((file->flags & (O_NONBLOCK) ?
124 1 : 0))
125 {
126 restore_flags (flags);
127 return -EAGAIN;
128 }
129
130
131 {
132 unsigned long tl;
133
134 if (pre_event_timeout)
135 current->timeout = tl = jiffies + (pre_event_timeout);
136 else
137 tl = 0xffffffff;
138 midi_sleep_flag.mode = WK_SLEEP;
139 interruptible_sleep_on (&midi_sleeper);
140 if (!(midi_sleep_flag.mode & WK_WAKEUP))
141 {
142 if (jiffies >= tl)
143 midi_sleep_flag.mode |= WK_TIMEOUT;
144 }
145 midi_sleep_flag.mode &= ~WK_SLEEP;
146 };
147
148 if (!iqlen)
149 {
150 restore_flags (flags);
151 return 0;
152 }
153 }
154
155 while (iqlen && c >= ev_len)
156 {
157
158 memcpy_tofs (&((buf)[p]), (char *) &iqueue[iqhead * IEV_SZ], ev_len);
159 p += ev_len;
160 c -= ev_len;
161
162 iqhead = (iqhead + 1) % SEQ_MAX_QUEUE;
163 iqlen--;
164 }
165 restore_flags (flags);
166
167 return count - c;
168 }
169
170 static void
171 sequencer_midi_output (int dev)
172 {
173
174
175
176 }
177
178 void
179 seq_copy_to_input (unsigned char *event, int len)
180 {
181 unsigned long flags;
182
183
184
185
186
187 if (len != 4 && len != 8)
188 return;
189 if ((seq_mode == SEQ_1) != (len == 4))
190 return;
191
192 if (iqlen >= (SEQ_MAX_QUEUE - 1))
193 return;
194
195 save_flags (flags);
196 cli ();
197 memcpy (&iqueue[iqtail * IEV_SZ], event, len);
198 iqlen++;
199 iqtail = (iqtail + 1) % SEQ_MAX_QUEUE;
200
201 if ((midi_sleep_flag.mode & WK_SLEEP))
202 {
203 {
204 midi_sleep_flag.mode = WK_WAKEUP;
205 wake_up (&midi_sleeper);
206 };
207 }
208 restore_flags (flags);
209 }
210
211 static void
212 sequencer_midi_input (int dev, unsigned char data)
213 {
214 unsigned int tstamp;
215 unsigned char event[4];
216
217 if (data == 0xfe)
218 return;
219
220 tstamp = jiffies - seq_time;
221 if (tstamp != prev_input_time)
222 {
223 tstamp = (tstamp << 8) | SEQ_WAIT;
224
225 seq_copy_to_input ((unsigned char *) &tstamp, 4);
226 prev_input_time = tstamp;
227 }
228
229 event[0] = SEQ_MIDIPUTC;
230 event[1] = data;
231 event[2] = dev;
232 event[3] = 0;
233
234 seq_copy_to_input (event, 4);
235 }
236
237 void
238 seq_input_event (unsigned char *event, int len)
239 {
240 unsigned long this_time;
241
242 if (seq_mode == SEQ_2)
243 this_time = tmr->get_time (tmr_no);
244 else
245 this_time = jiffies - seq_time;
246
247 if (this_time != prev_input_time)
248 {
249 unsigned char tmp_event[8];
250
251 tmp_event[0] = EV_TIMING;
252 tmp_event[1] = TMR_WAIT_ABS;
253 tmp_event[2] = 0;
254 tmp_event[3] = 0;
255 *(unsigned long *) &tmp_event[4] = this_time;
256
257 seq_copy_to_input (tmp_event, 8);
258 prev_input_time = this_time;
259 }
260
261 seq_copy_to_input (event, len);
262 }
263
264 int
265 sequencer_write (int dev, struct fileinfo *file, const snd_rw_buf * buf, int count)
266 {
267 unsigned char event[EV_SZ], ev_code;
268 int p = 0, c, ev_size;
269 int err;
270 int mode = file->mode & O_ACCMODE;
271
272 dev = dev >> 4;
273
274 DEB (printk ("sequencer_write(dev=%d, count=%d)\n", dev, count));
275
276 if (mode == OPEN_READ)
277 return -EIO;
278
279 if (dev)
280
281
282 return pmgr_write (dev - 1, file, buf, count);
283
284 c = count;
285
286 while (c >= 4)
287 {
288 memcpy_fromfs ((char *) event, &((buf)[p]), 4);
289 ev_code = event[0];
290
291 if (ev_code == SEQ_FULLSIZE)
292 {
293 int err;
294
295 dev = *(unsigned short *) &event[2];
296 if (dev < 0 || dev >= max_synthdev)
297 return -ENXIO;
298
299 if (!(synth_open_mask & (1 << dev)))
300 return -ENXIO;
301
302 err = synth_devs[dev]->load_patch (dev, *(short *) &event[0], buf, p + 4, c, 0);
303 if (err < 0)
304 return err;
305
306 return err;
307 }
308
309 if (ev_code >= 128)
310 {
311 if (seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED)
312 {
313 printk ("Sequencer: Invalid level 2 event %x\n", ev_code);
314 return -EINVAL;
315 }
316
317 ev_size = 8;
318
319 if (c < ev_size)
320 {
321 if (!seq_playing)
322 seq_startplay ();
323 return count - c;
324 }
325
326 memcpy_fromfs ((char *) &event[4], &((buf)[p + 4]), 4);
327
328 }
329 else
330 {
331 if (seq_mode == SEQ_2)
332 {
333 printk ("Sequencer: 4 byte event in level 2 mode\n");
334 return -EINVAL;
335 }
336 ev_size = 4;
337 }
338
339 if (event[0] == SEQ_MIDIPUTC)
340 {
341
342 if (!midi_opened[event[2]])
343 {
344 int mode;
345 int dev = event[2];
346
347 if (dev >= max_mididev)
348 {
349 printk ("Sequencer Error: Nonexistent MIDI device %d\n", dev);
350 return -ENXIO;
351 }
352
353 mode = file->mode & O_ACCMODE;
354
355 if ((err = midi_devs[dev]->open (dev, mode,
356 sequencer_midi_input, sequencer_midi_output)) < 0)
357 {
358 seq_reset ();
359 printk ("Sequencer Error: Unable to open Midi #%d\n", dev);
360 return err;
361 }
362
363 midi_opened[dev] = 1;
364 }
365
366 }
367
368 if (!seq_queue (event, (file->flags & (O_NONBLOCK) ?
369 1 : 0)))
370 {
371 int processed = count - c;
372
373 if (!seq_playing)
374 seq_startplay ();
375
376 if (!processed && (file->flags & (O_NONBLOCK) ?
377 1 : 0))
378 return -EAGAIN;
379 else
380 return processed;
381 }
382
383 p += ev_size;
384 c -= ev_size;
385 }
386
387 if (!seq_playing)
388 seq_startplay ();
389
390 return count;
391
392
393 }
394
395 static int
396 seq_queue (unsigned char *note, char nonblock)
397 {
398
399
400
401
402
403 if (qlen >= SEQ_MAX_QUEUE)
404 if (!seq_playing)
405 seq_startplay ();
406
407
408
409 if (!nonblock && qlen >= SEQ_MAX_QUEUE && !(seq_sleep_flag.mode & WK_SLEEP))
410 {
411
412
413
414
415 {
416 unsigned long tl;
417
418 if (0)
419 current->timeout = tl = jiffies + (0);
420 else
421 tl = 0xffffffff;
422 seq_sleep_flag.mode = WK_SLEEP;
423 interruptible_sleep_on (&seq_sleeper);
424 if (!(seq_sleep_flag.mode & WK_WAKEUP))
425 {
426 if (jiffies >= tl)
427 seq_sleep_flag.mode |= WK_TIMEOUT;
428 }
429 seq_sleep_flag.mode &= ~WK_SLEEP;
430 };
431 }
432
433 if (qlen >= SEQ_MAX_QUEUE)
434 {
435 return 0;
436
437
438 }
439 memcpy (&queue[qtail * EV_SZ], note, EV_SZ);
440
441 qtail = (qtail + 1) % SEQ_MAX_QUEUE;
442 qlen++;
443
444 return 1;
445 }
446
447 static int
448 extended_event (unsigned char *q)
449 {
450 int dev = q[2];
451
452 if (dev < 0 || dev >= max_synthdev)
453 return -ENXIO;
454
455 if (!(synth_open_mask & (1 << dev)))
456 return -ENXIO;
457
458 switch (q[1])
459 {
460 case SEQ_NOTEOFF:
461 synth_devs[dev]->kill_note (dev, q[3], q[4], q[5]);
462 break;
463
464 case SEQ_NOTEON:
465 if (q[4] > 127 && q[4] != 255)
466 return 0;
467
468 synth_devs[dev]->start_note (dev, q[3], q[4], q[5]);
469 break;
470
471 case SEQ_PGMCHANGE:
472 synth_devs[dev]->set_instr (dev, q[3], q[4]);
473 break;
474
475 case SEQ_AFTERTOUCH:
476 synth_devs[dev]->aftertouch (dev, q[3], q[4]);
477 break;
478
479 case SEQ_BALANCE:
480 synth_devs[dev]->panning (dev, q[3], (char) q[4]);
481 break;
482
483 case SEQ_CONTROLLER:
484 synth_devs[dev]->controller (dev, q[3], q[4], *(short *) &q[5]);
485 break;
486
487 case SEQ_VOLMODE:
488 if (synth_devs[dev]->volume_method != NULL)
489 synth_devs[dev]->volume_method (dev, q[3]);
490 break;
491
492 default:
493 return -EINVAL;
494 }
495
496 return 0;
497 }
498
499 static int
500 find_voice (int dev, int chn, int note)
501 {
502 unsigned short key;
503 int i;
504
505 key = (chn << 8) | (note + 1);
506
507 for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
508 if (synth_devs[dev]->alloc.map[i] == key)
509 return i;
510
511 return -1;
512 }
513
514 static int
515 alloc_voice (int dev, int chn, int note)
516 {
517 unsigned short key;
518 int voice;
519
520 key = (chn << 8) | (note + 1);
521
522 voice = synth_devs[dev]->alloc_voice (dev, chn, note,
523 &synth_devs[dev]->alloc);
524 synth_devs[dev]->alloc.map[voice] = key;
525 synth_devs[dev]->alloc.alloc_times[voice] =
526 synth_devs[dev]->alloc.timestamp++;
527 return voice;
528 }
529
530 static void
531 seq_chn_voice_event (unsigned char *event)
532 {
533 unsigned char dev = event[1];
534 unsigned char cmd = event[2];
535 unsigned char chn = event[3];
536 unsigned char note = event[4];
537 unsigned char parm = event[5];
538 int voice = -1;
539
540 if ((int) dev > max_synthdev)
541 return;
542 if (!(synth_open_mask & (1 << dev)))
543 return;
544 if (!synth_devs[dev])
545 return;
546
547 if (seq_mode == SEQ_2)
548 {
549 if (synth_devs[dev]->alloc_voice)
550 voice = find_voice (dev, chn, note);
551
552 if (cmd == MIDI_NOTEON && parm == 0)
553 {
554 cmd = MIDI_NOTEOFF;
555 parm = 64;
556 }
557 }
558
559 switch (cmd)
560 {
561 case MIDI_NOTEON:
562 if (note > 127 && note != 255)
563 return;
564
565 if (voice == -1 && seq_mode == SEQ_2 && synth_devs[dev]->alloc_voice)
566 {
567 voice = alloc_voice (dev, chn, note);
568 }
569
570 if (voice == -1)
571 voice = chn;
572
573 if (seq_mode == SEQ_2 && (int) dev < num_synths)
574 {
575
576
577
578
579
580 if (chn == 9)
581 {
582 synth_devs[dev]->set_instr (dev, voice, 128 + note);
583 note = 60;
584
585 }
586 }
587
588 if (seq_mode == SEQ_2)
589 {
590 synth_devs[dev]->setup_voice (dev, voice, chn);
591 }
592
593 synth_devs[dev]->start_note (dev, voice, note, parm);
594 break;
595
596 case MIDI_NOTEOFF:
597 if (voice == -1)
598 voice = chn;
599 synth_devs[dev]->kill_note (dev, voice, note, parm);
600 break;
601
602 case MIDI_KEY_PRESSURE:
603 if (voice == -1)
604 voice = chn;
605 synth_devs[dev]->aftertouch (dev, voice, parm);
606 break;
607
608 default:;
609 }
610 }
611
612 static void
613 seq_chn_common_event (unsigned char *event)
614 {
615 unsigned char dev = event[1];
616 unsigned char cmd = event[2];
617 unsigned char chn = event[3];
618 unsigned char p1 = event[4];
619
620
621 unsigned short w14 = *(short *) &event[6];
622
623 if ((int) dev > max_synthdev)
624 return;
625 if (!(synth_open_mask & (1 << dev)))
626 return;
627 if (!synth_devs[dev])
628 return;
629
630 switch (cmd)
631 {
632 case MIDI_PGM_CHANGE:
633 if (seq_mode == SEQ_2)
634 {
635 synth_devs[dev]->chn_info[chn].pgm_num = p1;
636 if ((int) dev >= num_synths)
637 synth_devs[dev]->set_instr (dev, chn, p1);
638 }
639 else
640 synth_devs[dev]->set_instr (dev, chn, p1);
641
642 break;
643
644 case MIDI_CTL_CHANGE:
645 if (seq_mode == SEQ_2)
646 {
647 if (chn > 15 || p1 > 127)
648 break;
649
650 synth_devs[dev]->chn_info[chn].controllers[p1] = w14 & 0x7f;
651
652 if (p1 < 32)
653 synth_devs[dev]->chn_info[chn].controllers[p1 + 32] = 0;
654
655 if ((int) dev < num_synths)
656 {
657 int val = w14 & 0x7f;
658 int i, key;
659
660 if (p1 < 64)
661 {
662 val = ((synth_devs[dev]->
663 chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
664 | (synth_devs[dev]->
665 chn_info[chn].controllers[p1 | 32] & 0x7f);
666 p1 &= ~32;
667 }
668
669
670
671 key = ((int) chn << 8);
672
673 for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
674 if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
675 synth_devs[dev]->controller (dev, i, p1, val);
676 }
677 else
678 synth_devs[dev]->controller (dev, chn, p1, w14);
679 }
680 else
681 synth_devs[dev]->controller (dev, chn, p1, w14);
682 break;
683
684 case MIDI_PITCH_BEND:
685 if (seq_mode == SEQ_2)
686 {
687 synth_devs[dev]->chn_info[chn].bender_value = w14;
688
689 if ((int) dev < num_synths)
690 {
691 int i, key;
692
693 key = (chn << 8);
694
695 for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
696 if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
697 synth_devs[dev]->bender (dev, i, w14);
698 }
699 else
700 synth_devs[dev]->bender (dev, chn, w14);
701 }
702 else
703 synth_devs[dev]->bender (dev, chn, w14);
704 break;
705
706 default:;
707 }
708 }
709
710 static int
711 seq_timing_event (unsigned char *event)
712 {
713 unsigned char cmd = event[1];
714 unsigned int parm = *(int *) &event[4];
715
716 if (seq_mode == SEQ_2)
717 {
718 int ret;
719
720 if ((ret = tmr->event (tmr_no, event)) == TIMER_ARMED)
721 {
722 if ((SEQ_MAX_QUEUE - qlen) >= output_treshold)
723 {
724 unsigned long flags;
725
726 save_flags (flags);
727 cli ();
728 if ((seq_sleep_flag.mode & WK_SLEEP))
729 {
730 {
731 seq_sleep_flag.mode = WK_WAKEUP;
732 wake_up (&seq_sleeper);
733 };
734 }
735 restore_flags (flags);
736 }
737 }
738 return ret;
739 }
740
741 switch (cmd)
742 {
743 case TMR_WAIT_REL:
744 parm += prev_event_time;
745
746
747
748
749
750
751 case TMR_WAIT_ABS:
752 if (parm > 0)
753 {
754 long time;
755
756 seq_playing = 1;
757 time = parm;
758 prev_event_time = time;
759
760 request_sound_timer (time);
761
762 if ((SEQ_MAX_QUEUE - qlen) >= output_treshold)
763 {
764 unsigned long flags;
765
766 save_flags (flags);
767 cli ();
768 if ((seq_sleep_flag.mode & WK_SLEEP))
769 {
770 {
771 seq_sleep_flag.mode = WK_WAKEUP;
772 wake_up (&seq_sleeper);
773 };
774 }
775 restore_flags (flags);
776 }
777
778 return TIMER_ARMED;
779 }
780 break;
781
782 case TMR_START:
783 seq_time = jiffies;
784 prev_input_time = 0;
785 prev_event_time = 0;
786 break;
787
788 case TMR_STOP:
789 break;
790
791 case TMR_CONTINUE:
792 break;
793
794 case TMR_TEMPO:
795 break;
796
797 case TMR_ECHO:
798 if (seq_mode == SEQ_2)
799 seq_copy_to_input (event, 8);
800 else
801 {
802 parm = (parm << 8 | SEQ_ECHO);
803 seq_copy_to_input ((unsigned char *) &parm, 4);
804 }
805 break;
806
807 default:;
808 }
809
810 return TIMER_NOT_ARMED;
811 }
812
813 static void
814 seq_local_event (unsigned char *event)
815 {
816 unsigned char cmd = event[1];
817 unsigned int parm = *((unsigned int *) &event[4]);
818
819 switch (cmd)
820 {
821 case LOCL_STARTAUDIO:
822 #ifndef EXCLUDE_AUDIO
823 DMAbuf_start_devices (parm);
824 #endif
825 break;
826
827 default:;
828 }
829 }
830
831 static void
832 seq_sysex_message (unsigned char *event)
833 {
834 int dev = event[1];
835 int i, l = 0;
836 unsigned char *buf = &event[2];
837
838 if ((int) dev > max_synthdev)
839 return;
840 if (!(synth_open_mask & (1 << dev)))
841 return;
842 if (!synth_devs[dev])
843 return;
844 if (!synth_devs[dev]->send_sysex)
845 return;
846
847 l = 0;
848 for (i = 0; i < 6 && buf[i] != 0xff; i++)
849 l = i + 1;
850
851 if (l > 0)
852 synth_devs[dev]->send_sysex (dev, buf, l);
853 }
854
855 static int
856 play_event (unsigned char *q)
857 {
858
859
860
861
862
863
864 unsigned long *delay;
865
866 switch (q[0])
867 {
868 case SEQ_NOTEOFF:
869 if (synth_open_mask & (1 << 0))
870 if (synth_devs[0])
871 synth_devs[0]->kill_note (0, q[1], 255, q[3]);
872 break;
873
874 case SEQ_NOTEON:
875 if (q[4] < 128 || q[4] == 255)
876 if (synth_open_mask & (1 << 0))
877 if (synth_devs[0])
878 synth_devs[0]->start_note (0, q[1], q[2], q[3]);
879 break;
880
881 case SEQ_WAIT:
882 delay = (unsigned long *) q;
883
884
885
886 *delay = (*delay >> 8) & 0xffffff;
887
888 if (*delay > 0)
889 {
890 long time;
891
892 seq_playing = 1;
893 time = *delay;
894 prev_event_time = time;
895
896 request_sound_timer (time);
897
898 if ((SEQ_MAX_QUEUE - qlen) >= output_treshold)
899 {
900 unsigned long flags;
901
902 save_flags (flags);
903 cli ();
904 if ((seq_sleep_flag.mode & WK_SLEEP))
905 {
906 {
907 seq_sleep_flag.mode = WK_WAKEUP;
908 wake_up (&seq_sleeper);
909 };
910 }
911 restore_flags (flags);
912 }
913
914
915
916
917 return 1;
918 }
919 break;
920
921 case SEQ_PGMCHANGE:
922 if (synth_open_mask & (1 << 0))
923 if (synth_devs[0])
924 synth_devs[0]->set_instr (0, q[1], q[2]);
925 break;
926
927 case SEQ_SYNCTIMER:
928
929
930 seq_time = jiffies;
931 prev_input_time = 0;
932 prev_event_time = 0;
933 break;
934
935 case SEQ_MIDIPUTC:
936
937
938 if (midi_opened[q[2]])
939 {
940 int dev;
941
942 dev = q[2];
943
944 if (!midi_devs[dev]->putc (dev, q[1]))
945 {
946
947
948
949
950 seq_playing = 1;
951 request_sound_timer (-1);
952 return 2;
953 }
954 else
955 midi_written[dev] = 1;
956 }
957 break;
958
959 case SEQ_ECHO:
960 seq_copy_to_input (q, 4);
961
962
963 break;
964
965 case SEQ_PRIVATE:
966 if ((int) q[1] < max_synthdev)
967 synth_devs[q[1]]->hw_control (q[1], q);
968 break;
969
970 case SEQ_EXTENDED:
971 extended_event (q);
972 break;
973
974 case EV_CHN_VOICE:
975 seq_chn_voice_event (q);
976 break;
977
978 case EV_CHN_COMMON:
979 seq_chn_common_event (q);
980 break;
981
982 case EV_TIMING:
983 if (seq_timing_event (q) == TIMER_ARMED)
984 {
985 return 1;
986 }
987 break;
988
989 case EV_SEQ_LOCAL:
990 seq_local_event (q);
991 break;
992
993 case EV_SYSEX:
994 seq_sysex_message (q);
995 break;
996
997 default:;
998 }
999
1000 return 0;
1001 }
1002
1003 static void
1004 seq_startplay (void)
1005 {
1006 unsigned long flags;
1007 int this_one, action;
1008
1009 while (qlen > 0)
1010 {
1011
1012 save_flags (flags);
1013 cli ();
1014 qhead = ((this_one = qhead) + 1) % SEQ_MAX_QUEUE;
1015 qlen--;
1016 restore_flags (flags);
1017
1018 seq_playing = 1;
1019
1020 if ((action = play_event (&queue[this_one * EV_SZ])))
1021 {
1022 if (action == 2)
1023 {
1024 qlen++;
1025 qhead = this_one;
1026 }
1027 return;
1028 }
1029
1030 }
1031
1032 seq_playing = 0;
1033
1034 if ((SEQ_MAX_QUEUE - qlen) >= output_treshold)
1035 {
1036 unsigned long flags;
1037
1038 save_flags (flags);
1039 cli ();
1040 if ((seq_sleep_flag.mode & WK_SLEEP))
1041 {
1042 {
1043 seq_sleep_flag.mode = WK_WAKEUP;
1044 wake_up (&seq_sleeper);
1045 };
1046 }
1047 restore_flags (flags);
1048 }
1049 }
1050
1051 static void
1052 reset_controllers (int dev, unsigned char *controller, int update_dev)
1053 {
1054
1055 int i;
1056
1057 for (i = 0; i < 128; i++)
1058 controller[i] = ctrl_def_values[i];
1059 }
1060
1061 static void
1062 setup_mode2 (void)
1063 {
1064 int dev;
1065
1066 max_synthdev = num_synths;
1067
1068 for (dev = 0; dev < num_midis; dev++)
1069 if (midi_devs[dev]->converter != NULL)
1070 {
1071 synth_devs[max_synthdev++] =
1072 midi_devs[dev]->converter;
1073 }
1074
1075 for (dev = 0; dev < max_synthdev; dev++)
1076 {
1077 int chn;
1078
1079 for (chn = 0; chn < 16; chn++)
1080 {
1081 synth_devs[dev]->chn_info[chn].pgm_num = 0;
1082 reset_controllers (dev,
1083 synth_devs[dev]->chn_info[chn].controllers,
1084 0);
1085 synth_devs[dev]->chn_info[chn].bender_value = (1 << 7);
1086 }
1087 }
1088
1089 max_mididev = 0;
1090 seq_mode = SEQ_2;
1091 }
1092
1093 int
1094 sequencer_open (int dev, struct fileinfo *file)
1095 {
1096 int retval, mode, i;
1097 int level, tmp;
1098
1099 level = ((dev & 0x0f) == SND_DEV_SEQ2) ? 2 : 1;
1100
1101 dev = dev >> 4;
1102 mode = file->mode & O_ACCMODE;
1103
1104 DEB (printk ("sequencer_open(dev=%d)\n", dev));
1105
1106 if (!sequencer_ok)
1107 {
1108 printk ("Soundcard: Sequencer not initialized\n");
1109 return -ENXIO;
1110 }
1111
1112 if (dev)
1113
1114
1115 {
1116 int err;
1117
1118 printk ("Patch manager interface is currently broken. Sorry\n");
1119 return -ENXIO;
1120
1121 dev--;
1122
1123 if (dev >= MAX_SYNTH_DEV)
1124 return -ENXIO;
1125 if (pmgr_present[dev])
1126 return -EBUSY;
1127 if ((err = pmgr_open (dev)) < 0)
1128 return err;
1129
1130
1131
1132 pmgr_present[dev] = 1;
1133 return err;
1134 }
1135
1136 if (sequencer_busy)
1137 {
1138 printk ("Sequencer busy\n");
1139 return -EBUSY;
1140 }
1141
1142 max_mididev = num_midis;
1143 max_synthdev = num_synths;
1144 pre_event_timeout = 0;
1145 seq_mode = SEQ_1;
1146
1147 if (pending_timer != -1)
1148 {
1149 tmr_no = pending_timer;
1150 pending_timer = -1;
1151 }
1152
1153 if (tmr_no == -1)
1154 {
1155 int i, best;
1156
1157 best = -1;
1158 for (i = 0; i < num_sound_timers; i++)
1159 if (sound_timer_devs[i]->priority > best)
1160 {
1161 tmr_no = i;
1162 best = sound_timer_devs[i]->priority;
1163 }
1164
1165 if (tmr_no == -1)
1166 tmr_no = 0;
1167 }
1168
1169 tmr = sound_timer_devs[tmr_no];
1170
1171 if (level == 2)
1172 {
1173 if (tmr == NULL)
1174 {
1175 printk ("sequencer: No timer for level 2\n");
1176 return -ENXIO;
1177 }
1178 setup_mode2 ();
1179 }
1180
1181 if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
1182 if (!max_mididev)
1183 {
1184 printk ("Sequencer: No Midi devices. Input not possible\n");
1185 return -ENXIO;
1186 }
1187
1188 if (!max_synthdev && !max_mididev)
1189 return -ENXIO;
1190
1191 synth_open_mask = 0;
1192
1193 for (i = 0; i < max_mididev; i++)
1194 {
1195 midi_opened[i] = 0;
1196 midi_written[i] = 0;
1197 }
1198
1199
1200
1201
1202 for (i = 0; i < max_synthdev; i++)
1203
1204
1205 if ((tmp = synth_devs[i]->open (i, mode)) < 0)
1206 {
1207 printk ("Sequencer: Warning! Cannot open synth device #%d (%d)\n", i, tmp);
1208 if (synth_devs[i]->midi_dev)
1209 printk ("(Maps to MIDI dev #%d)\n", synth_devs[i]->midi_dev);
1210 }
1211 else
1212 {
1213 synth_open_mask |= (1 << i);
1214 if (synth_devs[i]->midi_dev)
1215
1216
1217 midi_opened[synth_devs[i]->midi_dev] = 1;
1218 }
1219
1220 seq_time = jiffies;
1221 prev_input_time = 0;
1222 prev_event_time = 0;
1223
1224 if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
1225 {
1226
1227
1228 for (i = 0; i < max_mididev; i++)
1229 if (!midi_opened[i])
1230 {
1231 if ((retval = midi_devs[i]->open (i, mode,
1232 sequencer_midi_input, sequencer_midi_output)) >= 0)
1233 midi_opened[i] = 1;
1234 }
1235 }
1236
1237 if (seq_mode == SEQ_2)
1238 {
1239 tmr->open (tmr_no, seq_mode);
1240 }
1241
1242 sequencer_busy = 1;
1243 seq_sleep_flag.mode = WK_NONE;
1244 midi_sleep_flag.mode = WK_NONE;
1245 output_treshold = SEQ_MAX_QUEUE / 2;
1246
1247 for (i = 0; i < num_synths; i++)
1248 if (pmgr_present[i])
1249 pmgr_inform (i, PM_E_OPENED, 0, 0, 0, 0);
1250
1251 return 0;
1252 }
1253
1254 void
1255 seq_drain_midi_queues (void)
1256 {
1257 int i, n;
1258
1259
1260
1261
1262
1263 n = 1;
1264
1265 while (!(current->signal & ~current->blocked) && n)
1266 {
1267 n = 0;
1268
1269 for (i = 0; i < max_mididev; i++)
1270 if (midi_opened[i] && midi_written[i])
1271 if (midi_devs[i]->buffer_status != NULL)
1272 if (midi_devs[i]->buffer_status (i))
1273 n++;
1274
1275
1276
1277
1278 if (n)
1279 {
1280
1281 {
1282 unsigned long tl;
1283
1284 if (HZ / 10)
1285 current->timeout = tl = jiffies + (HZ / 10);
1286 else
1287 tl = 0xffffffff;
1288 seq_sleep_flag.mode = WK_SLEEP;
1289 interruptible_sleep_on (&seq_sleeper);
1290 if (!(seq_sleep_flag.mode & WK_WAKEUP))
1291 {
1292 if (jiffies >= tl)
1293 seq_sleep_flag.mode |= WK_TIMEOUT;
1294 }
1295 seq_sleep_flag.mode &= ~WK_SLEEP;
1296 };
1297 }
1298 }
1299 }
1300
1301 void
1302 sequencer_release (int dev, struct fileinfo *file)
1303 {
1304 int i;
1305 int mode = file->mode & O_ACCMODE;
1306
1307 dev = dev >> 4;
1308
1309 DEB (printk ("sequencer_release(dev=%d)\n", dev));
1310
1311 if (dev)
1312
1313
1314 {
1315 dev--;
1316 pmgr_release (dev);
1317 pmgr_present[dev] = 0;
1318 return;
1319 }
1320
1321
1322
1323
1324
1325 if (mode != OPEN_READ && !(file->flags & (O_NONBLOCK) ?
1326 1 : 0))
1327 while (!(current->signal & ~current->blocked) && qlen)
1328 {
1329 seq_sync ();
1330 }
1331
1332 if (mode != OPEN_READ)
1333 seq_drain_midi_queues ();
1334
1335
1336 seq_reset ();
1337 if (mode != OPEN_READ)
1338 seq_drain_midi_queues ();
1339
1340
1341
1342 for (i = 0; i < max_synthdev; i++)
1343 if (synth_open_mask & (1 << i))
1344
1345
1346 if (synth_devs[i])
1347 {
1348 synth_devs[i]->close (i);
1349
1350 if (synth_devs[i]->midi_dev)
1351 midi_opened[synth_devs[i]->midi_dev] = 0;
1352 }
1353
1354 for (i = 0; i < num_synths; i++)
1355 if (pmgr_present[i])
1356 pmgr_inform (i, PM_E_CLOSED, 0, 0, 0, 0);
1357
1358 for (i = 0; i < max_mididev; i++)
1359 if (midi_opened[i])
1360 midi_devs[i]->close (i);
1361
1362 if (seq_mode == SEQ_2)
1363 tmr->close (tmr_no);
1364
1365 sequencer_busy = 0;
1366 }
1367
1368 static int
1369 seq_sync (void)
1370 {
1371 unsigned long flags;
1372
1373 if (qlen && !seq_playing && !(current->signal & ~current->blocked))
1374 seq_startplay ();
1375
1376 save_flags (flags);
1377 cli ();
1378 if (qlen && !(seq_sleep_flag.mode & WK_SLEEP))
1379 {
1380
1381 {
1382 unsigned long tl;
1383
1384 if (0)
1385 current->timeout = tl = jiffies + (0);
1386 else
1387 tl = 0xffffffff;
1388 seq_sleep_flag.mode = WK_SLEEP;
1389 interruptible_sleep_on (&seq_sleeper);
1390 if (!(seq_sleep_flag.mode & WK_WAKEUP))
1391 {
1392 if (jiffies >= tl)
1393 seq_sleep_flag.mode |= WK_TIMEOUT;
1394 }
1395 seq_sleep_flag.mode &= ~WK_SLEEP;
1396 };
1397 }
1398 restore_flags (flags);
1399
1400 return qlen;
1401 }
1402
1403 static void
1404 midi_outc (int dev, unsigned char data)
1405 {
1406
1407
1408
1409
1410 int n;
1411 unsigned long flags;
1412
1413
1414
1415
1416
1417
1418
1419 n = 3 * HZ;
1420
1421 save_flags (flags);
1422 cli ();
1423 while (n && !midi_devs[dev]->putc (dev, data))
1424 {
1425
1426 {
1427 unsigned long tl;
1428
1429 if (4)
1430 current->timeout = tl = jiffies + (4);
1431 else
1432 tl = 0xffffffff;
1433 seq_sleep_flag.mode = WK_SLEEP;
1434 interruptible_sleep_on (&seq_sleeper);
1435 if (!(seq_sleep_flag.mode & WK_WAKEUP))
1436 {
1437 if (jiffies >= tl)
1438 seq_sleep_flag.mode |= WK_TIMEOUT;
1439 }
1440 seq_sleep_flag.mode &= ~WK_SLEEP;
1441 };
1442 n--;
1443 }
1444 restore_flags (flags);
1445 }
1446
1447 static void
1448 seq_reset (void)
1449 {
1450
1451
1452
1453
1454 int i;
1455 int chn;
1456 unsigned long flags;
1457
1458 sound_stop_timer ();
1459 seq_time = jiffies;
1460 prev_input_time = 0;
1461 prev_event_time = 0;
1462
1463 qlen = qhead = qtail = 0;
1464 iqlen = iqhead = iqtail = 0;
1465
1466 for (i = 0; i < max_synthdev; i++)
1467 if (synth_open_mask & (1 << i))
1468 if (synth_devs[i])
1469 synth_devs[i]->reset (i);
1470
1471 if (seq_mode == SEQ_2)
1472 {
1473
1474 for (chn = 0; chn < 16; chn++)
1475 for (i = 0; i < max_synthdev; i++)
1476 if (synth_open_mask & (1 << i))
1477 if (synth_devs[i])
1478 {
1479 synth_devs[i]->controller (i, chn, 123, 0);
1480 synth_devs[i]->controller (i, chn, 121, 0);
1481 synth_devs[i]->bender (i, chn, 1 << 13);
1482 }
1483
1484 }
1485 else
1486
1487 {
1488 for (i = 0; i < max_mididev; i++)
1489 if (midi_written[i])
1490
1491
1492 {
1493
1494
1495
1496
1497
1498 midi_outc (i, 0xfe);
1499
1500 for (chn = 0; chn < 16; chn++)
1501 {
1502 midi_outc (i,
1503 (unsigned char) (0xb0 + (chn & 0x0f)));
1504 midi_outc (i, 0x7b);
1505 midi_outc (i, 0);
1506 }
1507
1508 midi_devs[i]->close (i);
1509
1510 midi_written[i] = 0;
1511 midi_opened[i] = 0;
1512 }
1513 }
1514
1515 seq_playing = 0;
1516
1517 save_flags (flags);
1518 cli ();
1519 if ((seq_sleep_flag.mode & WK_SLEEP))
1520 {
1521
1522 {
1523 seq_sleep_flag.mode = WK_WAKEUP;
1524 wake_up (&seq_sleeper);
1525 };
1526 }
1527 restore_flags (flags);
1528
1529 }
1530
1531 static void
1532 seq_panic (void)
1533 {
1534
1535
1536
1537
1538
1539 seq_reset ();
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551 }
1552
1553 int
1554 sequencer_ioctl (int dev, struct fileinfo *file,
1555 unsigned int cmd, ioctl_arg arg)
1556 {
1557 int midi_dev, orig_dev;
1558 int mode = file->mode & O_ACCMODE;
1559
1560 orig_dev = dev = dev >> 4;
1561
1562 switch (cmd)
1563 {
1564 case SNDCTL_TMR_TIMEBASE:
1565 case SNDCTL_TMR_TEMPO:
1566 case SNDCTL_TMR_START:
1567 case SNDCTL_TMR_STOP:
1568 case SNDCTL_TMR_CONTINUE:
1569 case SNDCTL_TMR_METRONOME:
1570 case SNDCTL_TMR_SOURCE:
1571 if (dev)
1572 return -EIO;
1573
1574 if (seq_mode != SEQ_2)
1575 return -EINVAL;
1576 return tmr->ioctl (tmr_no, cmd, arg);
1577 break;
1578
1579 case SNDCTL_TMR_SELECT:
1580 if (dev)
1581 return -EIO;
1582
1583 if (seq_mode != SEQ_2)
1584 return -EINVAL;
1585 pending_timer = get_fs_long ((long *) arg);
1586
1587 if (pending_timer < 0 || pending_timer >= num_sound_timers)
1588 {
1589 pending_timer = -1;
1590 return -EINVAL;
1591 }
1592
1593 return snd_ioctl_return ((int *) arg, pending_timer);
1594 break;
1595
1596 case SNDCTL_SEQ_PANIC:
1597 seq_panic ();
1598 break;
1599
1600 case SNDCTL_SEQ_SYNC:
1601 if (dev)
1602
1603
1604 return -EIO;
1605
1606 if (mode == OPEN_READ)
1607 return 0;
1608 while (qlen && !(current->signal & ~current->blocked))
1609 seq_sync ();
1610 if (qlen)
1611 return -EINTR;
1612 else
1613 return 0;
1614 break;
1615
1616 case SNDCTL_SEQ_RESET:
1617 if (dev)
1618
1619
1620 return -EIO;
1621
1622 seq_reset ();
1623 return 0;
1624 break;
1625
1626 case SNDCTL_SEQ_TESTMIDI:
1627 if (dev)
1628
1629
1630 return -EIO;
1631
1632 midi_dev = get_fs_long ((long *) arg);
1633 if (midi_dev >= max_mididev)
1634 return -ENXIO;
1635
1636 if (!midi_opened[midi_dev])
1637 {
1638 int err, mode;
1639
1640 mode = file->mode & O_ACCMODE;
1641 if ((err = midi_devs[midi_dev]->open (midi_dev, mode,
1642 sequencer_midi_input,
1643 sequencer_midi_output)) < 0)
1644 return err;
1645 }
1646
1647 midi_opened[midi_dev] = 1;
1648
1649 return 0;
1650 break;
1651
1652 case SNDCTL_SEQ_GETINCOUNT:
1653 if (dev)
1654
1655
1656 return -EIO;
1657
1658 if (mode == OPEN_WRITE)
1659 return 0;
1660 return snd_ioctl_return ((int *) arg, iqlen);
1661 break;
1662
1663 case SNDCTL_SEQ_GETOUTCOUNT:
1664
1665 if (mode == OPEN_READ)
1666 return 0;
1667 return snd_ioctl_return ((int *) arg, SEQ_MAX_QUEUE - qlen);
1668 break;
1669
1670 case SNDCTL_SEQ_CTRLRATE:
1671 if (dev)
1672 return -EIO;
1673
1674
1675
1676
1677 if (seq_mode == SEQ_2)
1678 return tmr->ioctl (tmr_no, cmd, arg);
1679
1680 if (get_fs_long ((long *) arg) != 0)
1681 return -EINVAL;
1682
1683 return snd_ioctl_return ((int *) arg, HZ);
1684 break;
1685
1686 case SNDCTL_SEQ_RESETSAMPLES:
1687 {
1688 int err;
1689
1690 dev = get_fs_long ((long *) arg);
1691 if (dev < 0 || dev >= num_synths)
1692 {
1693 return -ENXIO;
1694 }
1695
1696 if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1697 {
1698 return -EBUSY;
1699 }
1700
1701 if (!orig_dev && pmgr_present[dev])
1702 pmgr_inform (dev, PM_E_PATCH_RESET, 0, 0, 0, 0);
1703
1704 err = synth_devs[dev]->ioctl (dev, cmd, arg);
1705 return err;
1706 }
1707 break;
1708
1709 case SNDCTL_SEQ_NRSYNTHS:
1710 return snd_ioctl_return ((int *) arg, max_synthdev);
1711 break;
1712
1713 case SNDCTL_SEQ_NRMIDIS:
1714 return snd_ioctl_return ((int *) arg, max_mididev);
1715 break;
1716
1717 case SNDCTL_SYNTH_MEMAVL:
1718 {
1719 int dev = get_fs_long ((long *) arg);
1720
1721 if (dev < 0 || dev >= num_synths)
1722 return -ENXIO;
1723
1724 if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1725 return -EBUSY;
1726
1727 return snd_ioctl_return ((int *) arg, synth_devs[dev]->ioctl (dev, cmd, arg));
1728 }
1729 break;
1730
1731 case SNDCTL_FM_4OP_ENABLE:
1732 {
1733 int dev = get_fs_long ((long *) arg);
1734
1735 if (dev < 0 || dev >= num_synths)
1736 return -ENXIO;
1737
1738 if (!(synth_open_mask & (1 << dev)))
1739 return -ENXIO;
1740
1741 synth_devs[dev]->ioctl (dev, cmd, arg);
1742 return 0;
1743 }
1744 break;
1745
1746 case SNDCTL_SYNTH_INFO:
1747 {
1748 struct synth_info inf;
1749 int dev;
1750
1751 memcpy_fromfs ((char *) &inf, &(((char *) arg)[0]), sizeof (inf));
1752 dev = inf.device;
1753
1754 if (dev < 0 || dev >= max_synthdev)
1755 return -ENXIO;
1756
1757 if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1758 return -EBUSY;
1759
1760 return synth_devs[dev]->ioctl (dev, cmd, arg);
1761 }
1762 break;
1763
1764 case SNDCTL_SEQ_OUTOFBAND:
1765 {
1766 struct seq_event_rec event;
1767 unsigned long flags;
1768
1769 memcpy_fromfs ((char *) &event, &(((char *) arg)[0]), sizeof (event));
1770
1771 save_flags (flags);
1772 cli ();
1773 play_event (event.arr);
1774 restore_flags (flags);
1775
1776 return 0;
1777 }
1778 break;
1779
1780 case SNDCTL_MIDI_INFO:
1781 {
1782 struct midi_info inf;
1783 int dev;
1784
1785 memcpy_fromfs ((char *) &inf, &(((char *) arg)[0]), sizeof (inf));
1786 dev = inf.device;
1787
1788 if (dev < 0 || dev >= max_mididev)
1789 return -ENXIO;
1790
1791 memcpy_tofs ((&((char *) arg)[0]), (char *) &(midi_devs[dev]->info), sizeof (inf));
1792 return 0;
1793 }
1794 break;
1795
1796 case SNDCTL_PMGR_IFACE:
1797 {
1798 struct patmgr_info *inf;
1799 int dev, err;
1800
1801 if ((inf = (struct patmgr_info *) kmalloc (sizeof (*inf), GFP_KERNEL)) == NULL)
1802 {
1803 printk ("patmgr: Can't allocate memory for a message\n");
1804 return -EIO;
1805 }
1806
1807 memcpy_fromfs ((char *) inf, &(((char *) arg)[0]), sizeof (*inf));
1808 dev = inf->device;
1809
1810 if (dev < 0 || dev >= num_synths)
1811 {
1812 kfree (inf);
1813 return -ENXIO;
1814 }
1815
1816 if (!synth_devs[dev]->pmgr_interface)
1817 {
1818 kfree (inf);
1819 return -ENXIO;
1820 }
1821
1822 if ((err = synth_devs[dev]->pmgr_interface (dev, inf)) == -1)
1823 {
1824 kfree (inf);
1825 return err;
1826 }
1827
1828 memcpy_tofs ((&((char *) arg)[0]), (char *) inf, sizeof (*inf));
1829 kfree (inf);
1830 return 0;
1831 }
1832 break;
1833
1834 case SNDCTL_PMGR_ACCESS:
1835 {
1836 struct patmgr_info *inf;
1837 int dev, err;
1838
1839 if ((inf = (struct patmgr_info *) kmalloc (sizeof (*inf), GFP_KERNEL)) == NULL)
1840 {
1841 printk ("patmgr: Can't allocate memory for a message\n");
1842 return -EIO;
1843 }
1844
1845 memcpy_fromfs ((char *) inf, &(((char *) arg)[0]), sizeof (*inf));
1846 dev = inf->device;
1847
1848 if (dev < 0 || dev >= num_synths)
1849 {
1850 kfree (inf);
1851 return -ENXIO;
1852 }
1853
1854 if (!pmgr_present[dev])
1855 {
1856 kfree (inf);
1857 return -ESRCH;
1858 }
1859
1860 if ((err = pmgr_access (dev, inf)) < 0)
1861 {
1862 kfree (inf);
1863 return err;
1864 }
1865
1866 memcpy_tofs ((&((char *) arg)[0]), (char *) inf, sizeof (*inf));
1867 kfree (inf);
1868 return 0;
1869 }
1870 break;
1871
1872 case SNDCTL_SEQ_THRESHOLD:
1873 {
1874 int tmp = get_fs_long ((long *) arg);
1875
1876 if (dev)
1877
1878
1879 return -EIO;
1880
1881 if (tmp < 1)
1882 tmp = 1;
1883 if (tmp >= SEQ_MAX_QUEUE)
1884 tmp = SEQ_MAX_QUEUE - 1;
1885 output_treshold = tmp;
1886 return 0;
1887 }
1888 break;
1889
1890 case SNDCTL_MIDI_PRETIME:
1891 {
1892 int val = get_fs_long ((long *) arg);
1893
1894 if (val < 0)
1895 val = 0;
1896
1897 val = (HZ * val) / 10;
1898 pre_event_timeout = val;
1899 return snd_ioctl_return ((int *) arg, val);
1900 }
1901 break;
1902
1903 default:
1904 if (dev)
1905
1906
1907 return -EIO;
1908
1909 if (mode == OPEN_READ)
1910 return -EIO;
1911
1912 if (!synth_devs[0])
1913 return -ENXIO;
1914 if (!(synth_open_mask & (1 << 0)))
1915 return -ENXIO;
1916 return synth_devs[0]->ioctl (0, cmd, arg);
1917 break;
1918 }
1919
1920 return -EINVAL;
1921 }
1922
1923 int
1924 sequencer_select (int dev, struct fileinfo *file, int sel_type, select_table * wait)
1925 {
1926 unsigned long flags;
1927
1928 dev = dev >> 4;
1929
1930 switch (sel_type)
1931 {
1932 case SEL_IN:
1933 save_flags (flags);
1934 cli ();
1935 if (!iqlen)
1936 {
1937 midi_sleep_flag.mode = WK_SLEEP;
1938 select_wait (&midi_sleeper, wait);
1939 restore_flags (flags);
1940 return 0;
1941 }
1942 midi_sleep_flag.mode &= ~WK_SLEEP;
1943 restore_flags (flags);
1944 return 1;
1945 break;
1946
1947 case SEL_OUT:
1948 save_flags (flags);
1949 cli ();
1950 if (qlen >= SEQ_MAX_QUEUE)
1951 {
1952 seq_sleep_flag.mode = WK_SLEEP;
1953 select_wait (&seq_sleeper, wait);
1954 restore_flags (flags);
1955 return 0;
1956 }
1957 seq_sleep_flag.mode &= ~WK_SLEEP;
1958 restore_flags (flags);
1959 return 1;
1960 break;
1961
1962 case SEL_EX:
1963 return 0;
1964 }
1965
1966 return 0;
1967 }
1968
1969
1970 void
1971 sequencer_timer (unsigned long dummy)
1972 {
1973 seq_startplay ();
1974 }
1975
1976 int
1977 note_to_freq (int note_num)
1978 {
1979
1980
1981
1982
1983
1984 int note, octave, note_freq;
1985 int notes[] =
1986 {
1987 261632, 277189, 293671, 311132, 329632, 349232,
1988 369998, 391998, 415306, 440000, 466162, 493880
1989 };
1990
1991 #define BASE_OCTAVE 5
1992
1993 octave = note_num / 12;
1994 note = note_num % 12;
1995
1996 note_freq = notes[note];
1997
1998 if (octave < BASE_OCTAVE)
1999 note_freq >>= (BASE_OCTAVE - octave);
2000 else if (octave > BASE_OCTAVE)
2001 note_freq <<= (octave - BASE_OCTAVE);
2002
2003
2004
2005
2006
2007 return note_freq;
2008 }
2009
2010 unsigned long
2011 compute_finetune (unsigned long base_freq, int bend, int range)
2012 {
2013 unsigned long amount;
2014 int negative, semitones, cents, multiplier = 1;
2015
2016 if (!bend)
2017 return base_freq;
2018 if (!range)
2019 return base_freq;
2020
2021 if (!base_freq)
2022 return base_freq;
2023
2024 if (range >= 8192)
2025 range = 8192;
2026
2027 bend = bend * range / 8192;
2028 if (!bend)
2029 return base_freq;
2030
2031 negative = bend < 0 ? 1 : 0;
2032
2033 if (bend < 0)
2034 bend *= -1;
2035 if (bend > range)
2036 bend = range;
2037
2038
2039
2040
2041
2042 while (bend > 2399)
2043 {
2044 multiplier *= 4;
2045 bend -= 2400;
2046 }
2047
2048 semitones = bend / 100;
2049 cents = bend % 100;
2050
2051 amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents])
2052 / 10000;
2053
2054 if (negative)
2055 return (base_freq * 10000) / amount;
2056 else
2057 return (base_freq * amount) / 10000;
2058 }
2059
2060
2061 long
2062 sequencer_init (long mem_start)
2063 {
2064
2065 sequencer_ok = 1;
2066
2067 queue = (unsigned char *) (sound_mem_blocks[sound_num_blocks] = kmalloc (SEQ_MAX_QUEUE * EV_SZ, GFP_KERNEL));
2068 if (sound_num_blocks < 1024)
2069 sound_num_blocks++;;
2070
2071 iqueue = (unsigned char *) (sound_mem_blocks[sound_num_blocks] = kmalloc (SEQ_MAX_QUEUE * IEV_SZ, GFP_KERNEL));
2072 if (sound_num_blocks < 1024)
2073 sound_num_blocks++;;
2074
2075 return mem_start;
2076 }
2077
2078 #endif
2079
2080 #endif