Fix misspellings of "system", "controller", "interrupt" and "necessary".
[linux-2.6.git] / sound / core / seq / seq_midi_emul.c
1 /*
2  *  GM/GS/XG midi module.
3  *
4  *  Copyright (C) 1999 Steve Ratcliffe
5  *
6  *  Based on awe_wave.c by Takashi Iwai
7  *
8  *   This program is free software; you can redistribute it and/or modify
9  *   it under the terms of the GNU General Public License as published by
10  *   the Free Software Foundation; either version 2 of the License, or
11  *   (at your option) any later version.
12  *
13  *   This program is distributed in the hope that it will be useful,
14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *   GNU General Public License for more details.
17  *
18  *   You should have received a copy of the GNU General Public License
19  *   along with this program; if not, write to the Free Software
20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21  *
22  */
23 /*
24  * This module is used to keep track of the current midi state.
25  * It can be used for drivers that are required to emulate midi when
26  * the hardware doesn't.
27  *
28  * It was written for a AWE64 driver, but there should be no AWE specific
29  * code in here.  If there is it should be reported as a bug.
30  */
31
32 #include <sound/driver.h>
33 #include <linux/init.h>
34 #include <linux/slab.h>
35 #include <linux/string.h>
36 #include <sound/core.h>
37 #include <sound/seq_kernel.h>
38 #include <sound/seq_midi_emul.h>
39 #include <sound/initval.h>
40 #include <sound/asoundef.h>
41
42 MODULE_AUTHOR("Takashi Iwai / Steve Ratcliffe");
43 MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer MIDI emulation.");
44 MODULE_LICENSE("GPL");
45
46 /* Prototypes for static functions */
47 static void note_off(struct snd_midi_op *ops, void *drv,
48                      struct snd_midi_channel *chan,
49                      int note, int vel);
50 static void do_control(struct snd_midi_op *ops, void *private,
51                        struct snd_midi_channel_set *chset,
52                        struct snd_midi_channel *chan,
53                        int control, int value);
54 static void rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
55                 struct snd_midi_channel_set *chset);
56 static void nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
57                  struct snd_midi_channel_set *chset);
58 static void sysex(struct snd_midi_op *ops, void *private, unsigned char *sysex,
59                   int len, struct snd_midi_channel_set *chset);
60 static void all_sounds_off(struct snd_midi_op *ops, void *private,
61                            struct snd_midi_channel *chan);
62 static void all_notes_off(struct snd_midi_op *ops, void *private,
63                           struct snd_midi_channel *chan);
64 static void snd_midi_reset_controllers(struct snd_midi_channel *chan);
65 static void reset_all_channels(struct snd_midi_channel_set *chset);
66
67
68 /*
69  * Process an event in a driver independent way.  This means dealing
70  * with RPN, NRPN, SysEx etc that are defined for common midi applications
71  * such as GM, GS and XG.
72  * There modes that this module will run in are:
73  *   Generic MIDI - no interpretation at all, it will just save current values
74  *                  of controllers etc.
75  *   GM - You can use all gm_ prefixed elements of chan.  Controls, RPN, NRPN,
76  *        SysEx will be interpreded as defined in General Midi.
77  *   GS - You can use all gs_ prefixed elements of chan. Codes for GS will be
78  *        interpreted.
79  *   XG - You can use all xg_ prefixed elements of chan.  Codes for XG will
80  *        be interpreted.
81  */
82 void
83 snd_midi_process_event(struct snd_midi_op *ops,
84                        struct snd_seq_event *ev,
85                        struct snd_midi_channel_set *chanset)
86 {
87         struct snd_midi_channel *chan;
88         void *drv;
89         int dest_channel = 0;
90
91         if (ev == NULL || chanset == NULL) {
92                 snd_printd("ev or chanbase NULL (snd_midi_process_event)\n");
93                 return;
94         }
95         if (chanset->channels == NULL)
96                 return;
97
98         if (snd_seq_ev_is_channel_type(ev)) {
99                 dest_channel = ev->data.note.channel;
100                 if (dest_channel >= chanset->max_channels) {
101                         snd_printd("dest channel is %d, max is %d\n",
102                                    dest_channel, chanset->max_channels);
103                         return;
104                 }
105         }
106
107         chan = chanset->channels + dest_channel;
108         drv  = chanset->private_data;
109
110         /* EVENT_NOTE should be processed before queued */
111         if (ev->type == SNDRV_SEQ_EVENT_NOTE)
112                 return;
113
114         /* Make sure that we don't have a note on that should really be
115          * a note off */
116         if (ev->type == SNDRV_SEQ_EVENT_NOTEON && ev->data.note.velocity == 0)
117                 ev->type = SNDRV_SEQ_EVENT_NOTEOFF;
118
119         /* Make sure the note is within array range */
120         if (ev->type == SNDRV_SEQ_EVENT_NOTEON ||
121             ev->type == SNDRV_SEQ_EVENT_NOTEOFF ||
122             ev->type == SNDRV_SEQ_EVENT_KEYPRESS) {
123                 if (ev->data.note.note >= 128)
124                         return;
125         }
126
127         switch (ev->type) {
128         case SNDRV_SEQ_EVENT_NOTEON:
129                 if (chan->note[ev->data.note.note] & SNDRV_MIDI_NOTE_ON) {
130                         if (ops->note_off)
131                                 ops->note_off(drv, ev->data.note.note, 0, chan);
132                 }
133                 chan->note[ev->data.note.note] = SNDRV_MIDI_NOTE_ON;
134                 if (ops->note_on)
135                         ops->note_on(drv, ev->data.note.note, ev->data.note.velocity, chan);
136                 break;
137         case SNDRV_SEQ_EVENT_NOTEOFF:
138                 if (! (chan->note[ev->data.note.note] & SNDRV_MIDI_NOTE_ON))
139                         break;
140                 if (ops->note_off)
141                         note_off(ops, drv, chan, ev->data.note.note, ev->data.note.velocity);
142                 break;
143         case SNDRV_SEQ_EVENT_KEYPRESS:
144                 if (ops->key_press)
145                         ops->key_press(drv, ev->data.note.note, ev->data.note.velocity, chan);
146                 break;
147         case SNDRV_SEQ_EVENT_CONTROLLER:
148                 do_control(ops, drv, chanset, chan,
149                            ev->data.control.param, ev->data.control.value);
150                 break;
151         case SNDRV_SEQ_EVENT_PGMCHANGE:
152                 chan->midi_program = ev->data.control.value;
153                 break;
154         case SNDRV_SEQ_EVENT_PITCHBEND:
155                 chan->midi_pitchbend = ev->data.control.value;
156                 if (ops->control)
157                         ops->control(drv, MIDI_CTL_PITCHBEND, chan);
158                 break;
159         case SNDRV_SEQ_EVENT_CHANPRESS:
160                 chan->midi_pressure = ev->data.control.value;
161                 if (ops->control)
162                         ops->control(drv, MIDI_CTL_CHAN_PRESSURE, chan);
163                 break;
164         case SNDRV_SEQ_EVENT_CONTROL14:
165                 /* Best guess is that this is any of the 14 bit controller values */
166                 if (ev->data.control.param < 32) {
167                         /* set low part first */
168                         chan->control[ev->data.control.param + 32] =
169                                 ev->data.control.value & 0x7f;
170                         do_control(ops, drv, chanset, chan,
171                                    ev->data.control.param,
172                                    ((ev->data.control.value>>7) & 0x7f));
173                 } else
174                         do_control(ops, drv, chanset, chan,
175                                    ev->data.control.param,
176                                    ev->data.control.value);
177                 break;
178         case SNDRV_SEQ_EVENT_NONREGPARAM:
179                 /* Break it back into its controller values */
180                 chan->param_type = SNDRV_MIDI_PARAM_TYPE_NONREGISTERED;
181                 chan->control[MIDI_CTL_MSB_DATA_ENTRY]
182                         = (ev->data.control.value >> 7) & 0x7f;
183                 chan->control[MIDI_CTL_LSB_DATA_ENTRY]
184                         = ev->data.control.value & 0x7f;
185                 chan->control[MIDI_CTL_NONREG_PARM_NUM_MSB]
186                         = (ev->data.control.param >> 7) & 0x7f;
187                 chan->control[MIDI_CTL_NONREG_PARM_NUM_LSB]
188                         = ev->data.control.param & 0x7f;
189                 nrpn(ops, drv, chan, chanset);
190                 break;
191         case SNDRV_SEQ_EVENT_REGPARAM:
192                 /* Break it back into its controller values */
193                 chan->param_type = SNDRV_MIDI_PARAM_TYPE_REGISTERED;
194                 chan->control[MIDI_CTL_MSB_DATA_ENTRY]
195                         = (ev->data.control.value >> 7) & 0x7f;
196                 chan->control[MIDI_CTL_LSB_DATA_ENTRY]
197                         = ev->data.control.value & 0x7f;
198                 chan->control[MIDI_CTL_REGIST_PARM_NUM_MSB]
199                         = (ev->data.control.param >> 7) & 0x7f;
200                 chan->control[MIDI_CTL_REGIST_PARM_NUM_LSB]
201                         = ev->data.control.param & 0x7f;
202                 rpn(ops, drv, chan, chanset);
203                 break;
204         case SNDRV_SEQ_EVENT_SYSEX:
205                 if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE) {
206                         unsigned char sysexbuf[64];
207                         int len;
208                         len = snd_seq_expand_var_event(ev, sizeof(sysexbuf), sysexbuf, 1, 0);
209                         if (len > 0)
210                                 sysex(ops, drv, sysexbuf, len, chanset);
211                 }
212                 break;
213         case SNDRV_SEQ_EVENT_SONGPOS:
214         case SNDRV_SEQ_EVENT_SONGSEL:
215         case SNDRV_SEQ_EVENT_CLOCK:
216         case SNDRV_SEQ_EVENT_START:
217         case SNDRV_SEQ_EVENT_CONTINUE:
218         case SNDRV_SEQ_EVENT_STOP:
219         case SNDRV_SEQ_EVENT_QFRAME:
220         case SNDRV_SEQ_EVENT_TEMPO:
221         case SNDRV_SEQ_EVENT_TIMESIGN:
222         case SNDRV_SEQ_EVENT_KEYSIGN:
223                 goto not_yet;
224         case SNDRV_SEQ_EVENT_SENSING:
225                 break;
226         case SNDRV_SEQ_EVENT_CLIENT_START:
227         case SNDRV_SEQ_EVENT_CLIENT_EXIT:
228         case SNDRV_SEQ_EVENT_CLIENT_CHANGE:
229         case SNDRV_SEQ_EVENT_PORT_START:
230         case SNDRV_SEQ_EVENT_PORT_EXIT:
231         case SNDRV_SEQ_EVENT_PORT_CHANGE:
232         case SNDRV_SEQ_EVENT_SAMPLE:
233         case SNDRV_SEQ_EVENT_SAMPLE_START:
234         case SNDRV_SEQ_EVENT_SAMPLE_STOP:
235         case SNDRV_SEQ_EVENT_SAMPLE_FREQ:
236         case SNDRV_SEQ_EVENT_SAMPLE_VOLUME:
237         case SNDRV_SEQ_EVENT_SAMPLE_LOOP:
238         case SNDRV_SEQ_EVENT_SAMPLE_POSITION:
239         case SNDRV_SEQ_EVENT_ECHO:
240         not_yet:
241         default:
242                 /*snd_printd("Unimplemented event %d\n", ev->type);*/
243                 break;
244         }
245 }
246
247
248 /*
249  * release note
250  */
251 static void
252 note_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
253          int note, int vel)
254 {
255         if (chan->gm_hold) {
256                 /* Hold this note until pedal is turned off */
257                 chan->note[note] |= SNDRV_MIDI_NOTE_RELEASED;
258         } else if (chan->note[note] & SNDRV_MIDI_NOTE_SOSTENUTO) {
259                 /* Mark this note as release; it will be turned off when sostenuto
260                  * is turned off */
261                 chan->note[note] |= SNDRV_MIDI_NOTE_RELEASED;
262         } else {
263                 chan->note[note] = 0;
264                 if (ops->note_off)
265                         ops->note_off(drv, note, vel, chan);
266         }
267 }
268
269 /*
270  * Do all driver independent operations for this controller and pass
271  * events that need to take place immediately to the driver.
272  */
273 static void
274 do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chset,
275            struct snd_midi_channel *chan, int control, int value)
276 {
277         int  i;
278
279         /* Switches */
280         if ((control >=64 && control <=69) || (control >= 80 && control <= 83)) {
281                 /* These are all switches; either off or on so set to 0 or 127 */
282                 value = (value >= 64)? 127: 0;
283         }
284         chan->control[control] = value;
285
286         switch (control) {
287         case MIDI_CTL_SUSTAIN:
288                 if (value == 0) {
289                         /* Sustain has been released, turn off held notes */
290                         for (i = 0; i < 128; i++) {
291                                 if (chan->note[i] & SNDRV_MIDI_NOTE_RELEASED) {
292                                         chan->note[i] = SNDRV_MIDI_NOTE_OFF;
293                                         if (ops->note_off)
294                                                 ops->note_off(drv, i, 0, chan);
295                                 }
296                         }
297                 }
298                 break;
299         case MIDI_CTL_PORTAMENTO:
300                 break;
301         case MIDI_CTL_SOSTENUTO:
302                 if (value) {
303                         /* Mark each note that is currently held down */
304                         for (i = 0; i < 128; i++) {
305                                 if (chan->note[i] & SNDRV_MIDI_NOTE_ON)
306                                         chan->note[i] |= SNDRV_MIDI_NOTE_SOSTENUTO;
307                         }
308                 } else {
309                         /* release all notes that were held */
310                         for (i = 0; i < 128; i++) {
311                                 if (chan->note[i] & SNDRV_MIDI_NOTE_SOSTENUTO) {
312                                         chan->note[i] &= ~SNDRV_MIDI_NOTE_SOSTENUTO;
313                                         if (chan->note[i] & SNDRV_MIDI_NOTE_RELEASED) {
314                                                 chan->note[i] = SNDRV_MIDI_NOTE_OFF;
315                                                 if (ops->note_off)
316                                                         ops->note_off(drv, i, 0, chan);
317                                         }
318                                 }
319                         }
320                 }
321                 break;
322         case MIDI_CTL_MSB_DATA_ENTRY:
323                 chan->control[MIDI_CTL_LSB_DATA_ENTRY] = 0;
324                 /* go through here */
325         case MIDI_CTL_LSB_DATA_ENTRY:
326                 if (chan->param_type == SNDRV_MIDI_PARAM_TYPE_REGISTERED)
327                         rpn(ops, drv, chan, chset);
328                 else
329                         nrpn(ops, drv, chan, chset);
330                 break;
331         case MIDI_CTL_REGIST_PARM_NUM_LSB:
332         case MIDI_CTL_REGIST_PARM_NUM_MSB:
333                 chan->param_type = SNDRV_MIDI_PARAM_TYPE_REGISTERED;
334                 break;
335         case MIDI_CTL_NONREG_PARM_NUM_LSB:
336         case MIDI_CTL_NONREG_PARM_NUM_MSB:
337                 chan->param_type = SNDRV_MIDI_PARAM_TYPE_NONREGISTERED;
338                 break;
339
340         case MIDI_CTL_ALL_SOUNDS_OFF:
341                 all_sounds_off(ops, drv, chan);
342                 break;
343
344         case MIDI_CTL_ALL_NOTES_OFF:
345                 all_notes_off(ops, drv, chan);
346                 break;
347
348         case MIDI_CTL_MSB_BANK:
349                 if (chset->midi_mode == SNDRV_MIDI_MODE_XG) {
350                         if (value == 127)
351                                 chan->drum_channel = 1;
352                         else
353                                 chan->drum_channel = 0;
354                 }
355                 break;
356         case MIDI_CTL_LSB_BANK:
357                 break;
358
359         case MIDI_CTL_RESET_CONTROLLERS:
360                 snd_midi_reset_controllers(chan);
361                 break;
362
363         case MIDI_CTL_SOFT_PEDAL:
364         case MIDI_CTL_LEGATO_FOOTSWITCH:
365         case MIDI_CTL_HOLD2:
366         case MIDI_CTL_SC1_SOUND_VARIATION:
367         case MIDI_CTL_SC2_TIMBRE:
368         case MIDI_CTL_SC3_RELEASE_TIME:
369         case MIDI_CTL_SC4_ATTACK_TIME:
370         case MIDI_CTL_SC5_BRIGHTNESS:
371         case MIDI_CTL_E1_REVERB_DEPTH:
372         case MIDI_CTL_E2_TREMOLO_DEPTH:
373         case MIDI_CTL_E3_CHORUS_DEPTH:
374         case MIDI_CTL_E4_DETUNE_DEPTH:
375         case MIDI_CTL_E5_PHASER_DEPTH:
376                 goto notyet;
377         notyet:
378         default:
379                 if (ops->control)
380                         ops->control(drv, control, chan);
381                 break;
382         }
383 }
384
385
386 /*
387  * initialize the MIDI status
388  */
389 void
390 snd_midi_channel_set_clear(struct snd_midi_channel_set *chset)
391 {
392         int i;
393
394         chset->midi_mode = SNDRV_MIDI_MODE_GM;
395         chset->gs_master_volume = 127;
396
397         for (i = 0; i < chset->max_channels; i++) {
398                 struct snd_midi_channel *chan = chset->channels + i;
399                 memset(chan->note, 0, sizeof(chan->note));
400
401                 chan->midi_aftertouch = 0;
402                 chan->midi_pressure = 0;
403                 chan->midi_program = 0;
404                 chan->midi_pitchbend = 0;
405                 snd_midi_reset_controllers(chan);
406                 chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
407                 chan->gm_rpn_fine_tuning = 0;
408                 chan->gm_rpn_coarse_tuning = 0;
409
410                 if (i == 9)
411                         chan->drum_channel = 1;
412                 else
413                         chan->drum_channel = 0;
414         }
415 }
416
417 /*
418  * Process a rpn message.
419  */
420 static void
421 rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
422     struct snd_midi_channel_set *chset)
423 {
424         int type;
425         int val;
426
427         if (chset->midi_mode != SNDRV_MIDI_MODE_NONE) {
428                 type = (chan->control[MIDI_CTL_REGIST_PARM_NUM_MSB] << 8) |
429                         chan->control[MIDI_CTL_REGIST_PARM_NUM_LSB];
430                 val = (chan->control[MIDI_CTL_MSB_DATA_ENTRY] << 7) |
431                         chan->control[MIDI_CTL_LSB_DATA_ENTRY];
432
433                 switch (type) {
434                 case 0x0000: /* Pitch bend sensitivity */
435                         /* MSB only / 1 semitone per 128 */
436                         chan->gm_rpn_pitch_bend_range = val;
437                         break;
438                                         
439                 case 0x0001: /* fine tuning: */
440                         /* MSB/LSB, 8192=center, 100/8192 cent step */
441                         chan->gm_rpn_fine_tuning = val - 8192;
442                         break;
443
444                 case 0x0002: /* coarse tuning */
445                         /* MSB only / 8192=center, 1 semitone per 128 */
446                         chan->gm_rpn_coarse_tuning = val - 8192;
447                         break;
448
449                 case 0x7F7F: /* "lock-in" RPN */
450                         /* ignored */
451                         break;
452                 }
453         }
454         /* should call nrpn or rpn callback here.. */
455 }
456
457 /*
458  * Process an nrpn message.
459  */
460 static void
461 nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
462      struct snd_midi_channel_set *chset)
463 {
464         /* parse XG NRPNs here if possible */
465         if (ops->nrpn)
466                 ops->nrpn(drv, chan, chset);
467 }
468
469
470 /*
471  * convert channel parameter in GS sysex
472  */
473 static int
474 get_channel(unsigned char cmd)
475 {
476         int p = cmd & 0x0f;
477         if (p == 0)
478                 p = 9;
479         else if (p < 10)
480                 p--;
481         return p;
482 }
483
484
485 /*
486  * Process a sysex message.
487  */
488 static void
489 sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len,
490       struct snd_midi_channel_set *chset)
491 {
492         /* GM on */
493         static unsigned char gm_on_macro[] = {
494                 0x7e,0x7f,0x09,0x01,
495         };
496         /* XG on */
497         static unsigned char xg_on_macro[] = {
498                 0x43,0x10,0x4c,0x00,0x00,0x7e,0x00,
499         };
500         /* GS prefix
501          * drum channel: XX=0x1?(channel), YY=0x15, ZZ=on/off
502          * reverb mode: XX=0x01, YY=0x30, ZZ=0-7
503          * chorus mode: XX=0x01, YY=0x38, ZZ=0-7
504          * master vol:  XX=0x00, YY=0x04, ZZ=0-127
505          */
506         static unsigned char gs_pfx_macro[] = {
507                 0x41,0x10,0x42,0x12,0x40,/*XX,YY,ZZ*/
508         };
509
510         int parsed = SNDRV_MIDI_SYSEX_NOT_PARSED;
511
512         if (len <= 0 || buf[0] != 0xf0)
513                 return;
514         /* skip first byte */
515         buf++;
516         len--;
517
518         /* GM on */
519         if (len >= (int)sizeof(gm_on_macro) &&
520             memcmp(buf, gm_on_macro, sizeof(gm_on_macro)) == 0) {
521                 if (chset->midi_mode != SNDRV_MIDI_MODE_GS &&
522                     chset->midi_mode != SNDRV_MIDI_MODE_XG) {
523                         chset->midi_mode = SNDRV_MIDI_MODE_GM;
524                         reset_all_channels(chset);
525                         parsed = SNDRV_MIDI_SYSEX_GM_ON;
526                 }
527         }
528
529         /* GS macros */
530         else if (len >= 8 &&
531                  memcmp(buf, gs_pfx_macro, sizeof(gs_pfx_macro)) == 0) {
532                 if (chset->midi_mode != SNDRV_MIDI_MODE_GS &&
533                     chset->midi_mode != SNDRV_MIDI_MODE_XG)
534                         chset->midi_mode = SNDRV_MIDI_MODE_GS;
535
536                 if (buf[5] == 0x00 && buf[6] == 0x7f && buf[7] == 0x00) {
537                         /* GS reset */
538                         parsed = SNDRV_MIDI_SYSEX_GS_RESET;
539                         reset_all_channels(chset);
540                 }
541
542                 else if ((buf[5] & 0xf0) == 0x10 && buf[6] == 0x15) {
543                         /* drum pattern */
544                         int p = get_channel(buf[5]);
545                         if (p < chset->max_channels) {
546                                 parsed = SNDRV_MIDI_SYSEX_GS_DRUM_CHANNEL;
547                                 if (buf[7])
548                                         chset->channels[p].drum_channel = 1;
549                                 else
550                                         chset->channels[p].drum_channel = 0;
551                         }
552
553                 } else if ((buf[5] & 0xf0) == 0x10 && buf[6] == 0x21) {
554                         /* program */
555                         int p = get_channel(buf[5]);
556                         if (p < chset->max_channels &&
557                             ! chset->channels[p].drum_channel) {
558                                 parsed = SNDRV_MIDI_SYSEX_GS_DRUM_CHANNEL;
559                                 chset->channels[p].midi_program = buf[7];
560                         }
561
562                 } else if (buf[5] == 0x01 && buf[6] == 0x30) {
563                         /* reverb mode */
564                         parsed = SNDRV_MIDI_SYSEX_GS_REVERB_MODE;
565                         chset->gs_reverb_mode = buf[7];
566
567                 } else if (buf[5] == 0x01 && buf[6] == 0x38) {
568                         /* chorus mode */
569                         parsed = SNDRV_MIDI_SYSEX_GS_CHORUS_MODE;
570                         chset->gs_chorus_mode = buf[7];
571
572                 } else if (buf[5] == 0x00 && buf[6] == 0x04) {
573                         /* master volume */
574                         parsed = SNDRV_MIDI_SYSEX_GS_MASTER_VOLUME;
575                         chset->gs_master_volume = buf[7];
576
577                 }
578         }
579
580         /* XG on */
581         else if (len >= (int)sizeof(xg_on_macro) &&
582                  memcmp(buf, xg_on_macro, sizeof(xg_on_macro)) == 0) {
583                 int i;
584                 chset->midi_mode = SNDRV_MIDI_MODE_XG;
585                 parsed = SNDRV_MIDI_SYSEX_XG_ON;
586                 /* reset CC#0 for drums */
587                 for (i = 0; i < chset->max_channels; i++) {
588                         if (chset->channels[i].drum_channel)
589                                 chset->channels[i].control[MIDI_CTL_MSB_BANK] = 127;
590                         else
591                                 chset->channels[i].control[MIDI_CTL_MSB_BANK] = 0;
592                 }
593         }
594
595         if (ops->sysex)
596                 ops->sysex(private, buf - 1, len + 1, parsed, chset);
597 }
598
599 /*
600  * all sound off
601  */
602 static void
603 all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
604 {
605         int n;
606
607         if (! ops->note_terminate)
608                 return;
609         for (n = 0; n < 128; n++) {
610                 if (chan->note[n]) {
611                         ops->note_terminate(drv, n, chan);
612                         chan->note[n] = 0;
613                 }
614         }
615 }
616
617 /*
618  * all notes off
619  */
620 static void
621 all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
622 {
623         int n;
624
625         if (! ops->note_off)
626                 return;
627         for (n = 0; n < 128; n++) {
628                 if (chan->note[n] == SNDRV_MIDI_NOTE_ON)
629                         note_off(ops, drv, chan, n, 0);
630         }
631 }
632
633 /*
634  * Initialise a single midi channel control block.
635  */
636 static void snd_midi_channel_init(struct snd_midi_channel *p, int n)
637 {
638         if (p == NULL)
639                 return;
640
641         memset(p, 0, sizeof(struct snd_midi_channel));
642         p->private = NULL;
643         p->number = n;
644
645         snd_midi_reset_controllers(p);
646         p->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
647         p->gm_rpn_fine_tuning = 0;
648         p->gm_rpn_coarse_tuning = 0;
649
650         if (n == 9)
651                 p->drum_channel = 1;    /* Default ch 10 as drums */
652 }
653
654 /*
655  * Allocate and initialise a set of midi channel control blocks.
656  */
657 static struct snd_midi_channel *snd_midi_channel_init_set(int n)
658 {
659         struct snd_midi_channel *chan;
660         int  i;
661
662         chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL);
663         if (chan) {
664                 for (i = 0; i < n; i++)
665                         snd_midi_channel_init(chan+i, i);
666         }
667
668         return chan;
669 }
670
671 /*
672  * reset all midi channels
673  */
674 static void
675 reset_all_channels(struct snd_midi_channel_set *chset)
676 {
677         int ch;
678         for (ch = 0; ch < chset->max_channels; ch++) {
679                 struct snd_midi_channel *chan = chset->channels + ch;
680                 snd_midi_reset_controllers(chan);
681                 chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
682                 chan->gm_rpn_fine_tuning = 0;
683                 chan->gm_rpn_coarse_tuning = 0;
684
685                 if (ch == 9)
686                         chan->drum_channel = 1;
687                 else
688                         chan->drum_channel = 0;
689         }
690 }
691
692
693 /*
694  * Allocate and initialise a midi channel set.
695  */
696 struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n)
697 {
698         struct snd_midi_channel_set *chset;
699
700         chset = kmalloc(sizeof(*chset), GFP_KERNEL);
701         if (chset) {
702                 chset->channels = snd_midi_channel_init_set(n);
703                 chset->private_data = NULL;
704                 chset->max_channels = n;
705         }
706         return chset;
707 }
708
709 /*
710  * Reset the midi controllers on a particular channel to default values.
711  */
712 static void snd_midi_reset_controllers(struct snd_midi_channel *chan)
713 {
714         memset(chan->control, 0, sizeof(chan->control));
715         chan->gm_volume = 127;
716         chan->gm_expression = 127;
717         chan->gm_pan = 64;
718 }
719
720
721 /*
722  * Free a midi channel set.
723  */
724 void snd_midi_channel_free_set(struct snd_midi_channel_set *chset)
725 {
726         if (chset == NULL)
727                 return;
728         kfree(chset->channels);
729         kfree(chset);
730 }
731
732 static int __init alsa_seq_midi_emul_init(void)
733 {
734         return 0;
735 }
736
737 static void __exit alsa_seq_midi_emul_exit(void)
738 {
739 }
740
741 module_init(alsa_seq_midi_emul_init)
742 module_exit(alsa_seq_midi_emul_exit)
743
744 EXPORT_SYMBOL(snd_midi_process_event);
745 EXPORT_SYMBOL(snd_midi_channel_set_clear);
746 EXPORT_SYMBOL(snd_midi_channel_alloc_set);
747 EXPORT_SYMBOL(snd_midi_channel_free_set);