1/* 2 ********************************************************************** 3 * sblive_mi.c - MIDI UART input HAL for emu10k1 driver 4 * Copyright 1999, 2000 Creative Labs, Inc. 5 * 6 ********************************************************************** 7 * 8 * Date Author Summary of changes 9 * ---- ------ ------------------ 10 * October 20, 1999 Bertrand Lee base code release 11 * November 2, 1999 Alan Cox clean up 12 * 13 ********************************************************************** 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License as 17 * published by the Free Software Foundation; either version 2 of 18 * the License, or (at your option) any later version. 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public 26 * License along with this program; if not, write to the Free 27 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 28 * USA. 29 * 30 ********************************************************************** 31 */ 32 33#include <linux/slab.h> 34#include <linux/jiffies.h> 35 36#include "hwaccess.h" 37#include "8010.h" 38#include "cardmi.h" 39#include "irqmgr.h" 40 41 42static int emu10k1_mpuin_callback(struct emu10k1_mpuin *card_mpuin, u32 msg, unsigned long data, u32 bytesvalid); 43 44static int sblive_miStateInit(struct emu10k1_mpuin *); 45static int sblive_miStateEntry(struct emu10k1_mpuin *, u8); 46static int sblive_miStateParse(struct emu10k1_mpuin *, u8); 47static int sblive_miState3Byte(struct emu10k1_mpuin *, u8); 48static int sblive_miState3ByteKey(struct emu10k1_mpuin *, u8); 49static int sblive_miState3ByteVel(struct emu10k1_mpuin *, u8); 50static int sblive_miState2Byte(struct emu10k1_mpuin *, u8); 51static int sblive_miState2ByteKey(struct emu10k1_mpuin *, u8); 52static int sblive_miStateSysCommon2(struct emu10k1_mpuin *, u8); 53static int sblive_miStateSysCommon2Key(struct emu10k1_mpuin *, u8); 54static int sblive_miStateSysCommon3(struct emu10k1_mpuin *, u8); 55static int sblive_miStateSysCommon3Key(struct emu10k1_mpuin *, u8); 56static int sblive_miStateSysCommon3Vel(struct emu10k1_mpuin *, u8); 57static int sblive_miStateSysExNorm(struct emu10k1_mpuin *, u8); 58static int sblive_miStateSysReal(struct emu10k1_mpuin *, u8); 59 60 61static struct { 62 int (*Fn) (struct emu10k1_mpuin *, u8); 63} midistatefn[] = { 64 65 { 66 sblive_miStateParse}, { 67 sblive_miState3Byte}, /* 0x8n, 0x9n, 0xAn, 0xBn, 0xEn */ 68 { 69 sblive_miState3ByteKey}, /* Byte 1 */ 70 { 71 sblive_miState3ByteVel}, /* Byte 2 */ 72 { 73 sblive_miState2Byte}, /* 0xCn, 0xDn */ 74 { 75 sblive_miState2ByteKey}, /* Byte 1 */ 76 { 77 sblive_miStateSysCommon2}, /* 0xF1 , 0xF3 */ 78 { 79 sblive_miStateSysCommon2Key}, /* 0xF1 , 0xF3, Byte 1 */ 80 { 81 sblive_miStateSysCommon3}, /* 0xF2 */ 82 { 83 sblive_miStateSysCommon3Key}, /* 0xF2 , Byte 1 */ 84 { 85 sblive_miStateSysCommon3Vel}, /* 0xF2 , Byte 2 */ 86 { 87 sblive_miStateSysExNorm}, /* 0xF0, 0xF7, Normal mode */ 88 { 89 sblive_miStateSysReal} /* 0xF4 - 0xF6 ,0xF8 - 0xFF */ 90}; 91 92 93/* Installs the IRQ handler for the MPU in port */ 94 95/* and initialize parameters */ 96 97int emu10k1_mpuin_open(struct emu10k1_card *card, struct midi_openinfo *openinfo) 98{ 99 struct emu10k1_mpuin *card_mpuin = card->mpuin; 100 101 DPF(2, "emu10k1_mpuin_open\n"); 102 103 if (!(card_mpuin->status & FLAGS_AVAILABLE)) 104 return -1; 105 106 /* Copy open info and mark channel as in use */ 107 card_mpuin->openinfo = *openinfo; 108 card_mpuin->status &= ~FLAGS_AVAILABLE; /* clear */ 109 card_mpuin->status |= FLAGS_READY; /* set */ 110 card_mpuin->status &= ~FLAGS_MIDM_STARTED; /* clear */ 111 card_mpuin->firstmidiq = NULL; 112 card_mpuin->lastmidiq = NULL; 113 card_mpuin->qhead = 0; 114 card_mpuin->qtail = 0; 115 116 sblive_miStateInit(card_mpuin); 117 118 emu10k1_mpu_reset(card); 119 emu10k1_mpu_acquire(card); 120 121 return 0; 122} 123 124int emu10k1_mpuin_close(struct emu10k1_card *card) 125{ 126 struct emu10k1_mpuin *card_mpuin = card->mpuin; 127 128 DPF(2, "emu10k1_mpuin_close()\n"); 129 130 /* Check if there are pending input SysEx buffers */ 131 if (card_mpuin->firstmidiq != NULL) { 132 ERROR(); 133 return -1; 134 } 135 136 /* Disable RX interrupt */ 137 emu10k1_irq_disable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE); 138 139 emu10k1_mpu_release(card); 140 141 card_mpuin->status |= FLAGS_AVAILABLE; /* set */ 142 card_mpuin->status &= ~FLAGS_MIDM_STARTED; /* clear */ 143 144 return 0; 145} 146 147/* Adds MIDI buffer to local queue list */ 148 149int emu10k1_mpuin_add_buffer(struct emu10k1_mpuin *card_mpuin, struct midi_hdr *midihdr) 150{ 151 struct midi_queue *midiq; 152 unsigned long flags; 153 154 DPF(2, "emu10k1_mpuin_add_buffer()\n"); 155 156 /* Update MIDI buffer flags */ 157 midihdr->flags |= MIDIBUF_INQUEUE; /* set */ 158 midihdr->flags &= ~MIDIBUF_DONE; /* clear */ 159 160 if ((midiq = kmalloc(sizeof(struct midi_queue), GFP_ATOMIC)) == NULL) { 161 /* Message lost */ 162 return -1; 163 } 164 165 midiq->next = NULL; 166 midiq->qtype = 1; 167 midiq->length = midihdr->bufferlength; 168 midiq->sizeLeft = midihdr->bufferlength; 169 midiq->midibyte = midihdr->data; 170 midiq->refdata = (unsigned long) midihdr; 171 172 spin_lock_irqsave(&card_mpuin->lock, flags); 173 174 if (card_mpuin->firstmidiq == NULL) { 175 card_mpuin->firstmidiq = midiq; 176 card_mpuin->lastmidiq = midiq; 177 } else { 178 (card_mpuin->lastmidiq)->next = midiq; 179 card_mpuin->lastmidiq = midiq; 180 } 181 182 spin_unlock_irqrestore(&card_mpuin->lock, flags); 183 184 return 0; 185} 186 187/* First set the Time Stamp if MIDI IN has not started. */ 188 189/* Then enable RX Irq. */ 190 191int emu10k1_mpuin_start(struct emu10k1_card *card) 192{ 193 struct emu10k1_mpuin *card_mpuin = card->mpuin; 194 u8 dummy; 195 196 DPF(2, "emu10k1_mpuin_start()\n"); 197 198 /* Set timestamp if not set */ 199 if (card_mpuin->status & FLAGS_MIDM_STARTED) { 200 DPF(2, "Time Stamp not changed\n"); 201 } else { 202 while (!emu10k1_mpu_read_data(card, &dummy)); 203 204 card_mpuin->status |= FLAGS_MIDM_STARTED; /* set */ 205 206 /* Set new time stamp */ 207 card_mpuin->timestart = (jiffies * 1000) / HZ; 208 DPD(2, "New Time Stamp = %d\n", card_mpuin->timestart); 209 210 card_mpuin->qhead = 0; 211 card_mpuin->qtail = 0; 212 213 emu10k1_irq_enable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE); 214 } 215 216 return 0; 217} 218 219/* Disable the RX Irq. If a partial recorded buffer */ 220 221/* exist, send it up to IMIDI level. */ 222 223int emu10k1_mpuin_stop(struct emu10k1_card *card) 224{ 225 struct emu10k1_mpuin *card_mpuin = card->mpuin; 226 struct midi_queue *midiq; 227 unsigned long flags; 228 229 DPF(2, "emu10k1_mpuin_stop()\n"); 230 231 emu10k1_irq_disable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE); 232 233 card_mpuin->status &= ~FLAGS_MIDM_STARTED; /* clear */ 234 235 if (card_mpuin->firstmidiq) { 236 spin_lock_irqsave(&card_mpuin->lock, flags); 237 238 midiq = card_mpuin->firstmidiq; 239 if (midiq != NULL) { 240 if (midiq->sizeLeft == midiq->length) 241 midiq = NULL; 242 else { 243 card_mpuin->firstmidiq = midiq->next; 244 if (card_mpuin->firstmidiq == NULL) 245 card_mpuin->lastmidiq = NULL; 246 } 247 } 248 249 spin_unlock_irqrestore(&card_mpuin->lock, flags); 250 251 if (midiq) { 252 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0); 253 kfree(midiq); 254 } 255 } 256 257 return 0; 258} 259 260/* Disable the RX Irq. If any buffer */ 261 262/* exist, send it up to IMIDI level. */ 263int emu10k1_mpuin_reset(struct emu10k1_card *card) 264{ 265 struct emu10k1_mpuin *card_mpuin = card->mpuin; 266 struct midi_queue *midiq; 267 268 DPF(2, "emu10k1_mpuin_reset()\n"); 269 270 emu10k1_irq_disable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE); 271 272 while (card_mpuin->firstmidiq) { 273 midiq = card_mpuin->firstmidiq; 274 card_mpuin->firstmidiq = midiq->next; 275 276 if (midiq->sizeLeft == midiq->length) 277 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGDATA, (unsigned long) midiq, 0); 278 else 279 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0); 280 281 kfree(midiq); 282 } 283 284 card_mpuin->lastmidiq = NULL; 285 card_mpuin->status &= ~FLAGS_MIDM_STARTED; 286 287 return 0; 288} 289 290/* Passes the message with the data back to the client */ 291 292/* via IRQ & DPC callbacks to Ring 3 */ 293static int emu10k1_mpuin_callback(struct emu10k1_mpuin *card_mpuin, u32 msg, unsigned long data, u32 bytesvalid) 294{ 295 unsigned long timein; 296 struct midi_queue *midiq; 297 unsigned long callback_msg[3]; 298 struct midi_hdr *midihdr; 299 300 /* Called during ISR. The data & code touched are: 301 * 1. card_mpuin 302 * 2. The function to be called 303 */ 304 305 timein = card_mpuin->timein; 306 if (card_mpuin->timestart <= timein) 307 callback_msg[0] = timein - card_mpuin->timestart; 308 else 309 callback_msg[0] = (~0x0L - card_mpuin->timestart) + timein; 310 311 if (msg == ICARDMIDI_INDATA || msg == ICARDMIDI_INDATAERROR) { 312 callback_msg[1] = data; 313 callback_msg[2] = bytesvalid; 314 DPD(2, "emu10k1_mpuin_callback: midimsg = %#lx\n", data); 315 } else { 316 midiq = (struct midi_queue *) data; 317 midihdr = (struct midi_hdr *) midiq->refdata; 318 319 callback_msg[1] = midiq->length - midiq->sizeLeft; 320 callback_msg[2] = midiq->refdata; 321 midihdr->flags &= ~MIDIBUF_INQUEUE; 322 midihdr->flags |= MIDIBUF_DONE; 323 324 midihdr->bytesrecorded = midiq->length - midiq->sizeLeft; 325 } 326 327 /* Notify client that Sysex buffer has been sent */ 328 emu10k1_midi_callback(msg, card_mpuin->openinfo.refdata, callback_msg); 329 330 return 0; 331} 332 333void emu10k1_mpuin_bh(unsigned long refdata) 334{ 335 u8 data; 336 unsigned idx; 337 struct emu10k1_mpuin *card_mpuin = (struct emu10k1_mpuin *) refdata; 338 unsigned long flags; 339 340 while (card_mpuin->qhead != card_mpuin->qtail) { 341 spin_lock_irqsave(&card_mpuin->lock, flags); 342 idx = card_mpuin->qhead; 343 data = card_mpuin->midiq[idx].data; 344 card_mpuin->timein = card_mpuin->midiq[idx].timein; 345 idx = (idx + 1) % MIDIIN_MAX_BUFFER_SIZE; 346 card_mpuin->qhead = idx; 347 spin_unlock_irqrestore(&card_mpuin->lock, flags); 348 349 sblive_miStateEntry(card_mpuin, data); 350 } 351 352 return; 353} 354 355/* IRQ callback handler routine for the MPU in port */ 356 357int emu10k1_mpuin_irqhandler(struct emu10k1_card *card) 358{ 359 unsigned idx; 360 unsigned count; 361 u8 MPUIvalue; 362 struct emu10k1_mpuin *card_mpuin = card->mpuin; 363 364 /* IRQ service routine. The data and code touched are: 365 * 1. card_mpuin 366 */ 367 368 count = 0; 369 idx = card_mpuin->qtail; 370 371 while (1) { 372 if (emu10k1_mpu_read_data(card, &MPUIvalue) < 0) { 373 break; 374 } else { 375 ++count; 376 card_mpuin->midiq[idx].data = MPUIvalue; 377 card_mpuin->midiq[idx].timein = (jiffies * 1000) / HZ; 378 idx = (idx + 1) % MIDIIN_MAX_BUFFER_SIZE; 379 } 380 } 381 382 if (count) { 383 card_mpuin->qtail = idx; 384 385 tasklet_hi_schedule(&card_mpuin->tasklet); 386 } 387 388 return 0; 389} 390 391/*****************************************************************************/ 392 393/* Supporting functions for Midi-In Interpretation State Machine */ 394 395/*****************************************************************************/ 396 397static int sblive_miStateInit(struct emu10k1_mpuin *card_mpuin) 398{ 399 card_mpuin->status = 0; /* For MIDI running status */ 400 card_mpuin->fstatus = 0; /* For 0xFn status only */ 401 card_mpuin->curstate = STIN_PARSE; 402 card_mpuin->laststate = STIN_PARSE; 403 card_mpuin->data = 0; 404 card_mpuin->timestart = 0; 405 card_mpuin->timein = 0; 406 407 return 0; 408} 409 410static int sblive_miStateEntry(struct emu10k1_mpuin *card_mpuin, u8 data) 411{ 412 return midistatefn[card_mpuin->curstate].Fn(card_mpuin, data); 413} 414 415static int sblive_miStateParse(struct emu10k1_mpuin *card_mpuin, u8 data) 416{ 417 switch (data & 0xf0) { 418 case 0x80: 419 case 0x90: 420 case 0xA0: 421 case 0xB0: 422 case 0xE0: 423 card_mpuin->curstate = STIN_3BYTE; 424 break; 425 426 case 0xC0: 427 case 0xD0: 428 card_mpuin->curstate = STIN_2BYTE; 429 break; 430 431 case 0xF0: 432 /* System messages do not affect the previous running status! */ 433 switch (data & 0x0f) { 434 case 0x0: 435 card_mpuin->laststate = card_mpuin->curstate; 436 card_mpuin->curstate = STIN_SYS_EX_NORM; 437 438 if (card_mpuin->firstmidiq) { 439 struct midi_queue *midiq; 440 441 midiq = card_mpuin->firstmidiq; 442 *midiq->midibyte = data; 443 --midiq->sizeLeft; 444 ++midiq->midibyte; 445 } 446 447 return CTSTATUS_NEXT_BYTE; 448 449 case 0x7: 450 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, 0xf7, 0); 451 return -1; 452 453 case 0x2: 454 card_mpuin->laststate = card_mpuin->curstate; 455 card_mpuin->curstate = STIN_SYS_COMMON_3; 456 break; 457 458 case 0x1: 459 case 0x3: 460 card_mpuin->laststate = card_mpuin->curstate; 461 card_mpuin->curstate = STIN_SYS_COMMON_2; 462 break; 463 464 default: 465 /* includes 0xF4 - 0xF6, 0xF8 - 0xFF */ 466 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data); 467 } 468 469 break; 470 471 default: 472 DPF(2, "BUG: default case hit\n"); 473 return -1; 474 } 475 476 return midistatefn[card_mpuin->curstate].Fn(card_mpuin, data); 477} 478 479static int sblive_miState3Byte(struct emu10k1_mpuin *card_mpuin, u8 data) 480{ 481 u8 temp = data & 0xf0; 482 483 if (temp < 0x80) { 484 return midistatefn[STIN_3BYTE_KEY].Fn(card_mpuin, data); 485 } else if (temp <= 0xe0 && temp != 0xc0 && temp != 0xd0) { 486 card_mpuin->status = data; 487 card_mpuin->curstate = STIN_3BYTE_KEY; 488 489 return CTSTATUS_NEXT_BYTE; 490 } 491 492 return midistatefn[STIN_PARSE].Fn(card_mpuin, data); 493} 494 495static int sblive_miState3ByteKey(struct emu10k1_mpuin *card_mpuin, u8 data) 496/* byte 1 */ 497{ 498 unsigned long tmp; 499 500 if (data > 0x7f) { 501 /* Real-time messages check */ 502 if (data > 0xf7) 503 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data); 504 505 /* Invalid data! */ 506 DPF(2, "Invalid data!\n"); 507 508 card_mpuin->curstate = STIN_PARSE; 509 tmp = ((unsigned long) data) << 8; 510 tmp |= (unsigned long) card_mpuin->status; 511 512 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0); 513 514 return -1; 515 } 516 517 card_mpuin->data = data; 518 card_mpuin->curstate = STIN_3BYTE_VEL; 519 520 return CTSTATUS_NEXT_BYTE; 521} 522 523static int sblive_miState3ByteVel(struct emu10k1_mpuin *card_mpuin, u8 data) 524/* byte 2 */ 525{ 526 unsigned long tmp; 527 528 if (data > 0x7f) { 529 /* Real-time messages check */ 530 if (data > 0xf7) 531 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data); 532 533 /* Invalid data! */ 534 DPF(2, "Invalid data!\n"); 535 536 card_mpuin->curstate = STIN_PARSE; 537 tmp = ((unsigned long) data) << 8; 538 tmp |= card_mpuin->data; 539 tmp = tmp << 8; 540 tmp |= (unsigned long) card_mpuin->status; 541 542 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0); 543 544 return -1; 545 } 546 547 card_mpuin->curstate = STIN_3BYTE; 548 tmp = (unsigned long) data; 549 tmp = tmp << 8; 550 tmp |= (unsigned long) card_mpuin->data; 551 tmp = tmp << 8; 552 tmp |= (unsigned long) card_mpuin->status; 553 554 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 3); 555 556 return 0; 557} 558 559static int sblive_miState2Byte(struct emu10k1_mpuin *card_mpuin, u8 data) 560{ 561 u8 temp = data & 0xf0; 562 563 if ((temp == 0xc0) || (temp == 0xd0)) { 564 card_mpuin->status = data; 565 card_mpuin->curstate = STIN_2BYTE_KEY; 566 567 return CTSTATUS_NEXT_BYTE; 568 } 569 570 if (temp < 0x80) 571 return midistatefn[STIN_2BYTE_KEY].Fn(card_mpuin, data); 572 573 return midistatefn[STIN_PARSE].Fn(card_mpuin, data); 574} 575 576static int sblive_miState2ByteKey(struct emu10k1_mpuin *card_mpuin, u8 data) 577/* byte 1 */ 578{ 579 unsigned long tmp; 580 581 if (data > 0x7f) { 582 /* Real-time messages check */ 583 if (data > 0xf7) 584 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data); 585 586 /* Invalid data! */ 587 DPF(2, "Invalid data!\n"); 588 589 card_mpuin->curstate = STIN_PARSE; 590 tmp = (unsigned long) data; 591 tmp = tmp << 8; 592 tmp |= (unsigned long) card_mpuin->status; 593 594 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0); 595 596 return -1; 597 } 598 599 card_mpuin->curstate = STIN_2BYTE; 600 tmp = (unsigned long) data; 601 tmp = tmp << 8; 602 tmp |= (unsigned long) card_mpuin->status; 603 604 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 2); 605 606 return 0; 607} 608 609static int sblive_miStateSysCommon2(struct emu10k1_mpuin *card_mpuin, u8 data) 610{ 611 card_mpuin->fstatus = data; 612 card_mpuin->curstate = STIN_SYS_COMMON_2_KEY; 613 614 return CTSTATUS_NEXT_BYTE; 615} 616 617static int sblive_miStateSysCommon2Key(struct emu10k1_mpuin *card_mpuin, u8 data) 618/* byte 1 */ 619{ 620 unsigned long tmp; 621 622 if (data > 0x7f) { 623 /* Real-time messages check */ 624 if (data > 0xf7) 625 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data); 626 627 /* Invalid data! */ 628 DPF(2, "Invalid data!\n"); 629 630 card_mpuin->curstate = card_mpuin->laststate; 631 tmp = (unsigned long) data; 632 tmp = tmp << 8; 633 tmp |= (unsigned long) card_mpuin->fstatus; 634 635 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0); 636 637 return -1; 638 } 639 640 card_mpuin->curstate = card_mpuin->laststate; 641 tmp = (unsigned long) data; 642 tmp = tmp << 8; 643 tmp |= (unsigned long) card_mpuin->fstatus; 644 645 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 2); 646 647 return 0; 648} 649 650static int sblive_miStateSysCommon3(struct emu10k1_mpuin *card_mpuin, u8 data) 651{ 652 card_mpuin->fstatus = data; 653 card_mpuin->curstate = STIN_SYS_COMMON_3_KEY; 654 655 return CTSTATUS_NEXT_BYTE; 656} 657 658static int sblive_miStateSysCommon3Key(struct emu10k1_mpuin *card_mpuin, u8 data) 659/* byte 1 */ 660{ 661 unsigned long tmp; 662 663 if (data > 0x7f) { 664 /* Real-time messages check */ 665 if (data > 0xf7) 666 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data); 667 668 /* Invalid data! */ 669 DPF(2, "Invalid data!\n"); 670 671 card_mpuin->curstate = card_mpuin->laststate; 672 tmp = (unsigned long) data; 673 tmp = tmp << 8; 674 tmp |= (unsigned long) card_mpuin->fstatus; 675 676 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0); 677 678 return -1; 679 } 680 681 card_mpuin->data = data; 682 card_mpuin->curstate = STIN_SYS_COMMON_3_VEL; 683 684 return CTSTATUS_NEXT_BYTE; 685} 686 687static int sblive_miStateSysCommon3Vel(struct emu10k1_mpuin *card_mpuin, u8 data) 688/* byte 2 */ 689{ 690 unsigned long tmp; 691 692 if (data > 0x7f) { 693 /* Real-time messages check */ 694 if (data > 0xf7) 695 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data); 696 697 /* Invalid data! */ 698 DPF(2, "Invalid data!\n"); 699 700 card_mpuin->curstate = card_mpuin->laststate; 701 tmp = (unsigned long) data; 702 tmp = tmp << 8; 703 tmp |= (unsigned long) card_mpuin->data; 704 tmp = tmp << 8; 705 tmp |= (unsigned long) card_mpuin->fstatus; 706 707 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0); 708 709 return -1; 710 } 711 712 card_mpuin->curstate = card_mpuin->laststate; 713 tmp = (unsigned long) data; 714 tmp = tmp << 8; 715 tmp |= (unsigned long) card_mpuin->data; 716 tmp = tmp << 8; 717 tmp |= (unsigned long) card_mpuin->fstatus; 718 719 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 3); 720 721 return 0; 722} 723 724static int sblive_miStateSysExNorm(struct emu10k1_mpuin *card_mpuin, u8 data) 725{ 726 unsigned long flags; 727 728 if ((data > 0x7f) && (data != 0xf7)) { 729 /* Real-time messages check */ 730 if (data > 0xf7) 731 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data); 732 733 /* Invalid Data! */ 734 DPF(2, "Invalid data!\n"); 735 736 card_mpuin->curstate = card_mpuin->laststate; 737 738 if (card_mpuin->firstmidiq) { 739 struct midi_queue *midiq; 740 741 midiq = card_mpuin->firstmidiq; 742 *midiq->midibyte = data; 743 --midiq->sizeLeft; 744 ++midiq->midibyte; 745 746 spin_lock_irqsave(&card_mpuin->lock, flags); 747 748 card_mpuin->firstmidiq = midiq->next; 749 if (card_mpuin->firstmidiq == NULL) 750 card_mpuin->lastmidiq = NULL; 751 752 spin_unlock_irqrestore(&card_mpuin->lock, flags); 753 754 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0); 755 756 kfree(midiq); 757 } 758 759 return -1; 760 } 761 762 if (card_mpuin->firstmidiq) { 763 struct midi_queue *midiq; 764 765 midiq = card_mpuin->firstmidiq; 766 *midiq->midibyte = data; 767 --midiq->sizeLeft; 768 ++midiq->midibyte; 769 } 770 771 if (data == 0xf7) { 772 /* End of Sysex buffer */ 773 /* Send down the buffer */ 774 775 card_mpuin->curstate = card_mpuin->laststate; 776 777 if (card_mpuin->firstmidiq) { 778 struct midi_queue *midiq; 779 780 midiq = card_mpuin->firstmidiq; 781 782 spin_lock_irqsave(&card_mpuin->lock, flags); 783 784 card_mpuin->firstmidiq = midiq->next; 785 if (card_mpuin->firstmidiq == NULL) 786 card_mpuin->lastmidiq = NULL; 787 788 spin_unlock_irqrestore(&card_mpuin->lock, flags); 789 790 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGDATA, (unsigned long) midiq, 0); 791 792 kfree(midiq); 793 } 794 795 return 0; 796 } 797 798 if (card_mpuin->firstmidiq) { 799 struct midi_queue *midiq; 800 801 midiq = card_mpuin->firstmidiq; 802 803 if (midiq->sizeLeft == 0) { 804 /* Special case */ 805 806 spin_lock_irqsave(&card_mpuin->lock, flags); 807 808 card_mpuin->firstmidiq = midiq->next; 809 if (card_mpuin->firstmidiq == NULL) 810 card_mpuin->lastmidiq = NULL; 811 812 spin_unlock_irqrestore(&card_mpuin->lock, flags); 813 814 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGDATA, (unsigned long) midiq, 0); 815 816 kfree(midiq); 817 818 return CTSTATUS_NEXT_BYTE; 819 } 820 } 821 822 return CTSTATUS_NEXT_BYTE; 823} 824 825static int sblive_miStateSysReal(struct emu10k1_mpuin *card_mpuin, u8 data) 826{ 827 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, data, 1); 828 829 return CTSTATUS_NEXT_BYTE; 830} 831