[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / core / seq / oss / seq_oss_midi.c

/*
 * OSS compatible sequencer driver
 *
 * MIDI device handlers
 *
 * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <sound/asoundef.h>
#include "seq_oss_midi.h"
#include "seq_oss_readq.h"
#include "seq_oss_timer.h"
#include "seq_oss_event.h"
#include <sound/seq_midi_event.h>
#include "../seq_lock.h"
#include <linux/init.h>
#include <linux/slab.h>


/*
 * constants
 */
#define SNDRV_SEQ_OSS_MAX_MIDI_NAME	30

/*
 * definition of midi device record
 */
struct seq_oss_midi {
	int seq_device;		/* device number */
	int client;		/* sequencer client number */
	int port;		/* sequencer port number */
	unsigned int flags;	/* port capability */
	int opened;		/* flag for opening */
	unsigned char name[SNDRV_SEQ_OSS_MAX_MIDI_NAME];
	struct snd_midi_event *coder;	/* MIDI event coder */
	struct seq_oss_devinfo *devinfo;	/* assigned OSSseq device */
	snd_use_lock_t use_lock;
};


/*
 * midi device table
 */
static int max_midi_devs;
static struct seq_oss_midi *midi_devs[SNDRV_SEQ_OSS_MAX_MIDI_DEVS];

static DEFINE_SPINLOCK(register_lock);

/*
 * prototypes
 */
static struct seq_oss_midi *get_mdev(int dev);
static struct seq_oss_midi *get_mididev(struct seq_oss_devinfo *dp, int dev);
static int send_synth_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int dev);
static int send_midi_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, struct seq_oss_midi *mdev);

/*
 * look up the existing ports
 * this looks a very exhausting job.
 */
int
snd_seq_oss_midi_lookup_ports(int client)
{
	struct snd_seq_client_info *clinfo;
	struct snd_seq_port_info *pinfo;

	clinfo = kzalloc(sizeof(*clinfo), GFP_KERNEL);
	pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
	if (! clinfo || ! pinfo) {
		kfree(clinfo);
		kfree(pinfo);
		return -ENOMEM;
	}
	clinfo->client = -1;
	while (snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT, clinfo) == 0) {
		if (clinfo->client == client)
			continue; /* ignore myself */
		pinfo->addr.client = clinfo->client;
		pinfo->addr.port = -1;
		while (snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT, pinfo) == 0)
			snd_seq_oss_midi_check_new_port(pinfo);
	}
	kfree(clinfo);
	kfree(pinfo);
	return 0;
}


/*
 */
static struct seq_oss_midi *
get_mdev(int dev)
{
	struct seq_oss_midi *mdev;
	unsigned long flags;

	spin_lock_irqsave(&register_lock, flags);
	mdev = midi_devs[dev];
	if (mdev)
		snd_use_lock_use(&mdev->use_lock);
	spin_unlock_irqrestore(&register_lock, flags);
	return mdev;
}

/*
 * look for the identical slot
 */
static struct seq_oss_midi *
find_slot(int client, int port)
{
	int i;
	struct seq_oss_midi *mdev;
	unsigned long flags;

	spin_lock_irqsave(&register_lock, flags);
	for (i = 0; i < max_midi_devs; i++) {
		mdev = midi_devs[i];
		if (mdev && mdev->client == client && mdev->port == port) {
			/* found! */
			snd_use_lock_use(&mdev->use_lock);
			spin_unlock_irqrestore(&register_lock, flags);
			return mdev;
		}
	}
	spin_unlock_irqrestore(&register_lock, flags);
	return NULL;
}


#define PERM_WRITE (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_SUBS_WRITE)
#define PERM_READ (SNDRV_SEQ_PORT_CAP_READ|SNDRV_SEQ_PORT_CAP_SUBS_READ)
/*
 * register a new port if it doesn't exist yet
 */
int
snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo)
{
	int i;
	struct seq_oss_midi *mdev;
	unsigned long flags;

	debug_printk(("check for MIDI client %d port %d\n", pinfo->addr.client, pinfo->addr.port));
	/* the port must include generic midi */
	if (! (pinfo->type & SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC))
		return 0;
	/* either read or write subscribable */
	if ((pinfo->capability & PERM_WRITE) != PERM_WRITE &&
	    (pinfo->capability & PERM_READ) != PERM_READ)
		return 0;

	/*
	 * look for the identical slot
	 */
	if ((mdev = find_slot(pinfo->addr.client, pinfo->addr.port)) != NULL) {
		/* already exists */
		snd_use_lock_free(&mdev->use_lock);
		return 0;
	}

	/*
	 * allocate midi info record
	 */
	if ((mdev = kzalloc(sizeof(*mdev), GFP_KERNEL)) == NULL) {
		snd_printk(KERN_ERR "can't malloc midi info\n");
		return -ENOMEM;
	}

	/* copy the port information */
	mdev->client = pinfo->addr.client;
	mdev->port = pinfo->addr.port;
	mdev->flags = pinfo->capability;
	mdev->opened = 0;
	snd_use_lock_init(&mdev->use_lock);

	/* copy and truncate the name of synth device */
	strlcpy(mdev->name, pinfo->name, sizeof(mdev->name));

	/* create MIDI coder */
	if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, &mdev->coder) < 0) {
		snd_printk(KERN_ERR "can't malloc midi coder\n");
		kfree(mdev);
		return -ENOMEM;
	}
	/* OSS sequencer adds running status to all sequences */
	snd_midi_event_no_status(mdev->coder, 1);

	/*
	 * look for en empty slot
	 */
	spin_lock_irqsave(&register_lock, flags);
	for (i = 0; i < max_midi_devs; i++) {
		if (midi_devs[i] == NULL)
			break;
	}
	if (i >= max_midi_devs) {
		if (max_midi_devs >= SNDRV_SEQ_OSS_MAX_MIDI_DEVS) {
			spin_unlock_irqrestore(&register_lock, flags);
			snd_midi_event_free(mdev->coder);
			kfree(mdev);
			return -ENOMEM;
		}
		max_midi_devs++;
	}
	mdev->seq_device = i;
	midi_devs[mdev->seq_device] = mdev;
	spin_unlock_irqrestore(&register_lock, flags);

	return 0;
}

/*
 * release the midi device if it was registered
 */
int
snd_seq_oss_midi_check_exit_port(int client, int port)
{
	struct seq_oss_midi *mdev;
	unsigned long flags;
	int index;

	if ((mdev = find_slot(client, port)) != NULL) {
		spin_lock_irqsave(&register_lock, flags);
		midi_devs[mdev->seq_device] = NULL;
		spin_unlock_irqrestore(&register_lock, flags);
		snd_use_lock_free(&mdev->use_lock);
		snd_use_lock_sync(&mdev->use_lock);
		if (mdev->coder)
			snd_midi_event_free(mdev->coder);
		kfree(mdev);
	}
	spin_lock_irqsave(&register_lock, flags);
	for (index = max_midi_devs - 1; index >= 0; index--) {
		if (midi_devs[index])
			break;
	}
	max_midi_devs = index + 1;
	spin_unlock_irqrestore(&register_lock, flags);
	return 0;
}


/*
 * release the midi device if it was registered
 */
void
snd_seq_oss_midi_clear_all(void)
{
	int i;
	struct seq_oss_midi *mdev;
	unsigned long flags;

	spin_lock_irqsave(&register_lock, flags);
	for (i = 0; i < max_midi_devs; i++) {
		if ((mdev = midi_devs[i]) != NULL) {
			if (mdev->coder)
				snd_midi_event_free(mdev->coder);
			kfree(mdev);
			midi_devs[i] = NULL;
		}
	}
	max_midi_devs = 0;
	spin_unlock_irqrestore(&register_lock, flags);
}


/*
 * set up midi tables
 */
void
snd_seq_oss_midi_setup(struct seq_oss_devinfo *dp)
{
	dp->max_mididev = max_midi_devs;
}

/*
 * clean up midi tables
 */
void
snd_seq_oss_midi_cleanup(struct seq_oss_devinfo *dp)
{
	int i;
	for (i = 0; i < dp->max_mididev; i++)
		snd_seq_oss_midi_close(dp, i);
	dp->max_mididev = 0;
}


/*
 * open all midi devices.  ignore errors.
 */
void
snd_seq_oss_midi_open_all(struct seq_oss_devinfo *dp, int file_mode)
{
	int i;
	for (i = 0; i < dp->max_mididev; i++)
		snd_seq_oss_midi_open(dp, i, file_mode);
}


/*
 * get the midi device information
 */
static struct seq_oss_midi *
get_mididev(struct seq_oss_devinfo *dp, int dev)
{
	if (dev < 0 || dev >= dp->max_mididev)
		return NULL;
	return get_mdev(dev);
}


/*
 * open the midi device if not opened yet
 */
int
snd_seq_oss_midi_open(struct seq_oss_devinfo *dp, int dev, int fmode)
{
	int perm;
	struct seq_oss_midi *mdev;
	struct snd_seq_port_subscribe subs;

	if ((mdev = get_mididev(dp, dev)) == NULL)
		return -ENODEV;

	/* already used? */
	if (mdev->opened && mdev->devinfo != dp) {
		snd_use_lock_free(&mdev->use_lock);
		return -EBUSY;
	}

	perm = 0;
	if (is_write_mode(fmode))
		perm |= PERM_WRITE;
	if (is_read_mode(fmode))
		perm |= PERM_READ;
	perm &= mdev->flags;
	if (perm == 0) {
		snd_use_lock_free(&mdev->use_lock);
		return -ENXIO;
	}

	/* already opened? */
	if ((mdev->opened & perm) == perm) {
		snd_use_lock_free(&mdev->use_lock);
		return 0;
	}

	perm &= ~mdev->opened;

	memset(&subs, 0, sizeof(subs));

	if (perm & PERM_WRITE) {
		subs.sender = dp->addr;
		subs.dest.client = mdev->client;
		subs.dest.port = mdev->port;
		if (snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs) >= 0)
			mdev->opened |= PERM_WRITE;
	}
	if (perm & PERM_READ) {
		subs.sender.client = mdev->client;
		subs.sender.port = mdev->port;
		subs.dest = dp->addr;
		subs.flags = SNDRV_SEQ_PORT_SUBS_TIMESTAMP;
		subs.queue = dp->queue;		/* queue for timestamps */
		if (snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs) >= 0)
			mdev->opened |= PERM_READ;
	}

	if (! mdev->opened) {
		snd_use_lock_free(&mdev->use_lock);
		return -ENXIO;
	}

	mdev->devinfo = dp;
	snd_use_lock_free(&mdev->use_lock);
	return 0;
}

/*
 * close the midi device if already opened
 */
int
snd_seq_oss_midi_close(struct seq_oss_devinfo *dp, int dev)
{
	struct seq_oss_midi *mdev;
	struct snd_seq_port_subscribe subs;

	if ((mdev = get_mididev(dp, dev)) == NULL)
		return -ENODEV;
	if (! mdev->opened || mdev->devinfo != dp) {
		snd_use_lock_free(&mdev->use_lock);
		return 0;
	}

	debug_printk(("closing client %d port %d mode %d\n", mdev->client, mdev->port, mdev->opened));
	memset(&subs, 0, sizeof(subs));
	if (mdev->opened & PERM_WRITE) {
		subs.sender = dp->addr;
		subs.dest.client = mdev->client;
		subs.dest.port = mdev->port;
		snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, &subs);
	}
	if (mdev->opened & PERM_READ) {
		subs.sender.client = mdev->client;
		subs.sender.port = mdev->port;
		subs.dest = dp->addr;
		snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, &subs);
	}

	mdev->opened = 0;
	mdev->devinfo = NULL;

	snd_use_lock_free(&mdev->use_lock);
	return 0;
}

/*
 * change seq capability flags to file mode flags
 */
int
snd_seq_oss_midi_filemode(struct seq_oss_devinfo *dp, int dev)
{
	struct seq_oss_midi *mdev;
	int mode;

	if ((mdev = get_mididev(dp, dev)) == NULL)
		return 0;

	mode = 0;
	if (mdev->opened & PERM_WRITE)
		mode |= SNDRV_SEQ_OSS_FILE_WRITE;
	if (mdev->opened & PERM_READ)
		mode |= SNDRV_SEQ_OSS_FILE_READ;

	snd_use_lock_free(&mdev->use_lock);
	return mode;
}

/*
 * reset the midi device and close it:
 * so far, only close the device.
 */
void
snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev)
{
	struct seq_oss_midi *mdev;

	if ((mdev = get_mididev(dp, dev)) == NULL)
		return;
	if (! mdev->opened) {
		snd_use_lock_free(&mdev->use_lock);
		return;
	}

	if (mdev->opened & PERM_WRITE) {
		struct snd_seq_event ev;
		int c;

		debug_printk(("resetting client %d port %d\n", mdev->client, mdev->port));
		memset(&ev, 0, sizeof(ev));
		ev.dest.client = mdev->client;
		ev.dest.port = mdev->port;
		ev.queue = dp->queue;
		ev.source.port = dp->port;
		if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_SYNTH) {
			ev.type = SNDRV_SEQ_EVENT_SENSING;
			snd_seq_oss_dispatch(dp, &ev, 0, 0);
		}
		for (c = 0; c < 16; c++) {
			ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
			ev.data.control.channel = c;
			ev.data.control.param = MIDI_CTL_ALL_NOTES_OFF;
			snd_seq_oss_dispatch(dp, &ev, 0, 0);
			if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC) {
				ev.data.control.param =
					MIDI_CTL_RESET_CONTROLLERS;
				snd_seq_oss_dispatch(dp, &ev, 0, 0);
				ev.type = SNDRV_SEQ_EVENT_PITCHBEND;
				ev.data.control.value = 0;
				snd_seq_oss_dispatch(dp, &ev, 0, 0);
			}
		}
	}
	// snd_seq_oss_midi_close(dp, dev);
	snd_use_lock_free(&mdev->use_lock);
}


/*
 * get client/port of the specified MIDI device
 */
void
snd_seq_oss_midi_get_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_addr *addr)
{
	struct seq_oss_midi *mdev;

	if ((mdev = get_mididev(dp, dev)) == NULL)
		return;
	addr->client = mdev->client;
	addr->port = mdev->port;
	snd_use_lock_free(&mdev->use_lock);
}


/*
 * input callback - this can be atomic
 */
int
snd_seq_oss_midi_input(struct snd_seq_event *ev, int direct, void *private_data)
{
	struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private_data;
	struct seq_oss_midi *mdev;
	int rc;

	if (dp->readq == NULL)
		return 0;
	if ((mdev = find_slot(ev->source.client, ev->source.port)) == NULL)
		return 0;
	if (! (mdev->opened & PERM_READ)) {
		snd_use_lock_free(&mdev->use_lock);
		return 0;
	}

	if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC)
		rc = send_synth_event(dp, ev, mdev->seq_device);
	else
		rc = send_midi_event(dp, ev, mdev);

	snd_use_lock_free(&mdev->use_lock);
	return rc;
}

/*
 * convert ALSA sequencer event to OSS synth event
 */
static int
send_synth_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int dev)
{
	union evrec ossev;

	memset(&ossev, 0, sizeof(ossev));

	switch (ev->type) {
	case SNDRV_SEQ_EVENT_NOTEON:
		ossev.v.cmd = MIDI_NOTEON; break;
	case SNDRV_SEQ_EVENT_NOTEOFF:
		ossev.v.cmd = MIDI_NOTEOFF; break;
	case SNDRV_SEQ_EVENT_KEYPRESS:
		ossev.v.cmd = MIDI_KEY_PRESSURE; break;
	case SNDRV_SEQ_EVENT_CONTROLLER:
		ossev.l.cmd = MIDI_CTL_CHANGE; break;
	case SNDRV_SEQ_EVENT_PGMCHANGE:
		ossev.l.cmd = MIDI_PGM_CHANGE; break;
	case SNDRV_SEQ_EVENT_CHANPRESS:
		ossev.l.cmd = MIDI_CHN_PRESSURE; break;
	case SNDRV_SEQ_EVENT_PITCHBEND:
		ossev.l.cmd = MIDI_PITCH_BEND; break;
	default:
		return 0; /* not supported */
	}

	ossev.v.dev = dev;

	switch (ev->type) {
	case SNDRV_SEQ_EVENT_NOTEON:
	case SNDRV_SEQ_EVENT_NOTEOFF:
	case SNDRV_SEQ_EVENT_KEYPRESS:
		ossev.v.code = EV_CHN_VOICE;
		ossev.v.note = ev->data.note.note;
		ossev.v.parm = ev->data.note.velocity;
		ossev.v.chn = ev->data.note.channel;
		break;
	case SNDRV_SEQ_EVENT_CONTROLLER:
	case SNDRV_SEQ_EVENT_PGMCHANGE:
	case SNDRV_SEQ_EVENT_CHANPRESS:
		ossev.l.code = EV_CHN_COMMON;
		ossev.l.p1 = ev->data.control.param;
		ossev.l.val = ev->data.control.value;
		ossev.l.chn = ev->data.control.channel;
		break;
	case SNDRV_SEQ_EVENT_PITCHBEND:
		ossev.l.code = EV_CHN_COMMON;
		ossev.l.val = ev->data.control.value + 8192;
		ossev.l.chn = ev->data.control.channel;
		break;
	}
	
	snd_seq_oss_readq_put_timestamp(dp->readq, ev->time.tick, dp->seq_mode);
	snd_seq_oss_readq_put_event(dp->readq, &ossev);

	return 0;
}

/*
 * decode event and send MIDI bytes to read queue
 */
static int
send_midi_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, struct seq_oss_midi *mdev)
{
	char msg[32];
	int len;
	
	snd_seq_oss_readq_put_timestamp(dp->readq, ev->time.tick, dp->seq_mode);
	if (!dp->timer->running)
		len = snd_seq_oss_timer_start(dp->timer);
	if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {
		if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
			snd_seq_oss_readq_puts(dp->readq, mdev->seq_device,
					       ev->data.ext.ptr, ev->data.ext.len);
	} else {
		len = snd_midi_event_decode(mdev->coder, msg, sizeof(msg), ev);
		if (len > 0)
			snd_seq_oss_readq_puts(dp->readq, mdev->seq_device, msg, len);
	}

	return 0;
}


/*
 * dump midi data
 * return 0 : enqueued
 *        non-zero : invalid - ignored
 */
int
snd_seq_oss_midi_putc(struct seq_oss_devinfo *dp, int dev, unsigned char c, struct snd_seq_event *ev)
{
	struct seq_oss_midi *mdev;

	if ((mdev = get_mididev(dp, dev)) == NULL)
		return -ENODEV;
	if (snd_midi_event_encode_byte(mdev->coder, c, ev) > 0) {
		snd_seq_oss_fill_addr(dp, ev, mdev->client, mdev->port);
		snd_use_lock_free(&mdev->use_lock);
		return 0;
	}
	snd_use_lock_free(&mdev->use_lock);
	return -EINVAL;
}

/*
 * create OSS compatible midi_info record
 */
int
snd_seq_oss_midi_make_info(struct seq_oss_devinfo *dp, int dev, struct midi_info *inf)
{
	struct seq_oss_midi *mdev;

	if ((mdev = get_mididev(dp, dev)) == NULL)
		return -ENXIO;
	inf->device = dev;
	inf->dev_type = 0; /* FIXME: ?? */
	inf->capabilities = 0; /* FIXME: ?? */
	strlcpy(inf->name, mdev->name, sizeof(inf->name));
	snd_use_lock_free(&mdev->use_lock);
	return 0;
}


#ifdef CONFIG_PROC_FS
/*
 * proc interface
 */
static char *
capmode_str(int val)
{
	val &= PERM_READ|PERM_WRITE;
	if (val == (PERM_READ|PERM_WRITE))
		return "read/write";
	else if (val == PERM_READ)
		return "read";
	else if (val == PERM_WRITE)
		return "write";
	else
		return "none";
}

void
snd_seq_oss_midi_info_read(struct snd_info_buffer *buf)
{
	int i;
	struct seq_oss_midi *mdev;

	snd_iprintf(buf, "\nNumber of MIDI devices: %d\n", max_midi_devs);
	for (i = 0; i < max_midi_devs; i++) {
		snd_iprintf(buf, "\nmidi %d: ", i);
		mdev = get_mdev(i);
		if (mdev == NULL) {
			snd_iprintf(buf, "*empty*\n");
			continue;
		}
		snd_iprintf(buf, "[%s] ALSA port %d:%d\n", mdev->name,
			    mdev->client, mdev->port);
		snd_iprintf(buf, "  capability %s / opened %s\n",
			    capmode_str(mdev->flags),
			    capmode_str(mdev->opened));
		snd_use_lock_free(&mdev->use_lock);
	}
}
#endif /* CONFIG_PROC_FS */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* OSS compatible sequencer driver
	3	*
	4	* MIDI device handlers
	5	*
	6	* Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*/
	22
08d03340	23	#include <sound/asoundef.h>
1da177e4 LT	24	#include "seq_oss_midi.h"
	25	#include "seq_oss_readq.h"
	26	#include "seq_oss_timer.h"
	27	#include "seq_oss_event.h"
	28	#include <sound/seq_midi_event.h>
	29	#include "../seq_lock.h"
	30	#include <linux/init.h>
5a0e3ad6	31	#include <linux/slab.h>
1da177e4 LT	32
	33
	34	/*
	35	* constants
	36	*/
	37	#define SNDRV_SEQ_OSS_MAX_MIDI_NAME 30
	38
	39	/*
	40	* definition of midi device record
	41	*/
080dece3	42	struct seq_oss_midi {
1da177e4 LT	43	int seq_device; /* device number */
	44	int client; /* sequencer client number */
	45	int port; /* sequencer port number */
	46	unsigned int flags; /* port capability */
	47	int opened; /* flag for opening */
	48	unsigned char name[SNDRV_SEQ_OSS_MAX_MIDI_NAME];
080dece3 TI	49	struct snd_midi_event coder; / MIDI event coder */
080dece3 TI	50	struct seq_oss_devinfo devinfo; / assigned OSSseq device */
1da177e4 LT	51	snd_use_lock_t use_lock;
	52	};
	53
	54
	55	/*
	56	* midi device table
	57	*/
	58	static int max_midi_devs;
080dece3	59	static struct seq_oss_midi *midi_devs[SNDRV_SEQ_OSS_MAX_MIDI_DEVS];
1da177e4 LT	60
	61	static DEFINE_SPINLOCK(register_lock);
	62
	63	/*
	64	* prototypes
	65	*/
080dece3 TI	66	static struct seq_oss_midi *get_mdev(int dev);
	67	static struct seq_oss_midi get_mididev(struct seq_oss_devinfo dp, int dev);
	68	static int send_synth_event(struct seq_oss_devinfo dp, struct snd_seq_event ev, int dev);
	69	static int send_midi_event(struct seq_oss_devinfo dp, struct snd_seq_event ev, struct seq_oss_midi *mdev);
1da177e4 LT	70
	71	/*
	72	* look up the existing ports
	73	* this looks a very exhausting job.
	74	*/
409972c1	75	int
1da177e4 LT	76	snd_seq_oss_midi_lookup_ports(int client)
1da177e4 LT	77	{
080dece3 TI	78	struct snd_seq_client_info *clinfo;
080dece3 TI	79	struct snd_seq_port_info *pinfo;
1da177e4	80
ecca82b4 TI	81	clinfo = kzalloc(sizeof(*clinfo), GFP_KERNEL);
ecca82b4 TI	82	pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
1da177e4 LT	83	if (! clinfo \|\| ! pinfo) {
	84	kfree(clinfo);
	85	kfree(pinfo);
	86	return -ENOMEM;
	87	}
	88	clinfo->client = -1;
	89	while (snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT, clinfo) == 0) {
	90	if (clinfo->client == client)
	91	continue; /* ignore myself */
	92	pinfo->addr.client = clinfo->client;
	93	pinfo->addr.port = -1;
	94	while (snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT, pinfo) == 0)
	95	snd_seq_oss_midi_check_new_port(pinfo);
	96	}
	97	kfree(clinfo);
	98	kfree(pinfo);
	99	return 0;
	100	}
	101
	102
	103	/*
	104	*/
080dece3	105	static struct seq_oss_midi *
1da177e4 LT	106	get_mdev(int dev)
1da177e4 LT	107	{
080dece3	108	struct seq_oss_midi *mdev;
1da177e4 LT	109	unsigned long flags;
	110
	111	spin_lock_irqsave(&register_lock, flags);
	112	mdev = midi_devs[dev];
	113	if (mdev)
	114	snd_use_lock_use(&mdev->use_lock);
	115	spin_unlock_irqrestore(&register_lock, flags);
	116	return mdev;
	117	}
	118
	119	/*
	120	* look for the identical slot
	121	*/
080dece3	122	static struct seq_oss_midi *
1da177e4 LT	123	find_slot(int client, int port)
	124	{
	125	int i;
080dece3	126	struct seq_oss_midi *mdev;
1da177e4 LT	127	unsigned long flags;
	128
	129	spin_lock_irqsave(&register_lock, flags);
	130	for (i = 0; i < max_midi_devs; i++) {
	131	mdev = midi_devs[i];
	132	if (mdev && mdev->client == client && mdev->port == port) {
	133	/* found! */
	134	snd_use_lock_use(&mdev->use_lock);
	135	spin_unlock_irqrestore(&register_lock, flags);
	136	return mdev;
	137	}
	138	}
	139	spin_unlock_irqrestore(&register_lock, flags);
	140	return NULL;
	141	}
	142
	143
	144	#define PERM_WRITE (SNDRV_SEQ_PORT_CAP_WRITE\|SNDRV_SEQ_PORT_CAP_SUBS_WRITE)
	145	#define PERM_READ (SNDRV_SEQ_PORT_CAP_READ\|SNDRV_SEQ_PORT_CAP_SUBS_READ)
	146	/*
	147	* register a new port if it doesn't exist yet
	148	*/
	149	int
080dece3	150	snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo)
1da177e4 LT	151	{
1da177e4 LT	152	int i;
080dece3	153	struct seq_oss_midi *mdev;
1da177e4 LT	154	unsigned long flags;
	155
	156	debug_printk(("check for MIDI client %d port %d\n", pinfo->addr.client, pinfo->addr.port));
	157	/* the port must include generic midi */
	158	if (! (pinfo->type & SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC))
	159	return 0;
	160	/* either read or write subscribable */
	161	if ((pinfo->capability & PERM_WRITE) != PERM_WRITE &&
	162	(pinfo->capability & PERM_READ) != PERM_READ)
	163	return 0;
	164
	165	/*
	166	* look for the identical slot
	167	*/
	168	if ((mdev = find_slot(pinfo->addr.client, pinfo->addr.port)) != NULL) {
	169	/* already exists */
	170	snd_use_lock_free(&mdev->use_lock);
	171	return 0;
	172	}
	173
	174	/*
	175	* allocate midi info record
	176	*/
ecca82b4	177	if ((mdev = kzalloc(sizeof(*mdev), GFP_KERNEL)) == NULL) {
1da177e4 LT	178	snd_printk(KERN_ERR "can't malloc midi info\n");
	179	return -ENOMEM;
	180	}
	181
	182	/* copy the port information */
	183	mdev->client = pinfo->addr.client;
	184	mdev->port = pinfo->addr.port;
	185	mdev->flags = pinfo->capability;
	186	mdev->opened = 0;
	187	snd_use_lock_init(&mdev->use_lock);
	188
	189	/* copy and truncate the name of synth device */
	190	strlcpy(mdev->name, pinfo->name, sizeof(mdev->name));
	191
	192	/* create MIDI coder */
	193	if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, &mdev->coder) < 0) {
	194	snd_printk(KERN_ERR "can't malloc midi coder\n");
	195	kfree(mdev);
	196	return -ENOMEM;
	197	}
	198	/* OSS sequencer adds running status to all sequences */
	199	snd_midi_event_no_status(mdev->coder, 1);
	200
	201	/*
	202	* look for en empty slot
	203	*/
	204	spin_lock_irqsave(&register_lock, flags);
	205	for (i = 0; i < max_midi_devs; i++) {
	206	if (midi_devs[i] == NULL)
	207	break;
	208	}
	209	if (i >= max_midi_devs) {
	210	if (max_midi_devs >= SNDRV_SEQ_OSS_MAX_MIDI_DEVS) {
	211	spin_unlock_irqrestore(&register_lock, flags);
	212	snd_midi_event_free(mdev->coder);
	213	kfree(mdev);
	214	return -ENOMEM;
	215	}
	216	max_midi_devs++;
	217	}
	218	mdev->seq_device = i;
	219	midi_devs[mdev->seq_device] = mdev;
	220	spin_unlock_irqrestore(&register_lock, flags);
	221
	222	return 0;
	223	}
	224
	225	/*
	226	* release the midi device if it was registered
	227	*/
	228	int
	229	snd_seq_oss_midi_check_exit_port(int client, int port)
	230	{
080dece3	231	struct seq_oss_midi *mdev;
1da177e4 LT	232	unsigned long flags;
	233	int index;
	234
	235	if ((mdev = find_slot(client, port)) != NULL) {
	236	spin_lock_irqsave(&register_lock, flags);
	237	midi_devs[mdev->seq_device] = NULL;
	238	spin_unlock_irqrestore(&register_lock, flags);
	239	snd_use_lock_free(&mdev->use_lock);
	240	snd_use_lock_sync(&mdev->use_lock);
	241	if (mdev->coder)
	242	snd_midi_event_free(mdev->coder);
	243	kfree(mdev);
	244	}
	245	spin_lock_irqsave(&register_lock, flags);
	246	for (index = max_midi_devs - 1; index >= 0; index--) {
	247	if (midi_devs[index])
	248	break;
	249	}
	250	max_midi_devs = index + 1;
	251	spin_unlock_irqrestore(&register_lock, flags);
	252	return 0;
	253	}
	254
	255
	256	/*
	257	* release the midi device if it was registered
	258	*/
	259	void
	260	snd_seq_oss_midi_clear_all(void)
	261	{
	262	int i;
080dece3	263	struct seq_oss_midi *mdev;
1da177e4 LT	264	unsigned long flags;
	265
	266	spin_lock_irqsave(&register_lock, flags);
	267	for (i = 0; i < max_midi_devs; i++) {
	268	if ((mdev = midi_devs[i]) != NULL) {
	269	if (mdev->coder)
	270	snd_midi_event_free(mdev->coder);
	271	kfree(mdev);
	272	midi_devs[i] = NULL;
	273	}
	274	}
	275	max_midi_devs = 0;
	276	spin_unlock_irqrestore(&register_lock, flags);
	277	}
	278
	279
	280	/*
	281	* set up midi tables
	282	*/
	283	void
080dece3	284	snd_seq_oss_midi_setup(struct seq_oss_devinfo *dp)
1da177e4 LT	285	{
	286	dp->max_mididev = max_midi_devs;
	287	}
	288
	289	/*
	290	* clean up midi tables
	291	*/
	292	void
080dece3	293	snd_seq_oss_midi_cleanup(struct seq_oss_devinfo *dp)
1da177e4 LT	294	{
	295	int i;
	296	for (i = 0; i < dp->max_mididev; i++)
	297	snd_seq_oss_midi_close(dp, i);
	298	dp->max_mididev = 0;
	299	}
	300
	301
	302	/*
	303	* open all midi devices. ignore errors.
	304	*/
	305	void
080dece3	306	snd_seq_oss_midi_open_all(struct seq_oss_devinfo *dp, int file_mode)
1da177e4 LT	307	{
	308	int i;
	309	for (i = 0; i < dp->max_mididev; i++)
	310	snd_seq_oss_midi_open(dp, i, file_mode);
	311	}
	312
	313
	314	/*
	315	* get the midi device information
	316	*/
080dece3 TI	317	static struct seq_oss_midi *
080dece3 TI	318	get_mididev(struct seq_oss_devinfo *dp, int dev)
1da177e4 LT	319	{
	320	if (dev < 0 \|\| dev >= dp->max_mididev)
	321	return NULL;
	322	return get_mdev(dev);
	323	}
	324
	325
	326	/*
	327	* open the midi device if not opened yet
	328	*/
	329	int
080dece3	330	snd_seq_oss_midi_open(struct seq_oss_devinfo *dp, int dev, int fmode)
1da177e4 LT	331	{
1da177e4 LT	332	int perm;
080dece3 TI	333	struct seq_oss_midi *mdev;
080dece3 TI	334	struct snd_seq_port_subscribe subs;
1da177e4 LT	335
	336	if ((mdev = get_mididev(dp, dev)) == NULL)
	337	return -ENODEV;
	338
	339	/* already used? */
	340	if (mdev->opened && mdev->devinfo != dp) {
	341	snd_use_lock_free(&mdev->use_lock);
	342	return -EBUSY;
	343	}
	344
	345	perm = 0;
	346	if (is_write_mode(fmode))
	347	perm \|= PERM_WRITE;
	348	if (is_read_mode(fmode))
	349	perm \|= PERM_READ;
	350	perm &= mdev->flags;
	351	if (perm == 0) {
	352	snd_use_lock_free(&mdev->use_lock);
	353	return -ENXIO;
	354	}
	355
	356	/* already opened? */
	357	if ((mdev->opened & perm) == perm) {
	358	snd_use_lock_free(&mdev->use_lock);
	359	return 0;
	360	}
	361
	362	perm &= ~mdev->opened;
	363
	364	memset(&subs, 0, sizeof(subs));
	365
	366	if (perm & PERM_WRITE) {
	367	subs.sender = dp->addr;
	368	subs.dest.client = mdev->client;
	369	subs.dest.port = mdev->port;
	370	if (snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs) >= 0)
	371	mdev->opened \|= PERM_WRITE;
	372	}
	373	if (perm & PERM_READ) {
	374	subs.sender.client = mdev->client;
	375	subs.sender.port = mdev->port;
	376	subs.dest = dp->addr;
	377	subs.flags = SNDRV_SEQ_PORT_SUBS_TIMESTAMP;
	378	subs.queue = dp->queue; /* queue for timestamps */
	379	if (snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs) >= 0)
	380	mdev->opened \|= PERM_READ;
	381	}
	382
	383	if (! mdev->opened) {
	384	snd_use_lock_free(&mdev->use_lock);
	385	return -ENXIO;
	386	}
	387
	388	mdev->devinfo = dp;
	389	snd_use_lock_free(&mdev->use_lock);
	390	return 0;
	391	}
	392
	393	/*
	394	* close the midi device if already opened
	395	*/
	396	int
080dece3	397	snd_seq_oss_midi_close(struct seq_oss_devinfo *dp, int dev)
1da177e4	398	{
080dece3 TI	399	struct seq_oss_midi *mdev;
080dece3 TI	400	struct snd_seq_port_subscribe subs;
1da177e4 LT	401
	402	if ((mdev = get_mididev(dp, dev)) == NULL)
	403	return -ENODEV;
	404	if (! mdev->opened \|\| mdev->devinfo != dp) {
	405	snd_use_lock_free(&mdev->use_lock);
	406	return 0;
	407	}
	408
	409	debug_printk(("closing client %d port %d mode %d\n", mdev->client, mdev->port, mdev->opened));
	410	memset(&subs, 0, sizeof(subs));
	411	if (mdev->opened & PERM_WRITE) {
	412	subs.sender = dp->addr;
	413	subs.dest.client = mdev->client;
	414	subs.dest.port = mdev->port;
	415	snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, &subs);
	416	}
	417	if (mdev->opened & PERM_READ) {
	418	subs.sender.client = mdev->client;
	419	subs.sender.port = mdev->port;
	420	subs.dest = dp->addr;
	421	snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, &subs);
	422	}
	423
	424	mdev->opened = 0;
	425	mdev->devinfo = NULL;
	426
	427	snd_use_lock_free(&mdev->use_lock);
	428	return 0;
	429	}
	430
	431	/*
	432	* change seq capability flags to file mode flags
	433	*/
	434	int
080dece3	435	snd_seq_oss_midi_filemode(struct seq_oss_devinfo *dp, int dev)
1da177e4	436	{
080dece3	437	struct seq_oss_midi *mdev;
1da177e4 LT	438	int mode;
	439
	440	if ((mdev = get_mididev(dp, dev)) == NULL)
	441	return 0;
	442
	443	mode = 0;
	444	if (mdev->opened & PERM_WRITE)
	445	mode \|= SNDRV_SEQ_OSS_FILE_WRITE;
	446	if (mdev->opened & PERM_READ)
	447	mode \|= SNDRV_SEQ_OSS_FILE_READ;
	448
	449	snd_use_lock_free(&mdev->use_lock);
	450	return mode;
	451	}
	452
	453	/*
	454	* reset the midi device and close it:
	455	* so far, only close the device.
	456	*/
	457	void
080dece3	458	snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev)
1da177e4	459	{
080dece3	460	struct seq_oss_midi *mdev;
1da177e4 LT	461
	462	if ((mdev = get_mididev(dp, dev)) == NULL)
	463	return;
	464	if (! mdev->opened) {
	465	snd_use_lock_free(&mdev->use_lock);
	466	return;
	467	}
	468
	469	if (mdev->opened & PERM_WRITE) {
080dece3	470	struct snd_seq_event ev;
1da177e4 LT	471	int c;
	472
	473	debug_printk(("resetting client %d port %d\n", mdev->client, mdev->port));
	474	memset(&ev, 0, sizeof(ev));
	475	ev.dest.client = mdev->client;
	476	ev.dest.port = mdev->port;
	477	ev.queue = dp->queue;
	478	ev.source.port = dp->port;
	479	if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_SYNTH) {
	480	ev.type = SNDRV_SEQ_EVENT_SENSING;
08d03340	481	snd_seq_oss_dispatch(dp, &ev, 0, 0);
1da177e4 LT	482	}
	483	for (c = 0; c < 16; c++) {
	484	ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
	485	ev.data.control.channel = c;
08d03340 CL	486	ev.data.control.param = MIDI_CTL_ALL_NOTES_OFF;
08d03340 CL	487	snd_seq_oss_dispatch(dp, &ev, 0, 0);
1da177e4	488	if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC) {
08d03340 CL	489	ev.data.control.param =
	490	MIDI_CTL_RESET_CONTROLLERS;
	491	snd_seq_oss_dispatch(dp, &ev, 0, 0);
1da177e4 LT	492	ev.type = SNDRV_SEQ_EVENT_PITCHBEND;
1da177e4 LT	493	ev.data.control.value = 0;
08d03340	494	snd_seq_oss_dispatch(dp, &ev, 0, 0);
1da177e4 LT	495	}
	496	}
	497	}
	498	// snd_seq_oss_midi_close(dp, dev);
	499	snd_use_lock_free(&mdev->use_lock);
	500	}
	501
	502
	503	/*
	504	* get client/port of the specified MIDI device
	505	*/
	506	void
080dece3	507	snd_seq_oss_midi_get_addr(struct seq_oss_devinfo dp, int dev, struct snd_seq_addr addr)
1da177e4	508	{
080dece3	509	struct seq_oss_midi *mdev;
1da177e4 LT	510
	511	if ((mdev = get_mididev(dp, dev)) == NULL)
	512	return;
	513	addr->client = mdev->client;
	514	addr->port = mdev->port;
	515	snd_use_lock_free(&mdev->use_lock);
	516	}
	517
	518
	519	/*
	520	* input callback - this can be atomic
	521	*/
	522	int
080dece3	523	snd_seq_oss_midi_input(struct snd_seq_event ev, int direct, void private_data)
1da177e4	524	{
080dece3 TI	525	struct seq_oss_devinfo dp = (struct seq_oss_devinfo )private_data;
080dece3 TI	526	struct seq_oss_midi *mdev;
1da177e4 LT	527	int rc;
	528
	529	if (dp->readq == NULL)
	530	return 0;
	531	if ((mdev = find_slot(ev->source.client, ev->source.port)) == NULL)
	532	return 0;
	533	if (! (mdev->opened & PERM_READ)) {
	534	snd_use_lock_free(&mdev->use_lock);
	535	return 0;
	536	}
	537
	538	if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC)
	539	rc = send_synth_event(dp, ev, mdev->seq_device);
	540	else
	541	rc = send_midi_event(dp, ev, mdev);
	542
	543	snd_use_lock_free(&mdev->use_lock);
	544	return rc;
	545	}
	546
	547	/*
	548	* convert ALSA sequencer event to OSS synth event
	549	*/
	550	static int
080dece3	551	send_synth_event(struct seq_oss_devinfo dp, struct snd_seq_event ev, int dev)
1da177e4	552	{
080dece3	553	union evrec ossev;
1da177e4 LT	554
	555	memset(&ossev, 0, sizeof(ossev));
	556
	557	switch (ev->type) {
	558	case SNDRV_SEQ_EVENT_NOTEON:
	559	ossev.v.cmd = MIDI_NOTEON; break;
	560	case SNDRV_SEQ_EVENT_NOTEOFF:
	561	ossev.v.cmd = MIDI_NOTEOFF; break;
	562	case SNDRV_SEQ_EVENT_KEYPRESS:
	563	ossev.v.cmd = MIDI_KEY_PRESSURE; break;
	564	case SNDRV_SEQ_EVENT_CONTROLLER:
	565	ossev.l.cmd = MIDI_CTL_CHANGE; break;
	566	case SNDRV_SEQ_EVENT_PGMCHANGE:
	567	ossev.l.cmd = MIDI_PGM_CHANGE; break;
	568	case SNDRV_SEQ_EVENT_CHANPRESS:
	569	ossev.l.cmd = MIDI_CHN_PRESSURE; break;
	570	case SNDRV_SEQ_EVENT_PITCHBEND:
	571	ossev.l.cmd = MIDI_PITCH_BEND; break;
	572	default:
	573	return 0; /* not supported */
	574	}
	575
	576	ossev.v.dev = dev;
	577
	578	switch (ev->type) {
	579	case SNDRV_SEQ_EVENT_NOTEON:
	580	case SNDRV_SEQ_EVENT_NOTEOFF:
	581	case SNDRV_SEQ_EVENT_KEYPRESS:
	582	ossev.v.code = EV_CHN_VOICE;
	583	ossev.v.note = ev->data.note.note;
	584	ossev.v.parm = ev->data.note.velocity;
	585	ossev.v.chn = ev->data.note.channel;
	586	break;
	587	case SNDRV_SEQ_EVENT_CONTROLLER:
	588	case SNDRV_SEQ_EVENT_PGMCHANGE:
	589	case SNDRV_SEQ_EVENT_CHANPRESS:
	590	ossev.l.code = EV_CHN_COMMON;
	591	ossev.l.p1 = ev->data.control.param;
	592	ossev.l.val = ev->data.control.value;
	593	ossev.l.chn = ev->data.control.channel;
	594	break;
	595	case SNDRV_SEQ_EVENT_PITCHBEND:
	596	ossev.l.code = EV_CHN_COMMON;
	597	ossev.l.val = ev->data.control.value + 8192;
	598	ossev.l.chn = ev->data.control.channel;
	599	break;
	600	}
	601
	602	snd_seq_oss_readq_put_timestamp(dp->readq, ev->time.tick, dp->seq_mode);
	603	snd_seq_oss_readq_put_event(dp->readq, &ossev);
	604
	605	return 0;
	606	}
	607
	608	/*
	609	* decode event and send MIDI bytes to read queue
	610	*/
	611	static int
080dece3	612	send_midi_event(struct seq_oss_devinfo dp, struct snd_seq_event ev, struct seq_oss_midi *mdev)
1da177e4 LT	613	{
	614	char msg[32];
	615	int len;
	616
	617	snd_seq_oss_readq_put_timestamp(dp->readq, ev->time.tick, dp->seq_mode);
	618	if (!dp->timer->running)
	619	len = snd_seq_oss_timer_start(dp->timer);
	620	if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {
	621	if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
	622	snd_seq_oss_readq_puts(dp->readq, mdev->seq_device,
	623	ev->data.ext.ptr, ev->data.ext.len);
	624	} else {
	625	len = snd_midi_event_decode(mdev->coder, msg, sizeof(msg), ev);
	626	if (len > 0)
	627	snd_seq_oss_readq_puts(dp->readq, mdev->seq_device, msg, len);
	628	}
	629
	630	return 0;
	631	}
	632
	633
	634	/*
	635	* dump midi data
	636	* return 0 : enqueued
	637	* non-zero : invalid - ignored
	638	*/
	639	int
080dece3	640	snd_seq_oss_midi_putc(struct seq_oss_devinfo dp, int dev, unsigned char c, struct snd_seq_event ev)
1da177e4	641	{
080dece3	642	struct seq_oss_midi *mdev;
1da177e4 LT	643
	644	if ((mdev = get_mididev(dp, dev)) == NULL)
	645	return -ENODEV;
	646	if (snd_midi_event_encode_byte(mdev->coder, c, ev) > 0) {
	647	snd_seq_oss_fill_addr(dp, ev, mdev->client, mdev->port);
	648	snd_use_lock_free(&mdev->use_lock);
	649	return 0;
	650	}
	651	snd_use_lock_free(&mdev->use_lock);
	652	return -EINVAL;
	653	}
	654
	655	/*
	656	* create OSS compatible midi_info record
	657	*/
	658	int
080dece3	659	snd_seq_oss_midi_make_info(struct seq_oss_devinfo dp, int dev, struct midi_info inf)
1da177e4	660	{
080dece3	661	struct seq_oss_midi *mdev;
1da177e4 LT	662
	663	if ((mdev = get_mididev(dp, dev)) == NULL)
	664	return -ENXIO;
	665	inf->device = dev;
	666	inf->dev_type = 0; /* FIXME: ?? */
	667	inf->capabilities = 0; /* FIXME: ?? */
	668	strlcpy(inf->name, mdev->name, sizeof(inf->name));
	669	snd_use_lock_free(&mdev->use_lock);
	670	return 0;
	671	}
	672
	673
04f141a8	674	#ifdef CONFIG_PROC_FS
1da177e4 LT	675	/*
	676	* proc interface
	677	*/
	678	static char *
	679	capmode_str(int val)
	680	{
	681	val &= PERM_READ\|PERM_WRITE;
	682	if (val == (PERM_READ\|PERM_WRITE))
	683	return "read/write";
	684	else if (val == PERM_READ)
	685	return "read";
	686	else if (val == PERM_WRITE)
	687	return "write";
	688	else
	689	return "none";
	690	}
	691
	692	void
080dece3	693	snd_seq_oss_midi_info_read(struct snd_info_buffer *buf)
1da177e4 LT	694	{
1da177e4 LT	695	int i;
080dece3	696	struct seq_oss_midi *mdev;
1da177e4 LT	697
	698	snd_iprintf(buf, "\nNumber of MIDI devices: %d\n", max_midi_devs);
	699	for (i = 0; i < max_midi_devs; i++) {
	700	snd_iprintf(buf, "\nmidi %d: ", i);
	701	mdev = get_mdev(i);
	702	if (mdev == NULL) {
	703	snd_iprintf(buf, "empty\n");
	704	continue;
	705	}
	706	snd_iprintf(buf, "[%s] ALSA port %d:%d\n", mdev->name,
	707	mdev->client, mdev->port);
	708	snd_iprintf(buf, " capability %s / opened %s\n",
	709	capmode_str(mdev->flags),
	710	capmode_str(mdev->opened));
	711	snd_use_lock_free(&mdev->use_lock);
	712	}
	713	}
04f141a8	714	#endif /* CONFIG_PROC_FS */