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
snd_midi_process_event(const struct snd_midi_op * ops,struct snd_seq_event * ev,struct snd_midi_channel_set * chanset)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
note_off(const struct snd_midi_op * ops,void * drv,struct snd_midi_channel * chan,int note,int vel)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
do_control(const struct snd_midi_op * ops,void * drv,struct snd_midi_channel_set * chset,struct snd_midi_channel * chan,int control,int value)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 		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  */
377 void
snd_midi_channel_set_clear(struct snd_midi_channel_set * chset)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
rpn(const struct snd_midi_op * ops,void * drv,struct snd_midi_channel * chan,struct snd_midi_channel_set * chset)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
nrpn(const struct snd_midi_op * ops,void * drv,struct snd_midi_channel * chan,struct snd_midi_channel_set * chset)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
get_channel(unsigned char cmd)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
sysex(const struct snd_midi_op * ops,void * private,unsigned char * buf,int len,struct snd_midi_channel_set * chset)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 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  */
591 static void
all_sounds_off(const struct snd_midi_op * ops,void * drv,struct snd_midi_channel * chan)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
all_notes_off(const struct snd_midi_op * ops,void * drv,struct snd_midi_channel * chan)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  */
snd_midi_channel_init(struct snd_midi_channel * p,int n)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  */
snd_midi_channel_init_set(int n)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
reset_all_channels(struct snd_midi_channel_set * chset)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  */
snd_midi_channel_alloc_set(int n)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  */
snd_midi_reset_controllers(struct snd_midi_channel * chan)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  */
snd_midi_channel_free_set(struct snd_midi_channel_set * chset)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);
724