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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
midi.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：14k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

midi.c：源码内容
  1. /*
  2.  **********************************************************************
  3.  *     midi.c - /dev/midi interface 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.  *
  12.  **********************************************************************
  13.  *
  14.  *     This program is free software; you can redistribute it and/or
  15.  *     modify it under the terms of the GNU General Public License as
  16.  *     published by the Free Software Foundation; either version 2 of
  17.  *     the License, or (at your option) any later version.
  18.  *
  19.  *     This program is distributed in the hope that it will be useful,
  20.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22.  *     GNU General Public License for more details.
  23.  *
  24.  *     You should have received a copy of the GNU General Public
  25.  *     License along with this program; if not, write to the Free
  26.  *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  27.  *     USA.
  28.  *
  29.  **********************************************************************
  30.  */
  32. #define __NO_VERSION__
  33. #include <linux/module.h>
  34. #include <linux/poll.h>
  35. #include <linux/slab.h>
  36. #include <linux/version.h>
  37. #include <linux/sched.h>
  38. #include <linux/smp_lock.h>
  39. #include <asm/uaccess.h>
  41. #include "hwaccess.h"
  42. #include "cardmo.h"
  43. #include "cardmi.h"
  44. #include "midi.h"
  46. #ifdef EMU10K1_SEQUENCER
  47. #include "../sound_config.h"
  48. #endif
  50. static spinlock_t midi_spinlock __attribute((unused)) = SPIN_LOCK_UNLOCKED;
  52. static void init_midi_hdr(struct midi_hdr *midihdr)
  53. {
  54. midihdr->bufferlength = MIDIIN_BUFLEN;
  55. midihdr->bytesrecorded = 0;
  56. midihdr->flags = 0;
  57. }
  59. static int midiin_add_buffer(struct emu10k1_mididevice *midi_dev, struct midi_hdr **midihdrptr)
  60. {
  61. struct midi_hdr *midihdr;
  63. if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL) {
  64. ERROR();
  65. return -EINVAL;
  66. }
  68. init_midi_hdr(midihdr);
  70. if ((midihdr->data = (u8 *) kmalloc(MIDIIN_BUFLEN, GFP_KERNEL)) == NULL) {
  71. ERROR();
  72. kfree(midihdr);
  73. return -1;
  74. }
  76. if (emu10k1_mpuin_add_buffer(midi_dev->card->mpuin, midihdr) < 0) {
  77. ERROR();
  78. kfree(midihdr->data);
  79. kfree(midihdr);
  80. return -1;
  81. }
  83. *midihdrptr = midihdr;
  84. list_add_tail(&midihdr->list, &midi_dev->mid_hdrs);
  86. return 0;
  87. }
  89. static int emu10k1_midi_open(struct inode *inode, struct file *file)
  90. {
  91. int minor = MINOR(inode->i_rdev);
  92. struct emu10k1_card *card = NULL;
  93. struct emu10k1_mididevice *midi_dev;
  94. struct list_head *entry;
  96. DPF(2, "emu10k1_midi_open()n");
  98. /* Check for correct device to open */
  99. list_for_each(entry, &emu10k1_devs) {
  100. card = list_entry(entry, struct emu10k1_card, list);
  102. if (card->midi_dev == minor)
  103. goto match;
  104. }
  106. return -ENODEV;
  108. match:
  109. #ifdef EMU10K1_SEQUENCER
  110. if (card->seq_mididev) /* card is opened by sequencer */
  111. return -EBUSY;
  112. #endif
  114. /* Wait for device to become free */
  115. down(&card->open_sem);
  116. while (card->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
  117. if (file->f_flags & O_NONBLOCK) {
  118. up(&card->open_sem);
  119. return -EBUSY;
  120. }
  122. up(&card->open_sem);
  123. interruptible_sleep_on(&card->open_wait);
  125. if (signal_pending(current)) {
  126. return -ERESTARTSYS;
  127. }
  129. down(&card->open_sem);
  130. }
  132. if ((midi_dev = (struct emu10k1_mididevice *) kmalloc(sizeof(*midi_dev), GFP_KERNEL)) == NULL)
  133. return -EINVAL;
  135. midi_dev->card = card;
  136. midi_dev->mistate = MIDIIN_STATE_STOPPED;
  137. init_waitqueue_head(&midi_dev->oWait);
  138. init_waitqueue_head(&midi_dev->iWait);
  139. midi_dev->ird = 0;
  140. midi_dev->iwr = 0;
  141. midi_dev->icnt = 0;
  142. INIT_LIST_HEAD(&midi_dev->mid_hdrs);
  144. if (file->f_mode & FMODE_READ) {
  145. struct midi_openinfo dsCardMidiOpenInfo;
  146. struct midi_hdr *midihdr1;
  147. struct midi_hdr *midihdr2;
  149. dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
  151. if (emu10k1_mpuin_open(card, &dsCardMidiOpenInfo) < 0) {
  152. ERROR();
  153. kfree(midi_dev);
  154. return -ENODEV;
  155. }
  157. /* Add two buffers to receive sysex buffer */
  158. if (midiin_add_buffer(midi_dev, &midihdr1) < 0) {
  159. kfree(midi_dev);
  160. return -ENODEV;
  161. }
  163. if (midiin_add_buffer(midi_dev, &midihdr2) < 0) {
  164. list_del(&midihdr1->list);
  165. kfree(midihdr1->data);
  166. kfree(midihdr1);
  167. kfree(midi_dev);
  168. return -ENODEV;
  169. }
  170. }
  172. if (file->f_mode & FMODE_WRITE) {
  173. struct midi_openinfo dsCardMidiOpenInfo;
  175. dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
  177. if (emu10k1_mpuout_open(card, &dsCardMidiOpenInfo) < 0) {
  178. ERROR();
  179. kfree(midi_dev);
  180. return -ENODEV;
  181. }
  182. }
  184. file->private_data = (void *) midi_dev;
  186. card->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
  188. up(&card->open_sem);
  190. return 0;
  191. }
  193. static int emu10k1_midi_release(struct inode *inode, struct file *file)
  194. {
  195. struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
  196. struct emu10k1_card *card;
  198. lock_kernel();
  200. card = midi_dev->card;
  201. DPF(2, "emu10k1_midi_release()n");
  203. if (file->f_mode & FMODE_WRITE) {
  204. if (!(file->f_flags & O_NONBLOCK)) {
  206. while (!signal_pending(current) && (card->mpuout->firstmidiq != NULL)) {
  207. DPF(4, "Cannot close - buffers not emptyn");
  209. interruptible_sleep_on(&midi_dev->oWait);
  211. }
  212. }
  214. emu10k1_mpuout_close(card);
  215. }
  217. if (file->f_mode & FMODE_READ) {
  218. struct midi_hdr *midihdr;
  220. if (midi_dev->mistate == MIDIIN_STATE_STARTED) {
  221. emu10k1_mpuin_stop(card);
  222. midi_dev->mistate = MIDIIN_STATE_STOPPED;
  223. }
  225. emu10k1_mpuin_reset(card);
  226. emu10k1_mpuin_close(card);
  228. while (!list_empty(&midi_dev->mid_hdrs)) {
  229. midihdr = list_entry(midi_dev->mid_hdrs.next, struct midi_hdr, list);
  231. list_del(midi_dev->mid_hdrs.next);
  232. kfree(midihdr->data);
  233. kfree(midihdr);
  234. }
  235. }
  237. kfree(midi_dev);
  239. down(&card->open_sem);
  240. card->open_mode &= ~((file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE));
  241. up(&card->open_sem);
  242. wake_up_interruptible(&card->open_wait);
  244. unlock_kernel();
  246. return 0;
  247. }
  249. static ssize_t emu10k1_midi_read(struct file *file, char *buffer, size_t count, loff_t * pos)
  250. {
  251. struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
  252. ssize_t ret = 0;
  253. u16 cnt;
  254. unsigned long flags;
  256. DPD(4, "emu10k1_midi_read(), count %#xn", (u32) count);
  258. if (pos != &file->f_pos)
  259. return -ESPIPE;
  261. if (!access_ok(VERIFY_WRITE, buffer, count))
  262. return -EFAULT;
  264. if (midi_dev->mistate == MIDIIN_STATE_STOPPED) {
  265. if (emu10k1_mpuin_start(midi_dev->card) < 0) {
  266. ERROR();
  267. return -EINVAL;
  268. }
  270. midi_dev->mistate = MIDIIN_STATE_STARTED;
  271. }
  273. while (count > 0) {
  274. cnt = MIDIIN_BUFLEN - midi_dev->ird;
  276. spin_lock_irqsave(&midi_spinlock, flags);
  278. if (midi_dev->icnt < cnt)
  279. cnt = midi_dev->icnt;
  281. spin_unlock_irqrestore(&midi_spinlock, flags);
  283. if (cnt > count)
  284. cnt = count;
  286. if (cnt <= 0) {
  287. if (file->f_flags & O_NONBLOCK)
  288. return ret ? ret : -EAGAIN;
  289. DPF(2, " Go to sleep...n");
  291. interruptible_sleep_on(&midi_dev->iWait);
  293. if (signal_pending(current))
  294. return ret ? ret : -ERESTARTSYS;
  296. continue;
  297. }
  299. if (copy_to_user(buffer, midi_dev->iBuf + midi_dev->ird, cnt)) {
  300. ERROR();
  301. return ret ? ret : -EFAULT;
  302. }
  304. midi_dev->ird += cnt;
  305. midi_dev->ird %= MIDIIN_BUFLEN;
  307. spin_lock_irqsave(&midi_spinlock, flags);
  309. midi_dev->icnt -= cnt;
  311. spin_unlock_irqrestore(&midi_spinlock, flags);
  313. count -= cnt;
  314. buffer += cnt;
  315. ret += cnt;
  317. if (midi_dev->icnt == 0)
  318. break;
  319. }
  321. return ret;
  322. }
  324. static ssize_t emu10k1_midi_write(struct file *file, const char *buffer, size_t count, loff_t * pos)
  325. {
  326. struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
  327. struct midi_hdr *midihdr;
  328. ssize_t ret = 0;
  329. unsigned long flags;
  331. DPD(4, "emu10k1_midi_write(), count=%#xn", (u32) count);
  333. if (pos != &file->f_pos)
  334. return -ESPIPE;
  336. if (!access_ok(VERIFY_READ, buffer, count))
  337. return -EFAULT;
  339. if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL)
  340. return -EINVAL;
  342. midihdr->bufferlength = count;
  343. midihdr->bytesrecorded = 0;
  344. midihdr->flags = 0;
  346. if ((midihdr->data = (u8 *) kmalloc(count, GFP_KERNEL)) == NULL) {
  347. ERROR();
  348. kfree(midihdr);
  349. return -EINVAL;
  350. }
  352. if (copy_from_user(midihdr->data, buffer, count)) {
  353. kfree(midihdr->data);
  354. kfree(midihdr);
  355. return ret ? ret : -EFAULT;
  356. }
  358. spin_lock_irqsave(&midi_spinlock, flags);
  360. if (emu10k1_mpuout_add_buffer(midi_dev->card, midihdr) < 0) {
  361. ERROR();
  362. kfree(midihdr->data);
  363. kfree(midihdr);
  364. spin_unlock_irqrestore(&midi_spinlock, flags);
  365. return -EINVAL;
  366. }
  368. spin_unlock_irqrestore(&midi_spinlock, flags);
  370. return count;
  371. }
  373. static unsigned int emu10k1_midi_poll(struct file *file, struct poll_table_struct *wait)
  374. {
  375. struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
  376. unsigned long flags;
  377. unsigned int mask = 0;
  379. DPF(4, "emu10k1_midi_poll() calledn");
  381. if (file->f_mode & FMODE_WRITE)
  382. poll_wait(file, &midi_dev->oWait, wait);
  384. if (file->f_mode & FMODE_READ)
  385. poll_wait(file, &midi_dev->iWait, wait);
  387. spin_lock_irqsave(&midi_spinlock, flags);
  389. if (file->f_mode & FMODE_WRITE)
  390. mask |= POLLOUT | POLLWRNORM;
  392. if (file->f_mode & FMODE_READ) {
  393. if (midi_dev->mistate == MIDIIN_STATE_STARTED)
  394. if (midi_dev->icnt > 0)
  395. mask |= POLLIN | POLLRDNORM;
  396. }
  398. spin_unlock_irqrestore(&midi_spinlock, flags);
  400. return mask;
  401. }
  403. int emu10k1_midi_callback(unsigned long msg, unsigned long refdata, unsigned long *pmsg)
  404. {
  405. struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) refdata;
  406. struct midi_hdr *midihdr = NULL;
  407. unsigned long flags;
  408. int i;
  410. DPF(4, "emu10k1_midi_callback()n");
  412. spin_lock_irqsave(&midi_spinlock, flags);
  414. switch (msg) {
  415. case ICARDMIDI_OUTLONGDATA:
  416. midihdr = (struct midi_hdr *) pmsg[2];
  418. kfree(midihdr->data);
  419. kfree(midihdr);
  420. wake_up_interruptible(&midi_dev->oWait);
  422. break;
  424. case ICARDMIDI_INLONGDATA:
  425. midihdr = (struct midi_hdr *) pmsg[2];
  427. for (i = 0; i < midihdr->bytesrecorded; i++) {
  428. midi_dev->iBuf[midi_dev->iwr++] = midihdr->data[i];
  429. midi_dev->iwr %= MIDIIN_BUFLEN;
  430. }
  432. midi_dev->icnt += midihdr->bytesrecorded;
  434. if (midi_dev->mistate == MIDIIN_STATE_STARTED) {
  435. init_midi_hdr(midihdr);
  436. emu10k1_mpuin_add_buffer(midi_dev->card->mpuin, midihdr);
  437. wake_up_interruptible(&midi_dev->iWait);
  438. }
  439. break;
  441. case ICARDMIDI_INDATA:
  442. {
  443. u8 *pBuf = (u8 *) & pmsg[1];
  444. u16 bytesvalid = pmsg[2];
  446. for (i = 0; i < bytesvalid; i++) {
  447. midi_dev->iBuf[midi_dev->iwr++] = pBuf[i];
  448. midi_dev->iwr %= MIDIIN_BUFLEN;
  449. }
  451. midi_dev->icnt += bytesvalid;
  452. }
  454. wake_up_interruptible(&midi_dev->iWait);
  455. break;
  457. default: /* Unknown message */
  458. spin_unlock_irqrestore(&midi_spinlock, flags);
  459. return -1;
  460. }
  462. spin_unlock_irqrestore(&midi_spinlock, flags);
  464. return 0;
  465. }
  467. /* MIDI file operations */
  468. struct file_operations emu10k1_midi_fops = {
  469. owner: THIS_MODULE,
  470. read: emu10k1_midi_read,
  471. write: emu10k1_midi_write,
  472. poll: emu10k1_midi_poll,
  473. open: emu10k1_midi_open,
  474. release: emu10k1_midi_release,
  475. };
  478. #ifdef EMU10K1_SEQUENCER
  480. /* functions used for sequencer access */
  482. int emu10k1_seq_midi_open(int dev, int mode,
  483. void (*input) (int dev, unsigned char data),
  484. void (*output) (int dev))
  485. {
  486. struct emu10k1_card *card;
  487. struct midi_openinfo dsCardMidiOpenInfo;
  488. struct emu10k1_mididevice *midi_dev;
  490. if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
  491. return -EINVAL;
  493. card = midi_devs[dev]->devc;
  495. if (card->open_mode) /* card is opened native */
  496. return -EBUSY;
  498. DPF(2, "emu10k1_seq_midi_open()n");
  500. if ((midi_dev = (struct emu10k1_mididevice *) kmalloc(sizeof(*midi_dev), GFP_KERNEL)) == NULL)
  501. return -EINVAL;
  503. midi_dev->card = card;
  504. midi_dev->mistate = MIDIIN_STATE_STOPPED;
  505. init_waitqueue_head(&midi_dev->oWait);
  506. init_waitqueue_head(&midi_dev->iWait);
  507. midi_dev->ird = 0;
  508. midi_dev->iwr = 0;
  509. midi_dev->icnt = 0;
  510. INIT_LIST_HEAD(&midi_dev->mid_hdrs);
  512. dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
  514. if (emu10k1_mpuout_open(card, &dsCardMidiOpenInfo) < 0) {
  515. ERROR();
  516. return -ENODEV;
  517. }
  519. card->seq_mididev = midi_dev;
  521. return 0;
  522. }
  524. void emu10k1_seq_midi_close(int dev)
  525. {
  526. struct emu10k1_card *card;
  528. DPF(2, "emu10k1_seq_midi_close()n");
  529. if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
  530. return;
  532. card = midi_devs[dev]->devc;
  533. emu10k1_mpuout_close(card);
  535. if (card->seq_mididev) {
  536. kfree(card->seq_mididev);
  537. card->seq_mididev = 0;
  538. }
  539. }
  541. int emu10k1_seq_midi_out(int dev, unsigned char midi_byte)
  542. {
  543. struct emu10k1_card *card;
  544. struct midi_hdr *midihdr;
  545. unsigned long flags;
  547. if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
  548. return -EINVAL;
  550. card = midi_devs[dev]->devc;
  552. if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL)
  553. return -EINVAL;
  555. midihdr->bufferlength = 1;
  556. midihdr->bytesrecorded = 0;
  557. midihdr->flags = 0;
  559. if ((midihdr->data = (u8 *) kmalloc(1, GFP_KERNEL)) == NULL) {
  560. ERROR();
  561. kfree(midihdr);
  562. return -EINVAL;
  563. }
  565. *(midihdr->data) = midi_byte;
  567. spin_lock_irqsave(&midi_spinlock, flags);
  569. if (emu10k1_mpuout_add_buffer(card, midihdr) < 0) {
  570. ERROR();
  571. kfree(midihdr->data);
  572. kfree(midihdr);
  573. spin_unlock_irqrestore(&midi_spinlock, flags);
  574. return -EINVAL;
  575. }
  577. spin_unlock_irqrestore(&midi_spinlock, flags);
  579. return 1;
  580. }
  582. int emu10k1_seq_midi_start_read(int dev)
  583. {
  584. return 0;
  585. }
  587. int emu10k1_seq_midi_end_read(int dev)
  588. {
  589. return 0;
  590. }
  592. void emu10k1_seq_midi_kick(int dev)
  593. {
  594. }
  596. int emu10k1_seq_midi_buffer_status(int dev)
  597. {
  598. int count;
  599. struct midi_queue *queue;
  600. struct emu10k1_card *card;
  602. if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
  603. return -EINVAL;
  605. count = 0;
  607. card = midi_devs[dev]->devc;
  608. queue = card->mpuout->firstmidiq;
  610. while (queue != NULL) {
  611. count++;
  612. if (queue == card->mpuout->lastmidiq)
  613. break;
  615. queue = queue->next;
  616. }
  618. return count;
  619. }
  621. #endif