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