/* ********************************************************************** * midi.c - /dev/midi interface for emu10k1 driver * Copyright 1999, 2000 Creative Labs, Inc. * ********************************************************************** * * Date Author Summary of changes * ---- ------ ------------------ * October 20, 1999 Bertrand Lee base code release * ********************************************************************** * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this program; if not, write to the Free * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, * USA. * ********************************************************************** */ #include <linux/module.h> #include <linux/poll.h> #include <linux/slab.h> #include <linux/sched.h> #include <linux/smp_lock.h> #include <asm/uaccess.h> #include "hwaccess.h" #include "cardmo.h" #include "cardmi.h" #include "midi.h" #ifdef EMU10K1_SEQUENCER #include "../sound_config.h" #endif static DEFINE_SPINLOCK(midi_spinlock __attribute((unused))); static void init_midi_hdr(struct midi_hdr *midihdr) { midihdr->bufferlength = MIDIIN_BUFLEN; midihdr->bytesrecorded = 0; midihdr->flags = 0; } static int midiin_add_buffer(struct emu10k1_mididevice *midi_dev, struct midi_hdr **midihdrptr) { struct midi_hdr *midihdr; if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL) { ERROR(); return -EINVAL; } init_midi_hdr(midihdr); if ((midihdr->data = (u8 *) kmalloc(MIDIIN_BUFLEN, GFP_KERNEL)) == NULL) { ERROR(); kfree(midihdr); return -1; } if (emu10k1_mpuin_add_buffer(midi_dev->card->mpuin, midihdr) < 0) { ERROR(); kfree(midihdr->data); kfree(midihdr); return -1; } *midihdrptr = midihdr; list_add_tail(&midihdr->list, &midi_dev->mid_hdrs); return 0; } static int emu10k1_midi_open(struct inode *inode, struct file *file) { int minor = iminor(inode); struct emu10k1_card *card = NULL; struct emu10k1_mididevice *midi_dev; struct list_head *entry; DPF(2, "emu10k1_midi_open()\n"); /* Check for correct device to open */ list_for_each(entry, &emu10k1_devs) { card = list_entry(entry, struct emu10k1_card, list); if (card->midi_dev == minor) goto match; } return -ENODEV; match: #ifdef EMU10K1_SEQUENCER if (card->seq_mididev) /* card is opened by sequencer */ return -EBUSY; #endif /* Wait for device to become free */ down(&card->open_sem); while (card->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) { if (file->f_flags & O_NONBLOCK) { up(&card->open_sem); return -EBUSY; } up(&card->open_sem); interruptible_sleep_on(&card->open_wait); if (signal_pending(current)) { return -ERESTARTSYS; } down(&card->open_sem); } if ((midi_dev = (struct emu10k1_mididevice *) kmalloc(sizeof(*midi_dev), GFP_KERNEL)) == NULL) return -EINVAL; midi_dev->card = card; midi_dev->mistate = MIDIIN_STATE_STOPPED; init_waitqueue_head(&midi_dev->oWait); init_waitqueue_head(&midi_dev->iWait); midi_dev->ird = 0; midi_dev->iwr = 0; midi_dev->icnt = 0; INIT_LIST_HEAD(&midi_dev->mid_hdrs); if (file->f_mode & FMODE_READ) { struct midi_openinfo dsCardMidiOpenInfo; struct midi_hdr *midihdr1; struct midi_hdr *midihdr2; dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev; if (emu10k1_mpuin_open(card, &dsCardMidiOpenInfo) < 0) { ERROR(); kfree(midi_dev); return -ENODEV; } /* Add two buffers to receive sysex buffer */ if (midiin_add_buffer(midi_dev, &midihdr1) < 0) { kfree(midi_dev); return -ENODEV; } if (midiin_add_buffer(midi_dev, &midihdr2) < 0) { list_del(&midihdr1->list); kfree(midihdr1->data); kfree(midihdr1); kfree(midi_dev); return -ENODEV; } } if (file->f_mode & FMODE_WRITE) { struct midi_openinfo dsCardMidiOpenInfo; dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev; if (emu10k1_mpuout_open(card, &dsCardMidiOpenInfo) < 0) { ERROR(); kfree(midi_dev); return -ENODEV; } } file->private_data = (void *) midi_dev; card->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE); up(&card->open_sem); return nonseekable_open(inode, file); } static int emu10k1_midi_release(struct inode *inode, struct file *file) { struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data; struct emu10k1_card *card; lock_kernel(); card = midi_dev->card; DPF(2, "emu10k1_midi_release()\n"); if (file->f_mode & FMODE_WRITE) { if (!(file->f_flags & O_NONBLOCK)) { while (!signal_pending(current) && (card->mpuout->firstmidiq != NULL)) { DPF(4, "Cannot close - buffers not empty\n"); interruptible_sleep_on(&midi_dev->oWait); } } emu10k1_mpuout_close(card); } if (file->f_mode & FMODE_READ) { struct midi_hdr *midihdr; if (midi_dev->mistate == MIDIIN_STATE_STARTED) { emu10k1_mpuin_stop(card); midi_dev->mistate = MIDIIN_STATE_STOPPED; } emu10k1_mpuin_reset(card); emu10k1_mpuin_close(card); while (!list_empty(&midi_dev->mid_hdrs)) { midihdr = list_entry(midi_dev->mid_hdrs.next, struct midi_hdr, list); list_del(midi_dev->mid_hdrs.next); kfree(midihdr->data); kfree(midihdr); } } kfree(midi_dev); down(&card->open_sem); card->open_mode &= ~((file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE)); up(&card->open_sem); wake_up_interruptible(&card->open_wait); unlock_kernel(); return 0; } static ssize_t emu10k1_midi_read(struct file *file, char __user *buffer, size_t count, loff_t * pos) { struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data; ssize_t ret = 0; u16 cnt; unsigned long flags; DPD(4, "emu10k1_midi_read(), count %#x\n", (u32) count); if (!access_ok(VERIFY_WRITE, buffer, count)) return -EFAULT; if (midi_dev->mistate == MIDIIN_STATE_STOPPED) { if (emu10k1_mpuin_start(midi_dev->card) < 0) { ERROR(); return -EINVAL; } midi_dev->mistate = MIDIIN_STATE_STARTED; } while (count > 0) { cnt = MIDIIN_BUFLEN - midi_dev->ird; spin_lock_irqsave(&midi_spinlock, flags); if (midi_dev->icnt < cnt) cnt = midi_dev->icnt; spin_unlock_irqrestore(&midi_spinlock, flags); if (cnt > count) cnt = count; if (cnt <= 0) { if (file->f_flags & O_NONBLOCK) return ret ? ret : -EAGAIN; DPF(2, " Go to sleep...\n"); interruptible_sleep_on(&midi_dev->iWait); if (signal_pending(current)) return ret ? ret : -ERESTARTSYS; continue; } if (copy_to_user(buffer, midi_dev->iBuf + midi_dev->ird, cnt)) { ERROR(); return ret ? ret : -EFAULT; } midi_dev->ird += cnt; midi_dev->ird %= MIDIIN_BUFLEN; spin_lock_irqsave(&midi_spinlock, flags); midi_dev->icnt -= cnt; spin_unlock_irqrestore(&midi_spinlock, flags); count -= cnt; buffer += cnt; ret += cnt; if (midi_dev->icnt == 0) break; } return ret; } static ssize_t emu10k1_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t * pos) { struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data; struct midi_hdr *midihdr; unsigned long flags; DPD(4, "emu10k1_midi_write(), count=%#x\n", (u32) count); if (!access_ok(VERIFY_READ, buffer, count)) return -EFAULT; if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL) return -EINVAL; midihdr->bufferlength = count; midihdr->bytesrecorded = 0; midihdr->flags = 0; if ((midihdr->data = (u8 *) kmalloc(count, GFP_KERNEL)) == NULL) { ERROR(); kfree(midihdr); return -EINVAL; } if (copy_from_user(midihdr->data, buffer, count)) { kfree(midihdr->data); kfree(midihdr); return -EFAULT; } spin_lock_irqsave(&midi_spinlock, flags); if (emu10k1_mpuout_add_buffer(midi_dev->card, midihdr) < 0) { ERROR(); kfree(midihdr->data); kfree(midihdr); spin_unlock_irqrestore(&midi_spinlock, flags); return -EINVAL; } spin_unlock_irqrestore(&midi_spinlock, flags); return count; } static unsigned int emu10k1_midi_poll(struct file *file, struct poll_table_struct *wait) { struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data; unsigned long flags; unsigned int mask = 0; DPF(4, "emu10k1_midi_poll() called\n"); if (file->f_mode & FMODE_WRITE) poll_wait(file, &midi_dev->oWait, wait); if (file->f_mode & FMODE_READ) poll_wait(file, &midi_dev->iWait, wait); spin_lock_irqsave(&midi_spinlock, flags); if (file->f_mode & FMODE_WRITE) mask |= POLLOUT | POLLWRNORM; if (file->f_mode & FMODE_READ) { if (midi_dev->mistate == MIDIIN_STATE_STARTED) if (midi_dev->icnt > 0) mask |= POLLIN | POLLRDNORM; } spin_unlock_irqrestore(&midi_spinlock, flags); return mask; } int emu10k1_midi_callback(unsigned long msg, unsigned long refdata, unsigned long *pmsg) { struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) refdata; struct midi_hdr *midihdr = NULL; unsigned long flags; int i; DPF(4, "emu10k1_midi_callback()\n"); spin_lock_irqsave(&midi_spinlock, flags); switch (msg) { case ICARDMIDI_OUTLONGDATA: midihdr = (struct midi_hdr *) pmsg[2]; kfree(midihdr->data); kfree(midihdr); wake_up_interruptible(&midi_dev->oWait); break; case ICARDMIDI_INLONGDATA: midihdr = (struct midi_hdr *) pmsg[2]; for (i = 0; i < midihdr->bytesrecorded; i++) { midi_dev->iBuf[midi_dev->iwr++] = midihdr->data[i]; midi_dev->iwr %= MIDIIN_BUFLEN; } midi_dev->icnt += midihdr->bytesrecorded; if (midi_dev->mistate == MIDIIN_STATE_STARTED) { init_midi_hdr(midihdr); emu10k1_mpuin_add_buffer(midi_dev->card->mpuin, midihdr); wake_up_interruptible(&midi_dev->iWait); } break; case ICARDMIDI_INDATA: { u8 *pBuf = (u8 *) & pmsg[1]; u16 bytesvalid = pmsg[2]; for (i = 0; i < bytesvalid; i++) { midi_dev->iBuf[midi_dev->iwr++] = pBuf[i]; midi_dev->iwr %= MIDIIN_BUFLEN; } midi_dev->icnt += bytesvalid; } wake_up_interruptible(&midi_dev->iWait); break; default: /* Unknown message */ spin_unlock_irqrestore(&midi_spinlock, flags); return -1; } spin_unlock_irqrestore(&midi_spinlock, flags); return 0; } /* MIDI file operations */ struct file_operations emu10k1_midi_fops = { .owner = THIS_MODULE, .read = emu10k1_midi_read, .write = emu10k1_midi_write, .poll = emu10k1_midi_poll, .open = emu10k1_midi_open, .release = emu10k1_midi_release, }; #ifdef EMU10K1_SEQUENCER /* functions used for sequencer access */ int emu10k1_seq_midi_open(int dev, int mode, void (*input) (int dev, unsigned char data), void (*output) (int dev)) { struct emu10k1_card *card; struct midi_openinfo dsCardMidiOpenInfo; struct emu10k1_mididevice *midi_dev; if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL) return -EINVAL; card = midi_devs[dev]->devc; if (card->open_mode) /* card is opened native */ return -EBUSY; DPF(2, "emu10k1_seq_midi_open()\n"); if ((midi_dev = (struct emu10k1_mididevice *) kmalloc(sizeof(*midi_dev), GFP_KERNEL)) == NULL) return -EINVAL; midi_dev->card = card; midi_dev->mistate = MIDIIN_STATE_STOPPED; init_waitqueue_head(&midi_dev->oWait); init_waitqueue_head(&midi_dev->iWait); midi_dev->ird = 0; midi_dev->iwr = 0; midi_dev->icnt = 0; INIT_LIST_HEAD(&midi_dev->mid_hdrs); dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev; if (emu10k1_mpuout_open(card, &dsCardMidiOpenInfo) < 0) { ERROR(); return -ENODEV; } card->seq_mididev = midi_dev; return 0; } void emu10k1_seq_midi_close(int dev) { struct emu10k1_card *card; DPF(2, "emu10k1_seq_midi_close()\n"); if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL) return; card = midi_devs[dev]->devc; emu10k1_mpuout_close(card); kfree(card->seq_mididev); card->seq_mididev = NULL; } int emu10k1_seq_midi_out(int dev, unsigned char midi_byte) { struct emu10k1_card *card; struct midi_hdr *midihdr; unsigned long flags; if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL) return -EINVAL; card = midi_devs[dev]->devc; if ((midihdr = (struct midi_hdr *) kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL) return -EINVAL; midihdr->bufferlength = 1; midihdr->bytesrecorded = 0; midihdr->flags = 0; if ((midihdr->data = (u8 *) kmalloc(1, GFP_KERNEL)) == NULL) { ERROR(); kfree(midihdr); return -EINVAL; } *(midihdr->data) = midi_byte; spin_lock_irqsave(&midi_spinlock, flags); if (emu10k1_mpuout_add_buffer(card, midihdr) < 0) { ERROR(); kfree(midihdr->data); kfree(midihdr); spin_unlock_irqrestore(&midi_spinlock, flags); return -EINVAL; } spin_unlock_irqrestore(&midi_spinlock, flags); return 1; } int emu10k1_seq_midi_start_read(int dev) { return 0; } int emu10k1_seq_midi_end_read(int dev) { return 0; } void emu10k1_seq_midi_kick(int dev) { } int emu10k1_seq_midi_buffer_status(int dev) { int count; struct midi_queue *queue; struct emu10k1_card *card; if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL) return -EINVAL; count = 0; card = midi_devs[dev]->devc; queue = card->mpuout->firstmidiq; while (queue != NULL) { count++; if (queue == card->mpuout->lastmidiq) break; queue = queue->next; } return count; } #endif