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