2 **********************************************************************
3 * midi.c - /dev/midi interface 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
12 **********************************************************************
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.
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.
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,
29 **********************************************************************
32 #include <linux/module.h>
33 #include <linux/poll.h>
34 #include <linux/slab.h>
35 #include <linux/sched.h>
36 #include <linux/smp_lock.h>
37 #include <asm/uaccess.h>
44 #ifdef EMU10K1_SEQUENCER
45 #include "../sound_config.h"
48 static spinlock_t midi_spinlock __attribute((unused)) = SPIN_LOCK_UNLOCKED;
50 static void init_midi_hdr(struct midi_hdr *midihdr)
52 midihdr->bufferlength = MIDIIN_BUFLEN;
53 midihdr->bytesrecorded = 0;
57 static int midiin_add_buffer(struct emu10k1_mididevice *midi_dev, struct midi_hdr **midihdrptr)
59 struct midi_hdr *midihdr;
61 if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL) {
66 init_midi_hdr(midihdr);
68 if ((midihdr->data = (u8 *) kmalloc(MIDIIN_BUFLEN, GFP_KERNEL)) == NULL) {
74 if (emu10k1_mpuin_add_buffer(midi_dev->card->mpuin, midihdr) < 0) {
81 *midihdrptr = midihdr;
82 list_add_tail(&midihdr->list, &midi_dev->mid_hdrs);
87 static int emu10k1_midi_open(struct inode *inode, struct file *file)
89 int minor = iminor(inode);
90 struct emu10k1_card *card = NULL;
91 struct emu10k1_mididevice *midi_dev;
92 struct list_head *entry;
94 DPF(2, "emu10k1_midi_open()\n");
96 /* Check for correct device to open */
97 list_for_each(entry, &emu10k1_devs) {
98 card = list_entry(entry, struct emu10k1_card, list);
100 if (card->midi_dev == minor)
107 #ifdef EMU10K1_SEQUENCER
108 if (card->seq_mididev) /* card is opened by sequencer */
112 /* Wait for device to become free */
113 down(&card->open_sem);
114 while (card->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
115 if (file->f_flags & O_NONBLOCK) {
121 interruptible_sleep_on(&card->open_wait);
123 if (signal_pending(current)) {
127 down(&card->open_sem);
130 if ((midi_dev = (struct emu10k1_mididevice *) kmalloc(sizeof(*midi_dev), GFP_KERNEL)) == NULL)
133 midi_dev->card = card;
134 midi_dev->mistate = MIDIIN_STATE_STOPPED;
135 init_waitqueue_head(&midi_dev->oWait);
136 init_waitqueue_head(&midi_dev->iWait);
140 INIT_LIST_HEAD(&midi_dev->mid_hdrs);
142 if (file->f_mode & FMODE_READ) {
143 struct midi_openinfo dsCardMidiOpenInfo;
144 struct midi_hdr *midihdr1;
145 struct midi_hdr *midihdr2;
147 dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
149 if (emu10k1_mpuin_open(card, &dsCardMidiOpenInfo) < 0) {
155 /* Add two buffers to receive sysex buffer */
156 if (midiin_add_buffer(midi_dev, &midihdr1) < 0) {
161 if (midiin_add_buffer(midi_dev, &midihdr2) < 0) {
162 list_del(&midihdr1->list);
163 kfree(midihdr1->data);
170 if (file->f_mode & FMODE_WRITE) {
171 struct midi_openinfo dsCardMidiOpenInfo;
173 dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
175 if (emu10k1_mpuout_open(card, &dsCardMidiOpenInfo) < 0) {
182 file->private_data = (void *) midi_dev;
184 card->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
191 static int emu10k1_midi_release(struct inode *inode, struct file *file)
193 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
194 struct emu10k1_card *card;
198 card = midi_dev->card;
199 DPF(2, "emu10k1_midi_release()\n");
201 if (file->f_mode & FMODE_WRITE) {
202 if (!(file->f_flags & O_NONBLOCK)) {
204 while (!signal_pending(current) && (card->mpuout->firstmidiq != NULL)) {
205 DPF(4, "Cannot close - buffers not empty\n");
207 interruptible_sleep_on(&midi_dev->oWait);
212 emu10k1_mpuout_close(card);
215 if (file->f_mode & FMODE_READ) {
216 struct midi_hdr *midihdr;
218 if (midi_dev->mistate == MIDIIN_STATE_STARTED) {
219 emu10k1_mpuin_stop(card);
220 midi_dev->mistate = MIDIIN_STATE_STOPPED;
223 emu10k1_mpuin_reset(card);
224 emu10k1_mpuin_close(card);
226 while (!list_empty(&midi_dev->mid_hdrs)) {
227 midihdr = list_entry(midi_dev->mid_hdrs.next, struct midi_hdr, list);
229 list_del(midi_dev->mid_hdrs.next);
230 kfree(midihdr->data);
237 down(&card->open_sem);
238 card->open_mode &= ~((file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE));
240 wake_up_interruptible(&card->open_wait);
247 static ssize_t emu10k1_midi_read(struct file *file, char __user *buffer, size_t count, loff_t * pos)
249 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
254 DPD(4, "emu10k1_midi_read(), count %#x\n", (u32) count);
256 if (pos != &file->f_pos)
259 if (!access_ok(VERIFY_WRITE, buffer, count))
262 if (midi_dev->mistate == MIDIIN_STATE_STOPPED) {
263 if (emu10k1_mpuin_start(midi_dev->card) < 0) {
268 midi_dev->mistate = MIDIIN_STATE_STARTED;
272 cnt = MIDIIN_BUFLEN - midi_dev->ird;
274 spin_lock_irqsave(&midi_spinlock, flags);
276 if (midi_dev->icnt < cnt)
277 cnt = midi_dev->icnt;
279 spin_unlock_irqrestore(&midi_spinlock, flags);
285 if (file->f_flags & O_NONBLOCK)
286 return ret ? ret : -EAGAIN;
287 DPF(2, " Go to sleep...\n");
289 interruptible_sleep_on(&midi_dev->iWait);
291 if (signal_pending(current))
292 return ret ? ret : -ERESTARTSYS;
297 if (copy_to_user(buffer, midi_dev->iBuf + midi_dev->ird, cnt)) {
299 return ret ? ret : -EFAULT;
302 midi_dev->ird += cnt;
303 midi_dev->ird %= MIDIIN_BUFLEN;
305 spin_lock_irqsave(&midi_spinlock, flags);
307 midi_dev->icnt -= cnt;
309 spin_unlock_irqrestore(&midi_spinlock, flags);
315 if (midi_dev->icnt == 0)
322 static ssize_t emu10k1_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t * pos)
324 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
325 struct midi_hdr *midihdr;
329 DPD(4, "emu10k1_midi_write(), count=%#x\n", (u32) count);
331 if (pos != &file->f_pos)
334 if (!access_ok(VERIFY_READ, buffer, count))
337 if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL)
340 midihdr->bufferlength = count;
341 midihdr->bytesrecorded = 0;
344 if ((midihdr->data = (u8 *) kmalloc(count, GFP_KERNEL)) == NULL) {
350 if (copy_from_user(midihdr->data, buffer, count)) {
351 kfree(midihdr->data);
353 return ret ? ret : -EFAULT;
356 spin_lock_irqsave(&midi_spinlock, flags);
358 if (emu10k1_mpuout_add_buffer(midi_dev->card, midihdr) < 0) {
360 kfree(midihdr->data);
362 spin_unlock_irqrestore(&midi_spinlock, flags);
366 spin_unlock_irqrestore(&midi_spinlock, flags);
371 static unsigned int emu10k1_midi_poll(struct file *file, struct poll_table_struct *wait)
373 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
375 unsigned int mask = 0;
377 DPF(4, "emu10k1_midi_poll() called\n");
379 if (file->f_mode & FMODE_WRITE)
380 poll_wait(file, &midi_dev->oWait, wait);
382 if (file->f_mode & FMODE_READ)
383 poll_wait(file, &midi_dev->iWait, wait);
385 spin_lock_irqsave(&midi_spinlock, flags);
387 if (file->f_mode & FMODE_WRITE)
388 mask |= POLLOUT | POLLWRNORM;
390 if (file->f_mode & FMODE_READ) {
391 if (midi_dev->mistate == MIDIIN_STATE_STARTED)
392 if (midi_dev->icnt > 0)
393 mask |= POLLIN | POLLRDNORM;
396 spin_unlock_irqrestore(&midi_spinlock, flags);
401 int emu10k1_midi_callback(unsigned long msg, unsigned long refdata, unsigned long *pmsg)
403 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) refdata;
404 struct midi_hdr *midihdr = NULL;
408 DPF(4, "emu10k1_midi_callback()\n");
410 spin_lock_irqsave(&midi_spinlock, flags);
413 case ICARDMIDI_OUTLONGDATA:
414 midihdr = (struct midi_hdr *) pmsg[2];
416 kfree(midihdr->data);
418 wake_up_interruptible(&midi_dev->oWait);
422 case ICARDMIDI_INLONGDATA:
423 midihdr = (struct midi_hdr *) pmsg[2];
425 for (i = 0; i < midihdr->bytesrecorded; i++) {
426 midi_dev->iBuf[midi_dev->iwr++] = midihdr->data[i];
427 midi_dev->iwr %= MIDIIN_BUFLEN;
430 midi_dev->icnt += midihdr->bytesrecorded;
432 if (midi_dev->mistate == MIDIIN_STATE_STARTED) {
433 init_midi_hdr(midihdr);
434 emu10k1_mpuin_add_buffer(midi_dev->card->mpuin, midihdr);
435 wake_up_interruptible(&midi_dev->iWait);
439 case ICARDMIDI_INDATA:
441 u8 *pBuf = (u8 *) & pmsg[1];
442 u16 bytesvalid = pmsg[2];
444 for (i = 0; i < bytesvalid; i++) {
445 midi_dev->iBuf[midi_dev->iwr++] = pBuf[i];
446 midi_dev->iwr %= MIDIIN_BUFLEN;
449 midi_dev->icnt += bytesvalid;
452 wake_up_interruptible(&midi_dev->iWait);
455 default: /* Unknown message */
456 spin_unlock_irqrestore(&midi_spinlock, flags);
460 spin_unlock_irqrestore(&midi_spinlock, flags);
465 /* MIDI file operations */
466 struct file_operations emu10k1_midi_fops = {
467 .owner = THIS_MODULE,
468 .read = emu10k1_midi_read,
469 .write = emu10k1_midi_write,
470 .poll = emu10k1_midi_poll,
471 .open = emu10k1_midi_open,
472 .release = emu10k1_midi_release,
476 #ifdef EMU10K1_SEQUENCER
478 /* functions used for sequencer access */
480 int emu10k1_seq_midi_open(int dev, int mode,
481 void (*input) (int dev, unsigned char data),
482 void (*output) (int dev))
484 struct emu10k1_card *card;
485 struct midi_openinfo dsCardMidiOpenInfo;
486 struct emu10k1_mididevice *midi_dev;
488 if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
491 card = midi_devs[dev]->devc;
493 if (card->open_mode) /* card is opened native */
496 DPF(2, "emu10k1_seq_midi_open()\n");
498 if ((midi_dev = (struct emu10k1_mididevice *) kmalloc(sizeof(*midi_dev), GFP_KERNEL)) == NULL)
501 midi_dev->card = card;
502 midi_dev->mistate = MIDIIN_STATE_STOPPED;
503 init_waitqueue_head(&midi_dev->oWait);
504 init_waitqueue_head(&midi_dev->iWait);
508 INIT_LIST_HEAD(&midi_dev->mid_hdrs);
510 dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
512 if (emu10k1_mpuout_open(card, &dsCardMidiOpenInfo) < 0) {
517 card->seq_mididev = midi_dev;
522 void emu10k1_seq_midi_close(int dev)
524 struct emu10k1_card *card;
526 DPF(2, "emu10k1_seq_midi_close()\n");
527 if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
530 card = midi_devs[dev]->devc;
531 emu10k1_mpuout_close(card);
533 if (card->seq_mididev) {
534 kfree(card->seq_mididev);
535 card->seq_mididev = 0;
539 int emu10k1_seq_midi_out(int dev, unsigned char midi_byte)
541 struct emu10k1_card *card;
542 struct midi_hdr *midihdr;
545 if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
548 card = midi_devs[dev]->devc;
550 if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL)
553 midihdr->bufferlength = 1;
554 midihdr->bytesrecorded = 0;
557 if ((midihdr->data = (u8 *) kmalloc(1, GFP_KERNEL)) == NULL) {
563 *(midihdr->data) = midi_byte;
565 spin_lock_irqsave(&midi_spinlock, flags);
567 if (emu10k1_mpuout_add_buffer(card, midihdr) < 0) {
569 kfree(midihdr->data);
571 spin_unlock_irqrestore(&midi_spinlock, flags);
575 spin_unlock_irqrestore(&midi_spinlock, flags);
580 int emu10k1_seq_midi_start_read(int dev)
585 int emu10k1_seq_midi_end_read(int dev)
590 void emu10k1_seq_midi_kick(int dev)
594 int emu10k1_seq_midi_buffer_status(int dev)
597 struct midi_queue *queue;
598 struct emu10k1_card *card;
600 if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
605 card = midi_devs[dev]->devc;
606 queue = card->mpuout->firstmidiq;
608 while (queue != NULL) {
610 if (queue == card->mpuout->lastmidiq)