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