开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
cardmi.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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.  */
  33. #include <linux/slab.h>
  34. #include <linux/sched.h>
  36. #include "hwaccess.h"
  37. #include "8010.h"
  38. #include "cardmi.h"
  39. #include "irqmgr.h"
  41. static struct {
  42. int (*Fn) (struct emu10k1_mpuin *, u8);
  43. } midistatefn[] = {
  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. };
  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)
  77. {
  78. struct emu10k1_mpuin *card_mpuin = card->mpuin;
  80. DPF(2, "emu10k1_mpuin_openn");
  82. if (!(card_mpuin->status & FLAGS_AVAILABLE))
  83. return -1;
  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);
  100. return 0;
  101. }
  103. int emu10k1_mpuin_close(struct emu10k1_card *card)
  104. {
  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) {
  111. ERROR();
  112. return -1;
  113. }
  115. /* Disable RX interrupt */
  116. emu10k1_irq_disable(card, INTE_MIDIRXENABLE);
  118. emu10k1_mpu_release(card);
  120. card_mpuin->status |= FLAGS_AVAILABLE; /* set */
  121. card_mpuin->status &= ~FLAGS_MIDM_STARTED; /* clear */
  123. return 0;
  124. }
  126. /* Adds MIDI buffer to local queue list                         */
  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;
  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) {
  140. /* Message lost */
  141. return -1;
  142. }
  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;
  151. spin_lock_irqsave(&card_mpuin->lock, flags);
  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. }
  161. spin_unlock_irqrestore(&card_mpuin->lock, flags);
  163. return 0;
  164. }
  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)
  171. {
  172. struct emu10k1_mpuin *card_mpuin = card->mpuin;
  173. u8 dummy;
  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 changedn");
  180. } else {
  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 = %dn", card_mpuin->timestart);
  189. card_mpuin->qhead = 0;
  190. card_mpuin->qtail = 0;
  192. emu10k1_irq_enable(card, INTE_MIDIRXENABLE);
  193. }
  195. return 0;
  196. }
  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)
  203. {
  204. struct emu10k1_mpuin *card_mpuin = card->mpuin;
  205. struct midi_queue *midiq;
  206. unsigned long flags;
  208. DPF(2, "emu10k1_mpuin_stop()n");
  210. emu10k1_irq_disable(card, 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;
  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. }
  228. spin_unlock_irqrestore(&card_mpuin->lock, flags);
  230. if (midiq) {
  231. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0);
  232. kfree(midiq);
  233. }
  234. }
  236. return 0;
  237. }
  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)
  243. {
  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, 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);
  257. else
  258. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0);
  260. kfree(midiq);
  261. }
  263. card_mpuin->lastmidiq = NULL;
  264. card_mpuin->status &= ~FLAGS_MIDM_STARTED;
  266. return 0;
  267. }
  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)
  273. {
  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:
  280.  * 1. card_mpuin
  281.  * 2. The function to be called
  282.  */
  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;
  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 = %#lxn", data);
  294. } else {
  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;
  304. }
  306. /* Notify client that Sysex buffer has been sent */
  307. emu10k1_midi_callback(msg, card_mpuin->openinfo.refdata, callback_msg);
  309. return 0;
  310. }
  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;
  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);
  329. }
  331. return;
  332. }
  334. /* IRQ callback handler routine for the MPU in port */
  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;
  343. /* IRQ service routine. The data and code touched are:
  344.  * 1. card_mpuin
  345.  */
  347. count = 0;
  348. idx = card_mpuin->qtail;
  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. }
  361. if (count) {
  362. card_mpuin->qtail = idx;
  364. tasklet_hi_schedule(&card_mpuin->tasklet);
  365. }
  367. return 0;
  368. }
  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)
  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;
  387. return 0;
  388. }
  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. }
  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;
  407. case 0xC0:
  408. case 0xD0:
  409. card_mpuin->curstate = STIN_2BYTE;
  410. break;
  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;
  419. if (card_mpuin->firstmidiq) {
  420. struct midi_queue *midiq;
  422. midiq = card_mpuin->firstmidiq;
  423. *midiq->midibyte = data;
  424. --midiq->sizeLeft;
  425. ++midiq->midibyte;
  426. }
  428. return CTSTATUS_NEXT_BYTE;
  430. case 0x7:
  431. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, 0xf7, 0);
  432. return -1;
  434. case 0x2:
  435. card_mpuin->laststate = card_mpuin->curstate;
  436. card_mpuin->curstate = STIN_SYS_COMMON_3;
  437. break;
  439. case 0x1:
  440. case 0x3:
  441. card_mpuin->laststate = card_mpuin->curstate;
  442. card_mpuin->curstate = STIN_SYS_COMMON_2;
  443. break;
  445. default:
  446. /* includes 0xF4 - 0xF6, 0xF8 - 0xFF */
  447. return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
  448. }
  450. break;
  452. default:
  453. DPF(2, "BUG: default case hitn");
  454. return -1;
  455. }
  457. return midistatefn[card_mpuin->curstate].Fn(card_mpuin, data);
  458. }
  460. int sblive_miState3Byte(struct emu10k1_mpuin *card_mpuin, u8 data)
  461. {
  462. u8 temp = data & 0xf0;
  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;
  470. return CTSTATUS_NEXT_BYTE;
  471. }
  473. return midistatefn[STIN_PARSE].Fn(card_mpuin, data);
  474. }
  476. int sblive_miState3ByteKey(struct emu10k1_mpuin *card_mpuin, u8 data)
  478. /* byte 1 */
  479. {
  480. unsigned long tmp;
  482. if (data > 0x7f) {
  483. /* Real-time messages check */
  484. if (data > 0xf7)
  485. return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
  487. /* Invalid 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);
  496. return -1;
  497. }
  499. card_mpuin->data = data;
  500. card_mpuin->curstate = STIN_3BYTE_VEL;
  502. return CTSTATUS_NEXT_BYTE;
  503. }
  505. int sblive_miState3ByteVel(struct emu10k1_mpuin *card_mpuin, u8 data)
  507. /* byte 2 */
  508. {
  509. unsigned long tmp;
  511. if (data > 0x7f) {
  512. /* Real-time messages check */
  513. if (data > 0xf7)
  514. return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
  516. /* Invalid data! */
  517. DPF(2, "Invalid data!n");
  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;
  525. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
  527. return -1;
  528. }
  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;
  537. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 3);
  539. return 0;
  540. }
  542. int sblive_miState2Byte(struct emu10k1_mpuin *card_mpuin, u8 data)
  543. {
  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;
  551. }
  553. if (temp < 0x80)
  554. return midistatefn[STIN_2BYTE_KEY].Fn(card_mpuin, data);
  556. return midistatefn[STIN_PARSE].Fn(card_mpuin, data);
  557. }
  559. int sblive_miState2ByteKey(struct emu10k1_mpuin *card_mpuin, u8 data)
  561. /* byte 1 */
  562. {
  563. unsigned long tmp;
  565. if (data > 0x7f) {
  566. /* Real-time messages check */
  567. if (data > 0xf7)
  568. return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
  570. /* Invalid data! */
  571. DPF(2, "Invalid data!n");
  573. card_mpuin->curstate = STIN_PARSE;
  574. tmp = (unsigned long) data;
  575. tmp = tmp << 8;
  576. tmp |= (unsigned long) card_mpuin->status;
  578. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
  580. return -1;
  581. }
  583. card_mpuin->curstate = STIN_2BYTE;
  584. tmp = (unsigned long) data;
  585. tmp = tmp << 8;
  586. tmp |= (unsigned long) card_mpuin->status;
  588. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 2);
  590. return 0;
  591. }
  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;
  598. return CTSTATUS_NEXT_BYTE;
  599. }
  601. int sblive_miStateSysCommon2Key(struct emu10k1_mpuin *card_mpuin, u8 data)
  603. /* byte 1 */
  604. {
  605. unsigned long tmp;
  607. if (data > 0x7f) {
  608. /* Real-time messages check */
  609. if (data > 0xf7)
  610. return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
  612. /* Invalid data! */
  613. DPF(2, "Invalid data!n");
  615. card_mpuin->curstate = card_mpuin->laststate;
  616. tmp = (unsigned long) data;
  617. tmp = tmp << 8;
  618. tmp |= (unsigned long) card_mpuin->fstatus;
  620. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
  622. return -1;
  623. }
  625. card_mpuin->curstate = card_mpuin->laststate;
  626. tmp = (unsigned long) data;
  627. tmp = tmp << 8;
  628. tmp |= (unsigned long) card_mpuin->fstatus;
  630. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 2);
  632. return 0;
  633. }
  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;
  640. return CTSTATUS_NEXT_BYTE;
  641. }
  643. int sblive_miStateSysCommon3Key(struct emu10k1_mpuin *card_mpuin, u8 data)
  645. /* byte 1 */
  646. {
  647. unsigned long tmp;
  649. if (data > 0x7f) {
  650. /* Real-time messages check */
  651. if (data > 0xf7)
  652. return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
  654. /* Invalid data! */
  655. DPF(2, "Invalid data!n");
  657. card_mpuin->curstate = card_mpuin->laststate;
  658. tmp = (unsigned long) data;
  659. tmp = tmp << 8;
  660. tmp |= (unsigned long) card_mpuin->fstatus;
  662. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
  664. return -1;
  665. }
  667. card_mpuin->data = data;
  668. card_mpuin->curstate = STIN_SYS_COMMON_3_VEL;
  670. return CTSTATUS_NEXT_BYTE;
  671. }
  673. int sblive_miStateSysCommon3Vel(struct emu10k1_mpuin *card_mpuin, u8 data)
  675. /* byte 2 */
  676. {
  677. unsigned long tmp;
  679. if (data > 0x7f) {
  680. /* Real-time messages check */
  681. if (data > 0xf7)
  682. return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);
  684. /* Invalid data! */
  685. DPF(2, "Invalid data!n");
  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;
  694. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);
  696. return -1;
  697. }
  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;
  706. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 3);
  708. return 0;
  709. }
  711. int sblive_miStateSysExNorm(struct emu10k1_mpuin *card_mpuin, u8 data)
  712. {
  713. unsigned long flags;
  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);
  720. /* Invalid 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;
  730. --midiq->sizeLeft;
  731. ++midiq->midibyte;
  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);
  743. kfree(midiq);
  744. }
  746. return -1;
  747. }
  749. if (card_mpuin->firstmidiq) {
  750. struct midi_queue *midiq;
  752. midiq = card_mpuin->firstmidiq;
  753. *midiq->midibyte = data;
  754. --midiq->sizeLeft;
  755. ++midiq->midibyte;
  756. }
  758. if (data == 0xf7) {
  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);
  779. kfree(midiq);
  780. }
  782. return 0;
  783. }
  785. if (card_mpuin->firstmidiq) {
  786. struct midi_queue *midiq;
  788. midiq = card_mpuin->firstmidiq;
  790. if (midiq->sizeLeft == 0) {
  791. /* Special case */
  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);
  803. kfree(midiq);
  805. return CTSTATUS_NEXT_BYTE;
  806. }
  807. }
  809. return CTSTATUS_NEXT_BYTE;
  810. }
  812. int sblive_miStateSysReal(struct emu10k1_mpuin *card_mpuin, u8 data)
  813. {
  814. emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, data, 1);
  816. return CTSTATUS_NEXT_BYTE;
  817. }