2 **********************************************************************
3 * sblive_mi.c - MIDI UART input HAL for emu10k1 driver
4 * Copyright 1999, 2000 Creative Labs, Inc.
6 **********************************************************************
8 * Date Author Summary of changes
9 * ---- ------ ------------------
10 * October 20, 1999 Bertrand Lee base code release
11 * November 2, 1999 Alan Cox clean up
13 **********************************************************************
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.
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.
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,
30 **********************************************************************
33 #include <linux/slab.h>
34 #include <linux/jiffies.h>
42 int (*Fn) (struct emu10k1_mpuin *, u8);
46 sblive_miStateParse}, {
47 sblive_miState3Byte}, /* 0x8n, 0x9n, 0xAn, 0xBn, 0xEn */
49 sblive_miState3ByteKey}, /* Byte 1 */
51 sblive_miState3ByteVel}, /* Byte 2 */
53 sblive_miState2Byte}, /* 0xCn, 0xDn */
55 sblive_miState2ByteKey}, /* Byte 1 */
57 sblive_miStateSysCommon2}, /* 0xF1 , 0xF3 */
59 sblive_miStateSysCommon2Key}, /* 0xF1 , 0xF3, Byte 1 */
61 sblive_miStateSysCommon3}, /* 0xF2 */
63 sblive_miStateSysCommon3Key}, /* 0xF2 , Byte 1 */
65 sblive_miStateSysCommon3Vel}, /* 0xF2 , Byte 2 */
67 sblive_miStateSysExNorm}, /* 0xF0, 0xF7, Normal mode */
69 sblive_miStateSysReal} /* 0xF4 - 0xF6 ,0xF8 - 0xFF */
72 /* Installs the IRQ handler for the MPU in port */
74 /* and initialize parameters */
76 int emu10k1_mpuin_open(struct emu10k1_card *card, struct midi_openinfo *openinfo)
78 struct emu10k1_mpuin *card_mpuin = card->mpuin;
80 DPF(2, "emu10k1_mpuin_open\n");
82 if (!(card_mpuin->status & FLAGS_AVAILABLE))
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;
95 sblive_miStateInit(card_mpuin);
97 emu10k1_mpu_reset(card);
98 emu10k1_mpu_acquire(card);
103 int emu10k1_mpuin_close(struct emu10k1_card *card)
105 struct emu10k1_mpuin *card_mpuin = card->mpuin;
107 DPF(2, "emu10k1_mpuin_close()\n");
109 /* Check if there are pending input SysEx buffers */
110 if (card_mpuin->firstmidiq != NULL) {
115 /* Disable RX interrupt */
116 emu10k1_irq_disable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE);
118 emu10k1_mpu_release(card);
120 card_mpuin->status |= FLAGS_AVAILABLE; /* set */
121 card_mpuin->status &= ~FLAGS_MIDM_STARTED; /* clear */
126 /* Adds MIDI buffer to local queue list */
128 int emu10k1_mpuin_add_buffer(struct emu10k1_mpuin *card_mpuin, struct midi_hdr *midihdr)
130 struct midi_queue *midiq;
133 DPF(2, "emu10k1_mpuin_add_buffer()\n");
135 /* Update MIDI buffer flags */
136 midihdr->flags |= MIDIBUF_INQUEUE; /* set */
137 midihdr->flags &= ~MIDIBUF_DONE; /* clear */
139 if ((midiq = (struct midi_queue *) kmalloc(sizeof(struct midi_queue), GFP_ATOMIC)) == NULL) {
146 midiq->length = midihdr->bufferlength;
147 midiq->sizeLeft = midihdr->bufferlength;
148 midiq->midibyte = midihdr->data;
149 midiq->refdata = (unsigned long) midihdr;
151 spin_lock_irqsave(&card_mpuin->lock, flags);
153 if (card_mpuin->firstmidiq == NULL) {
154 card_mpuin->firstmidiq = midiq;
155 card_mpuin->lastmidiq = midiq;
157 (card_mpuin->lastmidiq)->next = midiq;
158 card_mpuin->lastmidiq = midiq;
161 spin_unlock_irqrestore(&card_mpuin->lock, flags);
166 /* First set the Time Stamp if MIDI IN has not started. */
168 /* Then enable RX Irq. */
170 int emu10k1_mpuin_start(struct emu10k1_card *card)
172 struct emu10k1_mpuin *card_mpuin = card->mpuin;
175 DPF(2, "emu10k1_mpuin_start()\n");
177 /* Set timestamp if not set */
178 if (card_mpuin->status & FLAGS_MIDM_STARTED) {
179 DPF(2, "Time Stamp not changed\n");
181 while (!emu10k1_mpu_read_data(card, &dummy));
183 card_mpuin->status |= FLAGS_MIDM_STARTED; /* set */
185 /* Set new time stamp */
186 card_mpuin->timestart = (jiffies * 1000) / HZ;
187 DPD(2, "New Time Stamp = %d\n", card_mpuin->timestart);
189 card_mpuin->qhead = 0;
190 card_mpuin->qtail = 0;
192 emu10k1_irq_enable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE);
198 /* Disable the RX Irq. If a partial recorded buffer */
200 /* exist, send it up to IMIDI level. */
202 int emu10k1_mpuin_stop(struct emu10k1_card *card)
204 struct emu10k1_mpuin *card_mpuin = card->mpuin;
205 struct midi_queue *midiq;
208 DPF(2, "emu10k1_mpuin_stop()\n");
210 emu10k1_irq_disable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE);
212 card_mpuin->status &= ~FLAGS_MIDM_STARTED; /* clear */
214 if (card_mpuin->firstmidiq) {
215 spin_lock_irqsave(&card_mpuin->lock, flags);
217 midiq = card_mpuin->firstmidiq;
219 if (midiq->sizeLeft == midiq->length)
222 card_mpuin->firstmidiq = midiq->next;
223 if (card_mpuin->firstmidiq == NULL)
224 card_mpuin->lastmidiq = NULL;
228 spin_unlock_irqrestore(&card_mpuin->lock, flags);
231 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0);
239 /* Disable the RX Irq. If any buffer */
241 /* exist, send it up to IMIDI level. */
242 int emu10k1_mpuin_reset(struct emu10k1_card *card)
244 struct emu10k1_mpuin *card_mpuin = card->mpuin;
245 struct midi_queue *midiq;
247 DPF(2, "emu10k1_mpuin_reset()\n");
249 emu10k1_irq_disable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE);
251 while (card_mpuin->firstmidiq) {
252 midiq = card_mpuin->firstmidiq;
253 card_mpuin->firstmidiq = midiq->next;
255 if (midiq->sizeLeft == midiq->length)
256 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGDATA, (unsigned long) midiq, 0);
258 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0);
263 card_mpuin->lastmidiq = NULL;
264 card_mpuin->status &= ~FLAGS_MIDM_STARTED;
269 /* Passes the message with the data back to the client */
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)
274 unsigned long timein;
275 struct midi_queue *midiq;
276 unsigned long callback_msg[3];
277 struct midi_hdr *midihdr;
279 /* Called during ISR. The data & code touched are:
281 * 2. The function to be called
284 timein = card_mpuin->timein;
285 if (card_mpuin->timestart <= timein)
286 callback_msg[0] = timein - card_mpuin->timestart;
288 callback_msg[0] = (~0x0L - card_mpuin->timestart) + timein;
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);
295 midiq = (struct midi_queue *) data;
296 midihdr = (struct midi_hdr *) midiq->refdata;
298 callback_msg[1] = midiq->length - midiq->sizeLeft;
299 callback_msg[2] = midiq->refdata;
300 midihdr->flags &= ~MIDIBUF_INQUEUE;
301 midihdr->flags |= MIDIBUF_DONE;
303 midihdr->bytesrecorded = midiq->length - midiq->sizeLeft;
306 /* Notify client that Sysex buffer has been sent */
307 emu10k1_midi_callback(msg, card_mpuin->openinfo.refdata, callback_msg);
312 void emu10k1_mpuin_bh(unsigned long refdata)
316 struct emu10k1_mpuin *card_mpuin = (struct emu10k1_mpuin *) refdata;
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);
328 sblive_miStateEntry(card_mpuin, data);
334 /* IRQ callback handler routine for the MPU in port */
336 int emu10k1_mpuin_irqhandler(struct emu10k1_card *card)
341 struct emu10k1_mpuin *card_mpuin = card->mpuin;
343 /* IRQ service routine. The data and code touched are:
348 idx = card_mpuin->qtail;
351 if (emu10k1_mpu_read_data(card, &MPUIvalue) < 0) {
355 card_mpuin->midiq[idx].data = MPUIvalue;
356 card_mpuin->midiq[idx].timein = (jiffies * 1000) / HZ;
357 idx = (idx + 1) % MIDIIN_MAX_BUFFER_SIZE;
362 card_mpuin->qtail = idx;
364 tasklet_hi_schedule(&card_mpuin->tasklet);
370 /*****************************************************************************/
372 /* Supporting functions for Midi-In Interpretation State Machine */
374 /*****************************************************************************/
376 /* FIXME: This should be a macro */
377 int sblive_miStateInit(struct emu10k1_mpuin *card_mpuin)
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;
390 /* FIXME: This should be a macro */
391 int sblive_miStateEntry(struct emu10k1_mpuin *card_mpuin, u8 data)
393 return midistatefn[card_mpuin->curstate].Fn(card_mpuin, data);
396 int sblive_miStateParse(struct emu10k1_mpuin *card_mpuin, u8 data)
398 switch (data & 0xf0) {
404 card_mpuin->curstate = STIN_3BYTE;
409 card_mpuin->curstate = STIN_2BYTE;
413 /* System messages do not affect the previous running status! */
414 switch (data & 0x0f) {
416 card_mpuin->laststate = card_mpuin->curstate;
417 card_mpuin->curstate = STIN_SYS_EX_NORM;
419 if (card_mpuin->firstmidiq) {
420 struct midi_queue *midiq;
422 midiq = card_mpuin->firstmidiq;
423 *midiq->midibyte = data;
428 return CTSTATUS_NEXT_BYTE;
431 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, 0xf7, 0);
435 card_mpuin->laststate = card_mpuin->curstate;
436 card_mpuin->curstate = STIN_SYS_COMMON_3;
441 card_mpuin->laststate = card_mpuin->curstate;
442 card_mpuin->curstate = STIN_SYS_COMMON_2;
446 /* includes 0xF4 - 0xF6, 0xF8 - 0xFF */
447 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
453 DPF(2, "BUG: default case hit\n");
457 return midistatefn[card_mpuin->curstate].Fn(card_mpuin, data);
460 int sblive_miState3Byte(struct emu10k1_mpuin *card_mpuin, u8 data)
462 u8 temp = data & 0xf0;
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;
470 return CTSTATUS_NEXT_BYTE;
473 return midistatefn[STIN_PARSE].Fn(card_mpuin, data);
476 int sblive_miState3ByteKey(struct emu10k1_mpuin *card_mpuin, u8 data)
483 /* Real-time messages check */
485 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
488 DPF(2, "Invalid data!\n");
490 card_mpuin->curstate = STIN_PARSE;
491 tmp = ((unsigned long) data) << 8;
492 tmp |= (unsigned long) card_mpuin->status;
494 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
499 card_mpuin->data = data;
500 card_mpuin->curstate = STIN_3BYTE_VEL;
502 return CTSTATUS_NEXT_BYTE;
505 int sblive_miState3ByteVel(struct emu10k1_mpuin *card_mpuin, u8 data)
512 /* Real-time messages check */
514 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
517 DPF(2, "Invalid data!\n");
519 card_mpuin->curstate = STIN_PARSE;
520 tmp = ((unsigned long) data) << 8;
521 tmp |= card_mpuin->data;
523 tmp |= (unsigned long) card_mpuin->status;
525 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
530 card_mpuin->curstate = STIN_3BYTE;
531 tmp = (unsigned long) data;
533 tmp |= (unsigned long) card_mpuin->data;
535 tmp |= (unsigned long) card_mpuin->status;
537 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 3);
542 int sblive_miState2Byte(struct emu10k1_mpuin *card_mpuin, u8 data)
544 u8 temp = data & 0xf0;
546 if ((temp == 0xc0) || (temp == 0xd0)) {
547 card_mpuin->status = data;
548 card_mpuin->curstate = STIN_2BYTE_KEY;
550 return CTSTATUS_NEXT_BYTE;
554 return midistatefn[STIN_2BYTE_KEY].Fn(card_mpuin, data);
556 return midistatefn[STIN_PARSE].Fn(card_mpuin, data);
559 int sblive_miState2ByteKey(struct emu10k1_mpuin *card_mpuin, u8 data)
566 /* Real-time messages check */
568 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
571 DPF(2, "Invalid data!\n");
573 card_mpuin->curstate = STIN_PARSE;
574 tmp = (unsigned long) data;
576 tmp |= (unsigned long) card_mpuin->status;
578 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
583 card_mpuin->curstate = STIN_2BYTE;
584 tmp = (unsigned long) data;
586 tmp |= (unsigned long) card_mpuin->status;
588 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 2);
593 int sblive_miStateSysCommon2(struct emu10k1_mpuin *card_mpuin, u8 data)
595 card_mpuin->fstatus = data;
596 card_mpuin->curstate = STIN_SYS_COMMON_2_KEY;
598 return CTSTATUS_NEXT_BYTE;
601 int sblive_miStateSysCommon2Key(struct emu10k1_mpuin *card_mpuin, u8 data)
608 /* Real-time messages check */
610 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
613 DPF(2, "Invalid data!\n");
615 card_mpuin->curstate = card_mpuin->laststate;
616 tmp = (unsigned long) data;
618 tmp |= (unsigned long) card_mpuin->fstatus;
620 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
625 card_mpuin->curstate = card_mpuin->laststate;
626 tmp = (unsigned long) data;
628 tmp |= (unsigned long) card_mpuin->fstatus;
630 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 2);
635 int sblive_miStateSysCommon3(struct emu10k1_mpuin *card_mpuin, u8 data)
637 card_mpuin->fstatus = data;
638 card_mpuin->curstate = STIN_SYS_COMMON_3_KEY;
640 return CTSTATUS_NEXT_BYTE;
643 int sblive_miStateSysCommon3Key(struct emu10k1_mpuin *card_mpuin, u8 data)
650 /* Real-time messages check */
652 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
655 DPF(2, "Invalid data!\n");
657 card_mpuin->curstate = card_mpuin->laststate;
658 tmp = (unsigned long) data;
660 tmp |= (unsigned long) card_mpuin->fstatus;
662 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
667 card_mpuin->data = data;
668 card_mpuin->curstate = STIN_SYS_COMMON_3_VEL;
670 return CTSTATUS_NEXT_BYTE;
673 int sblive_miStateSysCommon3Vel(struct emu10k1_mpuin *card_mpuin, u8 data)
680 /* Real-time messages check */
682 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
685 DPF(2, "Invalid data!\n");
687 card_mpuin->curstate = card_mpuin->laststate;
688 tmp = (unsigned long) data;
690 tmp |= (unsigned long) card_mpuin->data;
692 tmp |= (unsigned long) card_mpuin->fstatus;
694 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
699 card_mpuin->curstate = card_mpuin->laststate;
700 tmp = (unsigned long) data;
702 tmp |= (unsigned long) card_mpuin->data;
704 tmp |= (unsigned long) card_mpuin->fstatus;
706 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 3);
711 int sblive_miStateSysExNorm(struct emu10k1_mpuin *card_mpuin, u8 data)
715 if ((data > 0x7f) && (data != 0xf7)) {
716 /* Real-time messages check */
718 return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
721 DPF(2, "Invalid data!\n");
723 card_mpuin->curstate = card_mpuin->laststate;
725 if (card_mpuin->firstmidiq) {
726 struct midi_queue *midiq;
728 midiq = card_mpuin->firstmidiq;
729 *midiq->midibyte = data;
733 spin_lock_irqsave(&card_mpuin->lock, flags);
735 card_mpuin->firstmidiq = midiq->next;
736 if (card_mpuin->firstmidiq == NULL)
737 card_mpuin->lastmidiq = NULL;
739 spin_unlock_irqrestore(&card_mpuin->lock, flags);
741 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0);
749 if (card_mpuin->firstmidiq) {
750 struct midi_queue *midiq;
752 midiq = card_mpuin->firstmidiq;
753 *midiq->midibyte = data;
759 /* End of Sysex buffer */
760 /* Send down the buffer */
762 card_mpuin->curstate = card_mpuin->laststate;
764 if (card_mpuin->firstmidiq) {
765 struct midi_queue *midiq;
767 midiq = card_mpuin->firstmidiq;
769 spin_lock_irqsave(&card_mpuin->lock, flags);
771 card_mpuin->firstmidiq = midiq->next;
772 if (card_mpuin->firstmidiq == NULL)
773 card_mpuin->lastmidiq = NULL;
775 spin_unlock_irqrestore(&card_mpuin->lock, flags);
777 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGDATA, (unsigned long) midiq, 0);
785 if (card_mpuin->firstmidiq) {
786 struct midi_queue *midiq;
788 midiq = card_mpuin->firstmidiq;
790 if (midiq->sizeLeft == 0) {
793 spin_lock_irqsave(&card_mpuin->lock, flags);
795 card_mpuin->firstmidiq = midiq->next;
796 if (card_mpuin->firstmidiq == NULL)
797 card_mpuin->lastmidiq = NULL;
799 spin_unlock_irqrestore(&card_mpuin->lock, flags);
801 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGDATA, (unsigned long) midiq, 0);
805 return CTSTATUS_NEXT_BYTE;
809 return CTSTATUS_NEXT_BYTE;
812 int sblive_miStateSysReal(struct emu10k1_mpuin *card_mpuin, u8 data)
814 emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, data, 1);
816 return CTSTATUS_NEXT_BYTE;