sound/oss/emu10k1/cardmi.c

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