Loading...
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
28MODULE_AUTHOR("Takashi Iwai / Steve Ratcliffe");
29MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer MIDI emulation.");
30MODULE_LICENSE("GPL");
31
32/* Prototypes for static functions */
33static void note_off(const struct snd_midi_op *ops, void *drv,
34 struct snd_midi_channel *chan,
35 int note, int vel);
36static 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);
40static void rpn(const struct snd_midi_op *ops, void *drv,
41 struct snd_midi_channel *chan,
42 struct snd_midi_channel_set *chset);
43static void nrpn(const struct snd_midi_op *ops, void *drv,
44 struct snd_midi_channel *chan,
45 struct snd_midi_channel_set *chset);
46static void sysex(const struct snd_midi_op *ops, void *private,
47 unsigned char *sysex,
48 int len, struct snd_midi_channel_set *chset);
49static void all_sounds_off(const struct snd_midi_op *ops, void *private,
50 struct snd_midi_channel *chan);
51static void all_notes_off(const struct snd_midi_op *ops, void *private,
52 struct snd_midi_channel *chan);
53static void snd_midi_reset_controllers(struct snd_midi_channel *chan);
54static 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 */
71void
72snd_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}
228EXPORT_SYMBOL(snd_midi_process_event);
229
230
231/*
232 * release note
233 */
234static void
235note_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 */
257static void
258do_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 fallthrough;
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 */
377void
378snd_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}
404EXPORT_SYMBOL(snd_midi_channel_set_clear);
405
406/*
407 * Process a rpn message.
408 */
409static void
410rpn(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 */
449static void
450nrpn(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 */
462static int
463get_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 */
477static void
478sysex(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 const unsigned char gm_on_macro[] = {
483 0x7e,0x7f,0x09,0x01,
484 };
485 /* XG on */
486 static const 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 const 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 */
591static void
592all_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 */
610static void
611all_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 */
627static 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 */
648static 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 */
665static void
666reset_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 */
687struct 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}
699EXPORT_SYMBOL(snd_midi_channel_alloc_set);
700
701/*
702 * Reset the midi controllers on a particular channel to default values.
703 */
704static 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 */
716void 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}
723EXPORT_SYMBOL(snd_midi_channel_free_set);
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 <linux/init.h>
33#include <linux/slab.h>
34#include <linux/string.h>
35#include <linux/module.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
42MODULE_AUTHOR("Takashi Iwai / Steve Ratcliffe");
43MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer MIDI emulation.");
44MODULE_LICENSE("GPL");
45
46/* Prototypes for static functions */
47static void note_off(struct snd_midi_op *ops, void *drv,
48 struct snd_midi_channel *chan,
49 int note, int vel);
50static 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);
54static void rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
55 struct snd_midi_channel_set *chset);
56static void nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
57 struct snd_midi_channel_set *chset);
58static void sysex(struct snd_midi_op *ops, void *private, unsigned char *sysex,
59 int len, struct snd_midi_channel_set *chset);
60static void all_sounds_off(struct snd_midi_op *ops, void *private,
61 struct snd_midi_channel *chan);
62static void all_notes_off(struct snd_midi_op *ops, void *private,
63 struct snd_midi_channel *chan);
64static void snd_midi_reset_controllers(struct snd_midi_channel *chan);
65static 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 */
82void
83snd_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 pr_debug("ALSA: seq_midi_emul: 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 pr_debug("ALSA: seq_midi_emul: 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_ECHO:
233 not_yet:
234 default:
235 /*pr_debug("ALSA: seq_midi_emul: Unimplemented event %d\n", ev->type);*/
236 break;
237 }
238}
239
240
241/*
242 * release note
243 */
244static void
245note_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
246 int note, int vel)
247{
248 if (chan->gm_hold) {
249 /* Hold this note until pedal is turned off */
250 chan->note[note] |= SNDRV_MIDI_NOTE_RELEASED;
251 } else if (chan->note[note] & SNDRV_MIDI_NOTE_SOSTENUTO) {
252 /* Mark this note as release; it will be turned off when sostenuto
253 * is turned off */
254 chan->note[note] |= SNDRV_MIDI_NOTE_RELEASED;
255 } else {
256 chan->note[note] = 0;
257 if (ops->note_off)
258 ops->note_off(drv, note, vel, chan);
259 }
260}
261
262/*
263 * Do all driver independent operations for this controller and pass
264 * events that need to take place immediately to the driver.
265 */
266static void
267do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chset,
268 struct snd_midi_channel *chan, int control, int value)
269{
270 int i;
271
272 if (control >= ARRAY_SIZE(chan->control))
273 return;
274
275 /* Switches */
276 if ((control >=64 && control <=69) || (control >= 80 && control <= 83)) {
277 /* These are all switches; either off or on so set to 0 or 127 */
278 value = (value >= 64)? 127: 0;
279 }
280 chan->control[control] = value;
281
282 switch (control) {
283 case MIDI_CTL_SUSTAIN:
284 if (value == 0) {
285 /* Sustain has been released, turn off held notes */
286 for (i = 0; i < 128; i++) {
287 if (chan->note[i] & SNDRV_MIDI_NOTE_RELEASED) {
288 chan->note[i] = SNDRV_MIDI_NOTE_OFF;
289 if (ops->note_off)
290 ops->note_off(drv, i, 0, chan);
291 }
292 }
293 }
294 break;
295 case MIDI_CTL_PORTAMENTO:
296 break;
297 case MIDI_CTL_SOSTENUTO:
298 if (value) {
299 /* Mark each note that is currently held down */
300 for (i = 0; i < 128; i++) {
301 if (chan->note[i] & SNDRV_MIDI_NOTE_ON)
302 chan->note[i] |= SNDRV_MIDI_NOTE_SOSTENUTO;
303 }
304 } else {
305 /* release all notes that were held */
306 for (i = 0; i < 128; i++) {
307 if (chan->note[i] & SNDRV_MIDI_NOTE_SOSTENUTO) {
308 chan->note[i] &= ~SNDRV_MIDI_NOTE_SOSTENUTO;
309 if (chan->note[i] & SNDRV_MIDI_NOTE_RELEASED) {
310 chan->note[i] = SNDRV_MIDI_NOTE_OFF;
311 if (ops->note_off)
312 ops->note_off(drv, i, 0, chan);
313 }
314 }
315 }
316 }
317 break;
318 case MIDI_CTL_MSB_DATA_ENTRY:
319 chan->control[MIDI_CTL_LSB_DATA_ENTRY] = 0;
320 /* go through here */
321 case MIDI_CTL_LSB_DATA_ENTRY:
322 if (chan->param_type == SNDRV_MIDI_PARAM_TYPE_REGISTERED)
323 rpn(ops, drv, chan, chset);
324 else
325 nrpn(ops, drv, chan, chset);
326 break;
327 case MIDI_CTL_REGIST_PARM_NUM_LSB:
328 case MIDI_CTL_REGIST_PARM_NUM_MSB:
329 chan->param_type = SNDRV_MIDI_PARAM_TYPE_REGISTERED;
330 break;
331 case MIDI_CTL_NONREG_PARM_NUM_LSB:
332 case MIDI_CTL_NONREG_PARM_NUM_MSB:
333 chan->param_type = SNDRV_MIDI_PARAM_TYPE_NONREGISTERED;
334 break;
335
336 case MIDI_CTL_ALL_SOUNDS_OFF:
337 all_sounds_off(ops, drv, chan);
338 break;
339
340 case MIDI_CTL_ALL_NOTES_OFF:
341 all_notes_off(ops, drv, chan);
342 break;
343
344 case MIDI_CTL_MSB_BANK:
345 if (chset->midi_mode == SNDRV_MIDI_MODE_XG) {
346 if (value == 127)
347 chan->drum_channel = 1;
348 else
349 chan->drum_channel = 0;
350 }
351 break;
352 case MIDI_CTL_LSB_BANK:
353 break;
354
355 case MIDI_CTL_RESET_CONTROLLERS:
356 snd_midi_reset_controllers(chan);
357 break;
358
359 case MIDI_CTL_SOFT_PEDAL:
360 case MIDI_CTL_LEGATO_FOOTSWITCH:
361 case MIDI_CTL_HOLD2:
362 case MIDI_CTL_SC1_SOUND_VARIATION:
363 case MIDI_CTL_SC2_TIMBRE:
364 case MIDI_CTL_SC3_RELEASE_TIME:
365 case MIDI_CTL_SC4_ATTACK_TIME:
366 case MIDI_CTL_SC5_BRIGHTNESS:
367 case MIDI_CTL_E1_REVERB_DEPTH:
368 case MIDI_CTL_E2_TREMOLO_DEPTH:
369 case MIDI_CTL_E3_CHORUS_DEPTH:
370 case MIDI_CTL_E4_DETUNE_DEPTH:
371 case MIDI_CTL_E5_PHASER_DEPTH:
372 goto notyet;
373 notyet:
374 default:
375 if (ops->control)
376 ops->control(drv, control, chan);
377 break;
378 }
379}
380
381
382/*
383 * initialize the MIDI status
384 */
385void
386snd_midi_channel_set_clear(struct snd_midi_channel_set *chset)
387{
388 int i;
389
390 chset->midi_mode = SNDRV_MIDI_MODE_GM;
391 chset->gs_master_volume = 127;
392
393 for (i = 0; i < chset->max_channels; i++) {
394 struct snd_midi_channel *chan = chset->channels + i;
395 memset(chan->note, 0, sizeof(chan->note));
396
397 chan->midi_aftertouch = 0;
398 chan->midi_pressure = 0;
399 chan->midi_program = 0;
400 chan->midi_pitchbend = 0;
401 snd_midi_reset_controllers(chan);
402 chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
403 chan->gm_rpn_fine_tuning = 0;
404 chan->gm_rpn_coarse_tuning = 0;
405
406 if (i == 9)
407 chan->drum_channel = 1;
408 else
409 chan->drum_channel = 0;
410 }
411}
412
413/*
414 * Process a rpn message.
415 */
416static void
417rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
418 struct snd_midi_channel_set *chset)
419{
420 int type;
421 int val;
422
423 if (chset->midi_mode != SNDRV_MIDI_MODE_NONE) {
424 type = (chan->control[MIDI_CTL_REGIST_PARM_NUM_MSB] << 8) |
425 chan->control[MIDI_CTL_REGIST_PARM_NUM_LSB];
426 val = (chan->control[MIDI_CTL_MSB_DATA_ENTRY] << 7) |
427 chan->control[MIDI_CTL_LSB_DATA_ENTRY];
428
429 switch (type) {
430 case 0x0000: /* Pitch bend sensitivity */
431 /* MSB only / 1 semitone per 128 */
432 chan->gm_rpn_pitch_bend_range = val;
433 break;
434
435 case 0x0001: /* fine tuning: */
436 /* MSB/LSB, 8192=center, 100/8192 cent step */
437 chan->gm_rpn_fine_tuning = val - 8192;
438 break;
439
440 case 0x0002: /* coarse tuning */
441 /* MSB only / 8192=center, 1 semitone per 128 */
442 chan->gm_rpn_coarse_tuning = val - 8192;
443 break;
444
445 case 0x7F7F: /* "lock-in" RPN */
446 /* ignored */
447 break;
448 }
449 }
450 /* should call nrpn or rpn callback here.. */
451}
452
453/*
454 * Process an nrpn message.
455 */
456static void
457nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
458 struct snd_midi_channel_set *chset)
459{
460 /* parse XG NRPNs here if possible */
461 if (ops->nrpn)
462 ops->nrpn(drv, chan, chset);
463}
464
465
466/*
467 * convert channel parameter in GS sysex
468 */
469static int
470get_channel(unsigned char cmd)
471{
472 int p = cmd & 0x0f;
473 if (p == 0)
474 p = 9;
475 else if (p < 10)
476 p--;
477 return p;
478}
479
480
481/*
482 * Process a sysex message.
483 */
484static void
485sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len,
486 struct snd_midi_channel_set *chset)
487{
488 /* GM on */
489 static unsigned char gm_on_macro[] = {
490 0x7e,0x7f,0x09,0x01,
491 };
492 /* XG on */
493 static unsigned char xg_on_macro[] = {
494 0x43,0x10,0x4c,0x00,0x00,0x7e,0x00,
495 };
496 /* GS prefix
497 * drum channel: XX=0x1?(channel), YY=0x15, ZZ=on/off
498 * reverb mode: XX=0x01, YY=0x30, ZZ=0-7
499 * chorus mode: XX=0x01, YY=0x38, ZZ=0-7
500 * master vol: XX=0x00, YY=0x04, ZZ=0-127
501 */
502 static unsigned char gs_pfx_macro[] = {
503 0x41,0x10,0x42,0x12,0x40,/*XX,YY,ZZ*/
504 };
505
506 int parsed = SNDRV_MIDI_SYSEX_NOT_PARSED;
507
508 if (len <= 0 || buf[0] != 0xf0)
509 return;
510 /* skip first byte */
511 buf++;
512 len--;
513
514 /* GM on */
515 if (len >= (int)sizeof(gm_on_macro) &&
516 memcmp(buf, gm_on_macro, sizeof(gm_on_macro)) == 0) {
517 if (chset->midi_mode != SNDRV_MIDI_MODE_GS &&
518 chset->midi_mode != SNDRV_MIDI_MODE_XG) {
519 chset->midi_mode = SNDRV_MIDI_MODE_GM;
520 reset_all_channels(chset);
521 parsed = SNDRV_MIDI_SYSEX_GM_ON;
522 }
523 }
524
525 /* GS macros */
526 else if (len >= 8 &&
527 memcmp(buf, gs_pfx_macro, sizeof(gs_pfx_macro)) == 0) {
528 if (chset->midi_mode != SNDRV_MIDI_MODE_GS &&
529 chset->midi_mode != SNDRV_MIDI_MODE_XG)
530 chset->midi_mode = SNDRV_MIDI_MODE_GS;
531
532 if (buf[5] == 0x00 && buf[6] == 0x7f && buf[7] == 0x00) {
533 /* GS reset */
534 parsed = SNDRV_MIDI_SYSEX_GS_RESET;
535 reset_all_channels(chset);
536 }
537
538 else if ((buf[5] & 0xf0) == 0x10 && buf[6] == 0x15) {
539 /* drum pattern */
540 int p = get_channel(buf[5]);
541 if (p < chset->max_channels) {
542 parsed = SNDRV_MIDI_SYSEX_GS_DRUM_CHANNEL;
543 if (buf[7])
544 chset->channels[p].drum_channel = 1;
545 else
546 chset->channels[p].drum_channel = 0;
547 }
548
549 } else if ((buf[5] & 0xf0) == 0x10 && buf[6] == 0x21) {
550 /* program */
551 int p = get_channel(buf[5]);
552 if (p < chset->max_channels &&
553 ! chset->channels[p].drum_channel) {
554 parsed = SNDRV_MIDI_SYSEX_GS_DRUM_CHANNEL;
555 chset->channels[p].midi_program = buf[7];
556 }
557
558 } else if (buf[5] == 0x01 && buf[6] == 0x30) {
559 /* reverb mode */
560 parsed = SNDRV_MIDI_SYSEX_GS_REVERB_MODE;
561 chset->gs_reverb_mode = buf[7];
562
563 } else if (buf[5] == 0x01 && buf[6] == 0x38) {
564 /* chorus mode */
565 parsed = SNDRV_MIDI_SYSEX_GS_CHORUS_MODE;
566 chset->gs_chorus_mode = buf[7];
567
568 } else if (buf[5] == 0x00 && buf[6] == 0x04) {
569 /* master volume */
570 parsed = SNDRV_MIDI_SYSEX_GS_MASTER_VOLUME;
571 chset->gs_master_volume = buf[7];
572
573 }
574 }
575
576 /* XG on */
577 else if (len >= (int)sizeof(xg_on_macro) &&
578 memcmp(buf, xg_on_macro, sizeof(xg_on_macro)) == 0) {
579 int i;
580 chset->midi_mode = SNDRV_MIDI_MODE_XG;
581 parsed = SNDRV_MIDI_SYSEX_XG_ON;
582 /* reset CC#0 for drums */
583 for (i = 0; i < chset->max_channels; i++) {
584 if (chset->channels[i].drum_channel)
585 chset->channels[i].control[MIDI_CTL_MSB_BANK] = 127;
586 else
587 chset->channels[i].control[MIDI_CTL_MSB_BANK] = 0;
588 }
589 }
590
591 if (ops->sysex)
592 ops->sysex(private, buf - 1, len + 1, parsed, chset);
593}
594
595/*
596 * all sound off
597 */
598static void
599all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
600{
601 int n;
602
603 if (! ops->note_terminate)
604 return;
605 for (n = 0; n < 128; n++) {
606 if (chan->note[n]) {
607 ops->note_terminate(drv, n, chan);
608 chan->note[n] = 0;
609 }
610 }
611}
612
613/*
614 * all notes off
615 */
616static void
617all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
618{
619 int n;
620
621 if (! ops->note_off)
622 return;
623 for (n = 0; n < 128; n++) {
624 if (chan->note[n] == SNDRV_MIDI_NOTE_ON)
625 note_off(ops, drv, chan, n, 0);
626 }
627}
628
629/*
630 * Initialise a single midi channel control block.
631 */
632static void snd_midi_channel_init(struct snd_midi_channel *p, int n)
633{
634 if (p == NULL)
635 return;
636
637 memset(p, 0, sizeof(struct snd_midi_channel));
638 p->private = NULL;
639 p->number = n;
640
641 snd_midi_reset_controllers(p);
642 p->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
643 p->gm_rpn_fine_tuning = 0;
644 p->gm_rpn_coarse_tuning = 0;
645
646 if (n == 9)
647 p->drum_channel = 1; /* Default ch 10 as drums */
648}
649
650/*
651 * Allocate and initialise a set of midi channel control blocks.
652 */
653static struct snd_midi_channel *snd_midi_channel_init_set(int n)
654{
655 struct snd_midi_channel *chan;
656 int i;
657
658 chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL);
659 if (chan) {
660 for (i = 0; i < n; i++)
661 snd_midi_channel_init(chan+i, i);
662 }
663
664 return chan;
665}
666
667/*
668 * reset all midi channels
669 */
670static void
671reset_all_channels(struct snd_midi_channel_set *chset)
672{
673 int ch;
674 for (ch = 0; ch < chset->max_channels; ch++) {
675 struct snd_midi_channel *chan = chset->channels + ch;
676 snd_midi_reset_controllers(chan);
677 chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
678 chan->gm_rpn_fine_tuning = 0;
679 chan->gm_rpn_coarse_tuning = 0;
680
681 if (ch == 9)
682 chan->drum_channel = 1;
683 else
684 chan->drum_channel = 0;
685 }
686}
687
688
689/*
690 * Allocate and initialise a midi channel set.
691 */
692struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n)
693{
694 struct snd_midi_channel_set *chset;
695
696 chset = kmalloc(sizeof(*chset), GFP_KERNEL);
697 if (chset) {
698 chset->channels = snd_midi_channel_init_set(n);
699 chset->private_data = NULL;
700 chset->max_channels = n;
701 }
702 return chset;
703}
704
705/*
706 * Reset the midi controllers on a particular channel to default values.
707 */
708static void snd_midi_reset_controllers(struct snd_midi_channel *chan)
709{
710 memset(chan->control, 0, sizeof(chan->control));
711 chan->gm_volume = 127;
712 chan->gm_expression = 127;
713 chan->gm_pan = 64;
714}
715
716
717/*
718 * Free a midi channel set.
719 */
720void snd_midi_channel_free_set(struct snd_midi_channel_set *chset)
721{
722 if (chset == NULL)
723 return;
724 kfree(chset->channels);
725 kfree(chset);
726}
727
728static int __init alsa_seq_midi_emul_init(void)
729{
730 return 0;
731}
732
733static void __exit alsa_seq_midi_emul_exit(void)
734{
735}
736
737module_init(alsa_seq_midi_emul_init)
738module_exit(alsa_seq_midi_emul_exit)
739
740EXPORT_SYMBOL(snd_midi_process_event);
741EXPORT_SYMBOL(snd_midi_channel_set_clear);
742EXPORT_SYMBOL(snd_midi_channel_alloc_set);
743EXPORT_SYMBOL(snd_midi_channel_free_set);