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