?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* added 0.99 linux version
[mascara-docs.git] / i386 / linux / linux-2.3.21 / drivers / sound / midi_synth.c
blob03d7d284f9efd0caa9b3ded1352bffe7c748a8e9
1 /*
2 * sound/midi_synth.c
3 *
4 * High level midi sequencer manager for dumb MIDI interfaces.
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 * Andrew Veliath : fixed running status in MIDI input state machine
16 */
17 #include <linux/config.h>
18
19 #define USE_SEQ_MACROS
20 #define USE_SIMPLE_MACROS
21
22 #include "sound_config.h"
23
24 #ifdef CONFIG_MIDI
25
26 #define _MIDI_SYNTH_C_
27
28 #include "midi_synth.h"
29
30 static int midi2synth[MAX_MIDI_DEV];
31 static int sysex_state[MAX_MIDI_DEV] =
32 {0};
33 static unsigned char prev_out_status[MAX_MIDI_DEV];
34
35 #ifndef CONFIG_SEQUENCER
36 #define STORE(cmd)
37 #else
38 #define STORE(cmd) \
39 { \
40 int len; \
41 unsigned char obuf[8]; \
42 cmd; \
43 seq_input_event(obuf, len); \
44 }
45 #endif
46
47 #define _seqbuf obuf
48 #define _seqbufptr 0
49 #define _SEQ_ADVBUF(x) len=x
50
51 void
52 do_midi_msg(int synthno, unsigned char *msg, int mlen)
53 {
54 switch (msg[0] & 0xf0)
55 {
56 case 0x90:
57 if (msg[2] != 0)
58 {
59 STORE(SEQ_START_NOTE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
60 break;
61 }
62 msg[2] = 64;
63
64 case 0x80:
65 STORE(SEQ_STOP_NOTE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
66 break;
67
68 case 0xA0:
69 STORE(SEQ_KEY_PRESSURE(synthno, msg[0] & 0x0f, msg[1], msg[2]));
70 break;
71
72 case 0xB0:
73 STORE(SEQ_CONTROL(synthno, msg[0] & 0x0f,
74 msg[1], msg[2]));
75 break;
76
77 case 0xC0:
78 STORE(SEQ_SET_PATCH(synthno, msg[0] & 0x0f, msg[1]));
79 break;
80
81 case 0xD0:
82 STORE(SEQ_CHN_PRESSURE(synthno, msg[0] & 0x0f, msg[1]));
83 break;
84
85 case 0xE0:
86 STORE(SEQ_BENDER(synthno, msg[0] & 0x0f,
87 (msg[1] & 0x7f) | ((msg[2] & 0x7f) << 7)));
88 break;
89
90 default:
91 /* printk( "MPU: Unknown midi channel message %02x\n", msg[0]); */
92 ;
93 }
94 }
95
96 static void
97 midi_outc(int midi_dev, int data)
98 {
99 int timeout;
100
101 for (timeout = 0; timeout < 3200; timeout++)
102 if (midi_devs[midi_dev]->outputc(midi_dev, (unsigned char) (data & 0xff)))
103 {
104 if (data & 0x80) /*
105 * Status byte
106 */
107 prev_out_status[midi_dev] =
108 (unsigned char) (data & 0xff); /*
109 * Store for running status
110 */
111 return; /*
112 * Mission complete
113 */
114 }
115 /*
116 * Sorry! No space on buffers.
117 */
118 printk("Midi send timed out\n");
119 }
120
121 static int
122 prefix_cmd(int midi_dev, unsigned char status)
123 {
124 if ((char *) midi_devs[midi_dev]->prefix_cmd == NULL)
125 return 1;
126
127 return midi_devs[midi_dev]->prefix_cmd(midi_dev, status);
128 }
129
130 static void
131 midi_synth_input(int orig_dev, unsigned char data)
132 {
133 int dev;
134 struct midi_input_info *inc;
135
136 static unsigned char len_tab[] = /* # of data bytes following a status
137 */
138 {
139 2, /* 8x */
140 2, /* 9x */
141 2, /* Ax */
142 2, /* Bx */
143 1, /* Cx */
144 1, /* Dx */
145 2, /* Ex */
146 0 /* Fx */
147 };
148
149 if (orig_dev < 0 || orig_dev > num_midis || midi_devs[orig_dev] == NULL)
150 return;
151
152 if (data == 0xfe) /* Ignore active sensing */
153 return;
154
155 dev = midi2synth[orig_dev];
156 inc = &midi_devs[orig_dev]->in_info;
157
158 switch (inc->m_state)
159 {
160 case MST_INIT:
161 if (data & 0x80) /* MIDI status byte */
162 {
163 if ((data & 0xf0) == 0xf0) /* Common message */
164 {
165 switch (data)
166 {
167 case 0xf0: /* Sysex */
168 inc->m_state = MST_SYSEX;
169 break; /* Sysex */
170
171 case 0xf1: /* MTC quarter frame */
172 case 0xf3: /* Song select */
173 inc->m_state = MST_DATA;
174 inc->m_ptr = 1;
175 inc->m_left = 1;
176 inc->m_buf[0] = data;
177 break;
178
179 case 0xf2: /* Song position pointer */
180 inc->m_state = MST_DATA;
181 inc->m_ptr = 1;
182 inc->m_left = 2;
183 inc->m_buf[0] = data;
184 break;
185
186 default:
187 inc->m_buf[0] = data;
188 inc->m_ptr = 1;
189 do_midi_msg(dev, inc->m_buf, inc->m_ptr);
190 inc->m_ptr = 0;
191 inc->m_left = 0;
192 }
193 } else
194 {
195 inc->m_state = MST_DATA;
196 inc->m_ptr = 1;
197 inc->m_left = len_tab[(data >> 4) - 8];
198 inc->m_buf[0] = inc->m_prev_status = data;
199 }
200 } else if (inc->m_prev_status & 0x80) {
201 /* Data byte (use running status) */
202 inc->m_ptr = 2;
203 inc->m_buf[1] = data;
204 inc->m_buf[0] = inc->m_prev_status;
205 inc->m_left = len_tab[(inc->m_buf[0] >> 4) - 8] - 1;
206 if (inc->m_left > 0)
207 inc->m_state = MST_DATA; /* Not done yet */
208 else {
209 inc->m_state = MST_INIT;
210 do_midi_msg(dev, inc->m_buf, inc->m_ptr);
211 inc->m_ptr = 0;
212 }
213 }
214 break; /* MST_INIT */
215
216 case MST_DATA:
217 inc->m_buf[inc->m_ptr++] = data;
218 if (--inc->m_left <= 0)
219 {
220 inc->m_state = MST_INIT;
221 do_midi_msg(dev, inc->m_buf, inc->m_ptr);
222 inc->m_ptr = 0;
223 }
224 break; /* MST_DATA */
225
226 case MST_SYSEX:
227 if (data == 0xf7) /* Sysex end */
228 {
229 inc->m_state = MST_INIT;
230 inc->m_left = 0;
231 inc->m_ptr = 0;
232 }
233 break; /* MST_SYSEX */
234
235 default:
236 printk("MIDI%d: Unexpected state %d (%02x)\n", orig_dev, inc->m_state, (int) data);
237 inc->m_state = MST_INIT;
238 }
239 }
240
241 static void
242 leave_sysex(int dev)
243 {
244 int orig_dev = synth_devs[dev]->midi_dev;
245 int timeout = 0;
246
247 if (!sysex_state[dev])
248 return;
249
250 sysex_state[dev] = 0;
251
252 while (!midi_devs[orig_dev]->outputc(orig_dev, 0xf7) &&
253 timeout < 1000)
254 timeout++;
255
256 sysex_state[dev] = 0;
257 }
258
259 static void
260 midi_synth_output(int dev)
261 {
262 /*
263 * Currently NOP
264 */
265 }
266
267 int midi_synth_ioctl(int dev, unsigned int cmd, caddr_t arg)
268 {
269 /*
270 * int orig_dev = synth_devs[dev]->midi_dev;
271 */
272
273 switch (cmd) {
274
275 case SNDCTL_SYNTH_INFO:
276 if (__copy_to_user(arg, synth_devs[dev]->info, sizeof(struct synth_info)))
277 return -EFAULT;
278 return 0;
279
280 case SNDCTL_SYNTH_MEMAVL:
281 return 0x7fffffff;
282
283 default:
284 return -EINVAL;
285 }
286 }
287
288 int
289 midi_synth_kill_note(int dev, int channel, int note, int velocity)
290 {
291 int orig_dev = synth_devs[dev]->midi_dev;
292 int msg, chn;
293
294 if (note < 0 || note > 127)
295 return 0;
296 if (channel < 0 || channel > 15)
297 return 0;
298 if (velocity < 0)
299 velocity = 0;
300 if (velocity > 127)
301 velocity = 127;
302
303 leave_sysex(dev);
304
305 msg = prev_out_status[orig_dev] & 0xf0;
306 chn = prev_out_status[orig_dev] & 0x0f;
307
308 if (chn == channel && ((msg == 0x90 && velocity == 64) || msg == 0x80))
309 { /*
310 * Use running status
311 */
312 if (!prefix_cmd(orig_dev, note))
313 return 0;
314
315 midi_outc(orig_dev, note);
316
317 if (msg == 0x90) /*
318 * Running status = Note on
319 */
320 midi_outc(orig_dev, 0); /*
321 * Note on with velocity 0 == note
322 * off
323 */
324 else
325 midi_outc(orig_dev, velocity);
326 } else
327 {
328 if (velocity == 64)
329 {
330 if (!prefix_cmd(orig_dev, 0x90 | (channel & 0x0f)))
331 return 0;
332 midi_outc(orig_dev, 0x90 | (channel & 0x0f)); /*
333 * Note on
334 */
335 midi_outc(orig_dev, note);
336 midi_outc(orig_dev, 0); /*
337 * Zero G
338 */
339 } else
340 {
341 if (!prefix_cmd(orig_dev, 0x80 | (channel & 0x0f)))
342 return 0;
343 midi_outc(orig_dev, 0x80 | (channel & 0x0f)); /*
344 * Note off
345 */
346 midi_outc(orig_dev, note);
347 midi_outc(orig_dev, velocity);
348 }
349 }
350
351 return 0;
352 }
353
354 int
355 midi_synth_set_instr(int dev, int channel, int instr_no)
356 {
357 int orig_dev = synth_devs[dev]->midi_dev;
358
359 if (instr_no < 0 || instr_no > 127)
360 instr_no = 0;
361 if (channel < 0 || channel > 15)
362 return 0;
363
364 leave_sysex(dev);
365
366 if (!prefix_cmd(orig_dev, 0xc0 | (channel & 0x0f)))
367 return 0;
368 midi_outc(orig_dev, 0xc0 | (channel & 0x0f)); /*
369 * Program change
370 */
371 midi_outc(orig_dev, instr_no);
372
373 return 0;
374 }
375
376 int
377 midi_synth_start_note(int dev, int channel, int note, int velocity)
378 {
379 int orig_dev = synth_devs[dev]->midi_dev;
380 int msg, chn;
381
382 if (note < 0 || note > 127)
383 return 0;
384 if (channel < 0 || channel > 15)
385 return 0;
386 if (velocity < 0)
387 velocity = 0;
388 if (velocity > 127)
389 velocity = 127;
390
391 leave_sysex(dev);
392
393 msg = prev_out_status[orig_dev] & 0xf0;
394 chn = prev_out_status[orig_dev] & 0x0f;
395
396 if (chn == channel && msg == 0x90)
397 { /*
398 * Use running status
399 */
400 if (!prefix_cmd(orig_dev, note))
401 return 0;
402 midi_outc(orig_dev, note);
403 midi_outc(orig_dev, velocity);
404 } else
405 {
406 if (!prefix_cmd(orig_dev, 0x90 | (channel & 0x0f)))
407 return 0;
408 midi_outc(orig_dev, 0x90 | (channel & 0x0f)); /*
409 * Note on
410 */
411 midi_outc(orig_dev, note);
412 midi_outc(orig_dev, velocity);
413 }
414 return 0;
415 }
416
417 void
418 midi_synth_reset(int dev)
419 {
420
421 leave_sysex(dev);
422 }
423
424 int
425 midi_synth_open(int dev, int mode)
426 {
427 int orig_dev = synth_devs[dev]->midi_dev;
428 int err;
429 unsigned long flags;
430 struct midi_input_info *inc;
431
432 if (orig_dev < 0 || orig_dev > num_midis || midi_devs[orig_dev] == NULL)
433 return -ENXIO;
434
435 midi2synth[orig_dev] = dev;
436 sysex_state[dev] = 0;
437 prev_out_status[orig_dev] = 0;
438
439 if ((err = midi_devs[orig_dev]->open(orig_dev, mode,
440 midi_synth_input, midi_synth_output)) < 0)
441 return err;
442 #ifdef MODULE
443 MOD_INC_USE_COUNT;
444 #endif
445 inc = &midi_devs[orig_dev]->in_info;
446
447 save_flags(flags);
448 cli();
449 inc->m_busy = 0;
450 inc->m_state = MST_INIT;
451 inc->m_ptr = 0;
452 inc->m_left = 0;
453 inc->m_prev_status = 0x00;
454 restore_flags(flags);
455
456 return 1;
457 }
458
459 void
460 midi_synth_close(int dev)
461 {
462 int orig_dev = synth_devs[dev]->midi_dev;
463
464 leave_sysex(dev);
465
466 /*
467 * Shut up the synths by sending just single active sensing message.
468 */
469 midi_devs[orig_dev]->outputc(orig_dev, 0xfe);
470
471 midi_devs[orig_dev]->close(orig_dev);
472 #ifdef MODULE
473 MOD_DEC_USE_COUNT;
474 #endif
475 }
476
477 void
478 midi_synth_hw_control(int dev, unsigned char *event)
479 {
480 }
481
482 int
483 midi_synth_load_patch(int dev, int format, const char *addr,
484 int offs, int count, int pmgr_flag)
485 {
486 int orig_dev = synth_devs[dev]->midi_dev;
487
488 struct sysex_info sysex;
489 int i;
490 unsigned long left, src_offs, eox_seen = 0;
491 int first_byte = 1;
492 int hdr_size = (unsigned long) &sysex.data[0] - (unsigned long) &sysex;
493
494 leave_sysex(dev);
495
496 if (!prefix_cmd(orig_dev, 0xf0))
497 return 0;
498
499 if (format != SYSEX_PATCH)
500 {
501 /* printk("MIDI Error: Invalid patch format (key) 0x%x\n", format);*/
502 return -EINVAL;
503 }
504 if (count < hdr_size)
505 {
506 /* printk("MIDI Error: Patch header too short\n");*/
507 return -EINVAL;
508 }
509 count -= hdr_size;
510
511 /*
512 * Copy the header from user space but ignore the first bytes which have
513 * been transferred already.
514 */
515
516 if(copy_from_user(&((char *) &sysex)[offs], &(addr)[offs], hdr_size - offs))
517 return -EFAULT;
518
519 if (count < sysex.len)
520 {
521 /* printk(KERN_WARNING "MIDI Warning: Sysex record too short (%d<%d)\n", count, (int) sysex.len);*/
522 sysex.len = count;
523 }
524 left = sysex.len;
525 src_offs = 0;
526
527 for (i = 0; i < left && !signal_pending(current); i++)
528 {
529 unsigned char data;
530
531 get_user(*(unsigned char *) &data, (unsigned char *) &((addr)[hdr_size + i]));
532
533 eox_seen = (i > 0 && data & 0x80); /* End of sysex */
534
535 if (eox_seen && data != 0xf7)
536 data = 0xf7;
537
538 if (i == 0)
539 {
540 if (data != 0xf0)
541 {
542 printk(KERN_WARNING "midi_synth: Sysex start missing\n");
543 return -EINVAL;
544 }
545 }
546 while (!midi_devs[orig_dev]->outputc(orig_dev, (unsigned char) (data & 0xff)) &&
547 !signal_pending(current))
548 schedule();
549
550 if (!first_byte && data & 0x80)
551 return 0;
552 first_byte = 0;
553 }
554
555 if (!eox_seen)
556 midi_outc(orig_dev, 0xf7);
557 return 0;
558 }
559
560 void midi_synth_panning(int dev, int channel, int pressure)
561 {
562 }
563
564 void midi_synth_aftertouch(int dev, int channel, int pressure)
565 {
566 int orig_dev = synth_devs[dev]->midi_dev;
567 int msg, chn;
568
569 if (pressure < 0 || pressure > 127)
570 return;
571 if (channel < 0 || channel > 15)
572 return;
573
574 leave_sysex(dev);
575
576 msg = prev_out_status[orig_dev] & 0xf0;
577 chn = prev_out_status[orig_dev] & 0x0f;
578
579 if (msg != 0xd0 || chn != channel) /*
580 * Test for running status
581 */
582 {
583 if (!prefix_cmd(orig_dev, 0xd0 | (channel & 0x0f)))
584 return;
585 midi_outc(orig_dev, 0xd0 | (channel & 0x0f)); /*
586 * Channel pressure
587 */
588 } else if (!prefix_cmd(orig_dev, pressure))
589 return;
590
591 midi_outc(orig_dev, pressure);
592 }
593
594 void
595 midi_synth_controller(int dev, int channel, int ctrl_num, int value)
596 {
597 int orig_dev = synth_devs[dev]->midi_dev;
598 int chn, msg;
599
600 if (ctrl_num < 0 || ctrl_num > 127)
601 return;
602 if (channel < 0 || channel > 15)
603 return;
604
605 leave_sysex(dev);
606
607 msg = prev_out_status[orig_dev] & 0xf0;
608 chn = prev_out_status[orig_dev] & 0x0f;
609
610 if (msg != 0xb0 || chn != channel)
611 {
612 if (!prefix_cmd(orig_dev, 0xb0 | (channel & 0x0f)))
613 return;
614 midi_outc(orig_dev, 0xb0 | (channel & 0x0f));
615 } else if (!prefix_cmd(orig_dev, ctrl_num))
616 return;
617
618 midi_outc(orig_dev, ctrl_num);
619 midi_outc(orig_dev, value & 0x7f);
620 }
621
622 void
623 midi_synth_bender(int dev, int channel, int value)
624 {
625 int orig_dev = synth_devs[dev]->midi_dev;
626 int msg, prev_chn;
627
628 if (channel < 0 || channel > 15)
629 return;
630
631 if (value < 0 || value > 16383)
632 return;
633
634 leave_sysex(dev);
635
636 msg = prev_out_status[orig_dev] & 0xf0;
637 prev_chn = prev_out_status[orig_dev] & 0x0f;
638
639 if (msg != 0xd0 || prev_chn != channel) /*
640 * Test for running status
641 */
642 {
643 if (!prefix_cmd(orig_dev, 0xe0 | (channel & 0x0f)))
644 return;
645 midi_outc(orig_dev, 0xe0 | (channel & 0x0f));
646 } else if (!prefix_cmd(orig_dev, value & 0x7f))
647 return;
648
649 midi_outc(orig_dev, value & 0x7f);
650 midi_outc(orig_dev, (value >> 7) & 0x7f);
651 }
652
653 void
654 midi_synth_setup_voice(int dev, int voice, int channel)
655 {
656 }
657
658 int
659 midi_synth_send_sysex(int dev, unsigned char *bytes, int len)
660 {
661 int orig_dev = synth_devs[dev]->midi_dev;
662 int i;
663
664 for (i = 0; i < len; i++)
665 {
666 switch (bytes[i])
667 {
668 case 0xf0: /* Start sysex */
669 if (!prefix_cmd(orig_dev, 0xf0))
670 return 0;
671 sysex_state[dev] = 1;
672 break;
673
674 case 0xf7: /* End sysex */
675 if (!sysex_state[dev]) /* Orphan sysex end */
676 return 0;
677 sysex_state[dev] = 0;
678 break;
679
680 default:
681 if (!sysex_state[dev])
682 return 0;
683
684 if (bytes[i] & 0x80) /* Error. Another message before sysex end */
685 {
686 bytes[i] = 0xf7; /* Sysex end */
687 sysex_state[dev] = 0;
688 }
689 }
690
691 if (!midi_devs[orig_dev]->outputc(orig_dev, bytes[i]))
692 {
693 /*
694 * Hardware level buffer is full. Abort the sysex message.
695 */
696
697 int timeout = 0;
698
699 bytes[i] = 0xf7;
700 sysex_state[dev] = 0;
701
702 while (!midi_devs[orig_dev]->outputc(orig_dev, bytes[i]) &&
703 timeout < 1000)
704 timeout++;
705 }
706 if (!sysex_state[dev])
707 return 0;
708 }
709
710 return 0;
711 }
712
713
714 #endif