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