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

/*
 * OSS compatible sequencer driver
 *
 * open/close and reset interface
 *
 * Copyright (C) 1998-1999 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 "seq_oss_device.h"
#include "seq_oss_synth.h"
#include "seq_oss_midi.h"
#include "seq_oss_writeq.h"
#include "seq_oss_readq.h"
#include "seq_oss_timer.h"
#include "seq_oss_event.h"
#include <linux/init.h>
#include <linux/export.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/workqueue.h>

/*
 * common variables
 */
static int maxqlen = SNDRV_SEQ_OSS_MAX_QLEN;
module_param(maxqlen, int, 0444);
MODULE_PARM_DESC(maxqlen, "maximum queue length");

static int system_client = -1; /* ALSA sequencer client number */
static int system_port = -1;

static int num_clients;
static struct seq_oss_devinfo *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS];


/*
 * prototypes
 */
static int receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop);
static int translate_mode(struct file *file);
static int create_port(struct seq_oss_devinfo *dp);
static int delete_port(struct seq_oss_devinfo *dp);
static int alloc_seq_queue(struct seq_oss_devinfo *dp);
static int delete_seq_queue(int queue);
static void free_devinfo(void *private);

#define call_ctl(type,rec) snd_seq_kernel_client_ctl(system_client, type, rec)


/* call snd_seq_oss_midi_lookup_ports() asynchronously */
static void async_call_lookup_ports(struct work_struct *work)
{
	snd_seq_oss_midi_lookup_ports(system_client);
}

static DECLARE_WORK(async_lookup_work, async_call_lookup_ports);

/*
 * create sequencer client for OSS sequencer
 */
int __init
snd_seq_oss_create_client(void)
{
	int rc;
	struct snd_seq_port_info *port;
	struct snd_seq_port_callback port_callback;

	port = kmalloc(sizeof(*port), GFP_KERNEL);
	if (!port) {
		rc = -ENOMEM;
		goto __error;
	}

	/* create ALSA client */
	rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS,
					  "OSS sequencer");
	if (rc < 0)
		goto __error;

	system_client = rc;
	debug_printk(("new client = %d\n", rc));

	/* create annoucement receiver port */
	memset(port, 0, sizeof(*port));
	strcpy(port->name, "Receiver");
	port->addr.client = system_client;
	port->capability = SNDRV_SEQ_PORT_CAP_WRITE; /* receive only */
	port->type = 0;

	memset(&port_callback, 0, sizeof(port_callback));
	/* don't set port_callback.owner here. otherwise the module counter
	 * is incremented and we can no longer release the module..
	 */
	port_callback.event_input = receive_announce;
	port->kernel = &port_callback;
	
	call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, port);
	if ((system_port = port->addr.port) >= 0) {
		struct snd_seq_port_subscribe subs;

		memset(&subs, 0, sizeof(subs));
		subs.sender.client = SNDRV_SEQ_CLIENT_SYSTEM;
		subs.sender.port = SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE;
		subs.dest.client = system_client;
		subs.dest.port = system_port;
		call_ctl(SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs);
	}
	rc = 0;

	/* look up midi devices */
	schedule_work(&async_lookup_work);

 __error:
	kfree(port);
	return rc;
}


/*
 * receive annoucement from system port, and check the midi device
 */
static int
receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop)
{
	struct snd_seq_port_info pinfo;

	if (atomic)
		return 0; /* it must not happen */

	switch (ev->type) {
	case SNDRV_SEQ_EVENT_PORT_START:
	case SNDRV_SEQ_EVENT_PORT_CHANGE:
		if (ev->data.addr.client == system_client)
			break; /* ignore myself */
		memset(&pinfo, 0, sizeof(pinfo));
		pinfo.addr = ev->data.addr;
		if (call_ctl(SNDRV_SEQ_IOCTL_GET_PORT_INFO, &pinfo) >= 0)
			snd_seq_oss_midi_check_new_port(&pinfo);
		break;

	case SNDRV_SEQ_EVENT_PORT_EXIT:
		if (ev->data.addr.client == system_client)
			break; /* ignore myself */
		snd_seq_oss_midi_check_exit_port(ev->data.addr.client,
						ev->data.addr.port);
		break;
	}
	return 0;
}


/*
 * delete OSS sequencer client
 */
int
snd_seq_oss_delete_client(void)
{
	cancel_work_sync(&async_lookup_work);
	if (system_client >= 0)
		snd_seq_delete_kernel_client(system_client);

	snd_seq_oss_midi_clear_all();

	return 0;
}


/*
 * open sequencer device
 */
int
snd_seq_oss_open(struct file *file, int level)
{
	int i, rc;
	struct seq_oss_devinfo *dp;

	dp = kzalloc(sizeof(*dp), GFP_KERNEL);
	if (!dp) {
		snd_printk(KERN_ERR "can't malloc device info\n");
		return -ENOMEM;
	}
	debug_printk(("oss_open: dp = %p\n", dp));

	dp->cseq = system_client;
	dp->port = -1;
	dp->queue = -1;

	for (i = 0; i < SNDRV_SEQ_OSS_MAX_CLIENTS; i++) {
		if (client_table[i] == NULL)
			break;
	}

	dp->index = i;
	if (i >= SNDRV_SEQ_OSS_MAX_CLIENTS) {
		snd_printk(KERN_ERR "too many applications\n");
		rc = -ENOMEM;
		goto _error;
	}

	/* look up synth and midi devices */
	snd_seq_oss_synth_setup(dp);
	snd_seq_oss_midi_setup(dp);

	if (dp->synth_opened == 0 && dp->max_mididev == 0) {
		/* snd_printk(KERN_ERR "no device found\n"); */
		rc = -ENODEV;
		goto _error;
	}

	/* create port */
	debug_printk(("create new port\n"));
	rc = create_port(dp);
	if (rc < 0) {
		snd_printk(KERN_ERR "can't create port\n");
		goto _error;
	}

	/* allocate queue */
	debug_printk(("allocate queue\n"));
	rc = alloc_seq_queue(dp);
	if (rc < 0)
		goto _error;

	/* set address */
	dp->addr.client = dp->cseq;
	dp->addr.port = dp->port;
	/*dp->addr.queue = dp->queue;*/
	/*dp->addr.channel = 0;*/

	dp->seq_mode = level;

	/* set up file mode */
	dp->file_mode = translate_mode(file);

	/* initialize read queue */
	debug_printk(("initialize read queue\n"));
	if (is_read_mode(dp->file_mode)) {
		dp->readq = snd_seq_oss_readq_new(dp, maxqlen);
		if (!dp->readq) {
			rc = -ENOMEM;
			goto _error;
		}
	}

	/* initialize write queue */
	debug_printk(("initialize write queue\n"));
	if (is_write_mode(dp->file_mode)) {
		dp->writeq = snd_seq_oss_writeq_new(dp, maxqlen);
		if (!dp->writeq) {
			rc = -ENOMEM;
			goto _error;
		}
	}

	/* initialize timer */
	debug_printk(("initialize timer\n"));
	dp->timer = snd_seq_oss_timer_new(dp);
	if (!dp->timer) {
		snd_printk(KERN_ERR "can't alloc timer\n");
		rc = -ENOMEM;
		goto _error;
	}
	debug_printk(("timer initialized\n"));

	/* set private data pointer */
	file->private_data = dp;

	/* set up for mode2 */
	if (level == SNDRV_SEQ_OSS_MODE_MUSIC)
		snd_seq_oss_synth_setup_midi(dp);
	else if (is_read_mode(dp->file_mode))
		snd_seq_oss_midi_open_all(dp, SNDRV_SEQ_OSS_FILE_READ);

	client_table[dp->index] = dp;
	num_clients++;

	debug_printk(("open done\n"));
	return 0;

 _error:
	snd_seq_oss_synth_cleanup(dp);
	snd_seq_oss_midi_cleanup(dp);
	delete_seq_queue(dp->queue);
	delete_port(dp);

	return rc;
}

/*
 * translate file flags to private mode
 */
static int
translate_mode(struct file *file)
{
	int file_mode = 0;
	if ((file->f_flags & O_ACCMODE) != O_RDONLY)
		file_mode |= SNDRV_SEQ_OSS_FILE_WRITE;
	if ((file->f_flags & O_ACCMODE) != O_WRONLY)
		file_mode |= SNDRV_SEQ_OSS_FILE_READ;
	if (file->f_flags & O_NONBLOCK)
		file_mode |= SNDRV_SEQ_OSS_FILE_NONBLOCK;
	return file_mode;
}


/*
 * create sequencer port
 */
static int
create_port(struct seq_oss_devinfo *dp)
{
	int rc;
	struct snd_seq_port_info port;
	struct snd_seq_port_callback callback;

	memset(&port, 0, sizeof(port));
	port.addr.client = dp->cseq;
	sprintf(port.name, "Sequencer-%d", dp->index);
	port.capability = SNDRV_SEQ_PORT_CAP_READ|SNDRV_SEQ_PORT_CAP_WRITE; /* no subscription */
	port.type = SNDRV_SEQ_PORT_TYPE_SPECIFIC;
	port.midi_channels = 128;
	port.synth_voices = 128;

	memset(&callback, 0, sizeof(callback));
	callback.owner = THIS_MODULE;
	callback.private_data = dp;
	callback.event_input = snd_seq_oss_event_input;
	callback.private_free = free_devinfo;
	port.kernel = &callback;

	rc = call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, &port);
	if (rc < 0)
		return rc;

	dp->port = port.addr.port;
	debug_printk(("new port = %d\n", port.addr.port));

	return 0;
}

/*
 * delete ALSA port
 */
static int
delete_port(struct seq_oss_devinfo *dp)
{
	if (dp->port < 0) {
		kfree(dp);
		return 0;
	}

	debug_printk(("delete_port %i\n", dp->port));
	return snd_seq_event_port_detach(dp->cseq, dp->port);
}

/*
 * allocate a queue
 */
static int
alloc_seq_queue(struct seq_oss_devinfo *dp)
{
	struct snd_seq_queue_info qinfo;
	int rc;

	memset(&qinfo, 0, sizeof(qinfo));
	qinfo.owner = system_client;
	qinfo.locked = 1;
	strcpy(qinfo.name, "OSS Sequencer Emulation");
	if ((rc = call_ctl(SNDRV_SEQ_IOCTL_CREATE_QUEUE, &qinfo)) < 0)
		return rc;
	dp->queue = qinfo.queue;
	return 0;
}

/*
 * release queue
 */
static int
delete_seq_queue(int queue)
{
	struct snd_seq_queue_info qinfo;
	int rc;

	if (queue < 0)
		return 0;
	memset(&qinfo, 0, sizeof(qinfo));
	qinfo.queue = queue;
	rc = call_ctl(SNDRV_SEQ_IOCTL_DELETE_QUEUE, &qinfo);
	if (rc < 0)
		printk(KERN_ERR "seq-oss: unable to delete queue %d (%d)\n", queue, rc);
	return rc;
}


/*
 * free device informations - private_free callback of port
 */
static void
free_devinfo(void *private)
{
	struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private;

	if (dp->timer)
		snd_seq_oss_timer_delete(dp->timer);
		
	if (dp->writeq)
		snd_seq_oss_writeq_delete(dp->writeq);

	if (dp->readq)
		snd_seq_oss_readq_delete(dp->readq);
	
	kfree(dp);
}


/*
 * close sequencer device
 */
void
snd_seq_oss_release(struct seq_oss_devinfo *dp)
{
	int queue;

	client_table[dp->index] = NULL;
	num_clients--;

	debug_printk(("resetting..\n"));
	snd_seq_oss_reset(dp);

	debug_printk(("cleaning up..\n"));
	snd_seq_oss_synth_cleanup(dp);
	snd_seq_oss_midi_cleanup(dp);

	/* clear slot */
	debug_printk(("releasing resource..\n"));
	queue = dp->queue;
	if (dp->port >= 0)
		delete_port(dp);
	delete_seq_queue(queue);

	debug_printk(("release done\n"));
}


/*
 * reset sequencer devices
 */
void
snd_seq_oss_reset(struct seq_oss_devinfo *dp)
{
	int i;

	/* reset all synth devices */
	for (i = 0; i < dp->max_synthdev; i++)
		snd_seq_oss_synth_reset(dp, i);

	/* reset all midi devices */
	if (dp->seq_mode != SNDRV_SEQ_OSS_MODE_MUSIC) {
		for (i = 0; i < dp->max_mididev; i++)
			snd_seq_oss_midi_reset(dp, i);
	}

	/* remove queues */
	if (dp->readq)
		snd_seq_oss_readq_clear(dp->readq);
	if (dp->writeq)
		snd_seq_oss_writeq_clear(dp->writeq);

	/* reset timer */
	snd_seq_oss_timer_stop(dp->timer);
}


#ifdef CONFIG_PROC_FS
/*
 * misc. functions for proc interface
 */
char *
enabled_str(int bool)
{
	return bool ? "enabled" : "disabled";
}

static char *
filemode_str(int val)
{
	static char *str[] = {
		"none", "read", "write", "read/write",
	};
	return str[val & SNDRV_SEQ_OSS_FILE_ACMODE];
}


/*
 * proc interface
 */
void
snd_seq_oss_system_info_read(struct snd_info_buffer *buf)
{
	int i;
	struct seq_oss_devinfo *dp;

	snd_iprintf(buf, "ALSA client number %d\n", system_client);
	snd_iprintf(buf, "ALSA receiver port %d\n", system_port);

	snd_iprintf(buf, "\nNumber of applications: %d\n", num_clients);
	for (i = 0; i < num_clients; i++) {
		snd_iprintf(buf, "\nApplication %d: ", i);
		if ((dp = client_table[i]) == NULL) {
			snd_iprintf(buf, "*empty*\n");
			continue;
		}
		snd_iprintf(buf, "port %d : queue %d\n", dp->port, dp->queue);
		snd_iprintf(buf, "  sequencer mode = %s : file open mode = %s\n",
			    (dp->seq_mode ? "music" : "synth"),
			    filemode_str(dp->file_mode));
		if (dp->seq_mode)
			snd_iprintf(buf, "  timer tempo = %d, timebase = %d\n",
				    dp->timer->oss_tempo, dp->timer->oss_timebase);
		snd_iprintf(buf, "  max queue length %d\n", maxqlen);
		if (is_read_mode(dp->file_mode) && dp->readq)
			snd_seq_oss_readq_info_read(dp->readq, buf);
	}
}
#endif /* CONFIG_PROC_FS */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* OSS compatible sequencer driver
	3	*
	4	* open/close and reset interface
	5	*
	6	* Copyright (C) 1998-1999 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
	23	#include "seq_oss_device.h"
	24	#include "seq_oss_synth.h"
	25	#include "seq_oss_midi.h"
	26	#include "seq_oss_writeq.h"
	27	#include "seq_oss_readq.h"
	28	#include "seq_oss_timer.h"
	29	#include "seq_oss_event.h"
	30	#include <linux/init.h>
d81a6d71	31	#include <linux/export.h>
1da177e4	32	#include <linux/moduleparam.h>
5a0e3ad6	33	#include <linux/slab.h>
409972c1	34	#include <linux/workqueue.h>
1da177e4 LT	35
	36	/*
	37	* common variables
	38	*/
	39	static int maxqlen = SNDRV_SEQ_OSS_MAX_QLEN;
	40	module_param(maxqlen, int, 0444);
	41	MODULE_PARM_DESC(maxqlen, "maximum queue length");
	42
	43	static int system_client = -1; /* ALSA sequencer client number */
	44	static int system_port = -1;
	45
	46	static int num_clients;
080dece3	47	static struct seq_oss_devinfo *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS];
1da177e4 LT	48
	49
	50	/*
	51	* prototypes
	52	*/
080dece3	53	static int receive_announce(struct snd_seq_event ev, int direct, void private, int atomic, int hop);
1da177e4	54	static int translate_mode(struct file *file);
080dece3 TI	55	static int create_port(struct seq_oss_devinfo *dp);
	56	static int delete_port(struct seq_oss_devinfo *dp);
	57	static int alloc_seq_queue(struct seq_oss_devinfo *dp);
1da177e4 LT	58	static int delete_seq_queue(int queue);
	59	static void free_devinfo(void *private);
	60
	61	#define call_ctl(type,rec) snd_seq_kernel_client_ctl(system_client, type, rec)
	62
	63
409972c1 TI	64	/* call snd_seq_oss_midi_lookup_ports() asynchronously */
	65	static void async_call_lookup_ports(struct work_struct *work)
	66	{
	67	snd_seq_oss_midi_lookup_ports(system_client);
	68	}
	69
	70	static DECLARE_WORK(async_lookup_work, async_call_lookup_ports);
	71
1da177e4 LT	72	/*
	73	* create sequencer client for OSS sequencer
	74	*/
	75	int __init
	76	snd_seq_oss_create_client(void)
	77	{
	78	int rc;
080dece3 TI	79	struct snd_seq_port_info *port;
080dece3 TI	80	struct snd_seq_port_callback port_callback;
1da177e4	81
1da177e4	82	port = kmalloc(sizeof(*port), GFP_KERNEL);
7b6d9245	83	if (!port) {
1da177e4 LT	84	rc = -ENOMEM;
	85	goto __error;
	86	}
	87
	88	/* create ALSA client */
7b6d9245 CL	89	rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS,
7b6d9245 CL	90	"OSS sequencer");
1da177e4 LT	91	if (rc < 0)
	92	goto __error;
	93
	94	system_client = rc;
	95	debug_printk(("new client = %d\n", rc));
	96
1da177e4 LT	97	/* create annoucement receiver port */
	98	memset(port, 0, sizeof(*port));
	99	strcpy(port->name, "Receiver");
	100	port->addr.client = system_client;
	101	port->capability = SNDRV_SEQ_PORT_CAP_WRITE; /* receive only */
	102	port->type = 0;
	103
	104	memset(&port_callback, 0, sizeof(port_callback));
	105	/* don't set port_callback.owner here. otherwise the module counter
	106	* is incremented and we can no longer release the module..
	107	*/
	108	port_callback.event_input = receive_announce;
	109	port->kernel = &port_callback;
	110
	111	call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, port);
	112	if ((system_port = port->addr.port) >= 0) {
080dece3	113	struct snd_seq_port_subscribe subs;
1da177e4 LT	114
	115	memset(&subs, 0, sizeof(subs));
	116	subs.sender.client = SNDRV_SEQ_CLIENT_SYSTEM;
	117	subs.sender.port = SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE;
	118	subs.dest.client = system_client;
	119	subs.dest.port = system_port;
	120	call_ctl(SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs);
	121	}
	122	rc = 0;
	123
409972c1 TI	124	/* look up midi devices */
	125	schedule_work(&async_lookup_work);
	126
1da177e4 LT	127	__error:
1da177e4 LT	128	kfree(port);
1da177e4 LT	129	return rc;
	130	}
	131
	132
	133	/*
	134	* receive annoucement from system port, and check the midi device
	135	*/
	136	static int
080dece3	137	receive_announce(struct snd_seq_event ev, int direct, void private, int atomic, int hop)
1da177e4	138	{
080dece3	139	struct snd_seq_port_info pinfo;
1da177e4 LT	140
	141	if (atomic)
	142	return 0; /* it must not happen */
	143
	144	switch (ev->type) {
	145	case SNDRV_SEQ_EVENT_PORT_START:
	146	case SNDRV_SEQ_EVENT_PORT_CHANGE:
	147	if (ev->data.addr.client == system_client)
	148	break; /* ignore myself */
	149	memset(&pinfo, 0, sizeof(pinfo));
	150	pinfo.addr = ev->data.addr;
	151	if (call_ctl(SNDRV_SEQ_IOCTL_GET_PORT_INFO, &pinfo) >= 0)
	152	snd_seq_oss_midi_check_new_port(&pinfo);
	153	break;
	154
	155	case SNDRV_SEQ_EVENT_PORT_EXIT:
	156	if (ev->data.addr.client == system_client)
	157	break; /* ignore myself */
	158	snd_seq_oss_midi_check_exit_port(ev->data.addr.client,
	159	ev->data.addr.port);
	160	break;
	161	}
	162	return 0;
	163	}
	164
	165
	166	/*
	167	* delete OSS sequencer client
	168	*/
	169	int
	170	snd_seq_oss_delete_client(void)
	171	{
409972c1	172	cancel_work_sync(&async_lookup_work);
1da177e4 LT	173	if (system_client >= 0)
	174	snd_seq_delete_kernel_client(system_client);
	175
	176	snd_seq_oss_midi_clear_all();
	177
	178	return 0;
	179	}
	180
	181
	182	/*
	183	* open sequencer device
	184	*/
	185	int
	186	snd_seq_oss_open(struct file *file, int level)
	187	{
	188	int i, rc;
080dece3	189	struct seq_oss_devinfo *dp;
1da177e4	190
7034632d ET	191	dp = kzalloc(sizeof(*dp), GFP_KERNEL);
7034632d ET	192	if (!dp) {
1da177e4 LT	193	snd_printk(KERN_ERR "can't malloc device info\n");
	194	return -ENOMEM;
	195	}
	196	debug_printk(("oss_open: dp = %p\n", dp));
	197
7034632d ET	198	dp->cseq = system_client;
	199	dp->port = -1;
	200	dp->queue = -1;
	201
1da177e4 LT	202	for (i = 0; i < SNDRV_SEQ_OSS_MAX_CLIENTS; i++) {
	203	if (client_table[i] == NULL)
	204	break;
	205	}
7034632d ET	206
7034632d ET	207	dp->index = i;
1da177e4 LT	208	if (i >= SNDRV_SEQ_OSS_MAX_CLIENTS) {
1da177e4 LT	209	snd_printk(KERN_ERR "too many applications\n");
7034632d ET	210	rc = -ENOMEM;
7034632d ET	211	goto _error;
1da177e4 LT	212	}
1da177e4 LT	213
1da177e4 LT	214	/* look up synth and midi devices */
	215	snd_seq_oss_synth_setup(dp);
	216	snd_seq_oss_midi_setup(dp);
	217
	218	if (dp->synth_opened == 0 && dp->max_mididev == 0) {
	219	/* snd_printk(KERN_ERR "no device found\n"); */
	220	rc = -ENODEV;
	221	goto _error;
	222	}
	223
	224	/* create port */
	225	debug_printk(("create new port\n"));
7034632d ET	226	rc = create_port(dp);
7034632d ET	227	if (rc < 0) {
1da177e4 LT	228	snd_printk(KERN_ERR "can't create port\n");
	229	goto _error;
	230	}
	231
	232	/* allocate queue */
	233	debug_printk(("allocate queue\n"));
7034632d ET	234	rc = alloc_seq_queue(dp);
7034632d ET	235	if (rc < 0)
1da177e4 LT	236	goto _error;
	237
	238	/* set address */
	239	dp->addr.client = dp->cseq;
	240	dp->addr.port = dp->port;
	241	/dp->addr.queue = dp->queue;/
	242	/dp->addr.channel = 0;/
	243
	244	dp->seq_mode = level;
	245
	246	/* set up file mode */
	247	dp->file_mode = translate_mode(file);
	248
	249	/* initialize read queue */
	250	debug_printk(("initialize read queue\n"));
	251	if (is_read_mode(dp->file_mode)) {
7034632d ET	252	dp->readq = snd_seq_oss_readq_new(dp, maxqlen);
7034632d ET	253	if (!dp->readq) {
1da177e4 LT	254	rc = -ENOMEM;
	255	goto _error;
	256	}
	257	}
	258
	259	/* initialize write queue */
	260	debug_printk(("initialize write queue\n"));
	261	if (is_write_mode(dp->file_mode)) {
	262	dp->writeq = snd_seq_oss_writeq_new(dp, maxqlen);
7034632d	263	if (!dp->writeq) {
1da177e4 LT	264	rc = -ENOMEM;
	265	goto _error;
	266	}
	267	}
	268
	269	/* initialize timer */
	270	debug_printk(("initialize timer\n"));
7034632d ET	271	dp->timer = snd_seq_oss_timer_new(dp);
7034632d ET	272	if (!dp->timer) {
1da177e4 LT	273	snd_printk(KERN_ERR "can't alloc timer\n");
	274	rc = -ENOMEM;
	275	goto _error;
	276	}
	277	debug_printk(("timer initialized\n"));
	278
	279	/* set private data pointer */
	280	file->private_data = dp;
	281
	282	/* set up for mode2 */
	283	if (level == SNDRV_SEQ_OSS_MODE_MUSIC)
	284	snd_seq_oss_synth_setup_midi(dp);
	285	else if (is_read_mode(dp->file_mode))
	286	snd_seq_oss_midi_open_all(dp, SNDRV_SEQ_OSS_FILE_READ);
	287
	288	client_table[dp->index] = dp;
	289	num_clients++;
	290
	291	debug_printk(("open done\n"));
	292	return 0;
	293
	294	_error:
	295	snd_seq_oss_synth_cleanup(dp);
	296	snd_seq_oss_midi_cleanup(dp);
7034632d	297	delete_seq_queue(dp->queue);
27f7ad53	298	delete_port(dp);
1da177e4 LT	299
	300	return rc;
	301	}
	302
	303	/*
	304	* translate file flags to private mode
	305	*/
	306	static int
	307	translate_mode(struct file *file)
	308	{
	309	int file_mode = 0;
	310	if ((file->f_flags & O_ACCMODE) != O_RDONLY)
	311	file_mode \|= SNDRV_SEQ_OSS_FILE_WRITE;
	312	if ((file->f_flags & O_ACCMODE) != O_WRONLY)
	313	file_mode \|= SNDRV_SEQ_OSS_FILE_READ;
	314	if (file->f_flags & O_NONBLOCK)
	315	file_mode \|= SNDRV_SEQ_OSS_FILE_NONBLOCK;
	316	return file_mode;
	317	}
	318
	319
	320	/*
	321	* create sequencer port
	322	*/
	323	static int
080dece3	324	create_port(struct seq_oss_devinfo *dp)
1da177e4 LT	325	{
1da177e4 LT	326	int rc;
080dece3 TI	327	struct snd_seq_port_info port;
080dece3 TI	328	struct snd_seq_port_callback callback;
1da177e4 LT	329
	330	memset(&port, 0, sizeof(port));
	331	port.addr.client = dp->cseq;
	332	sprintf(port.name, "Sequencer-%d", dp->index);
	333	port.capability = SNDRV_SEQ_PORT_CAP_READ\|SNDRV_SEQ_PORT_CAP_WRITE; /* no subscription */
	334	port.type = SNDRV_SEQ_PORT_TYPE_SPECIFIC;
	335	port.midi_channels = 128;
	336	port.synth_voices = 128;
	337
	338	memset(&callback, 0, sizeof(callback));
	339	callback.owner = THIS_MODULE;
	340	callback.private_data = dp;
	341	callback.event_input = snd_seq_oss_event_input;
	342	callback.private_free = free_devinfo;
	343	port.kernel = &callback;
	344
	345	rc = call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, &port);
	346	if (rc < 0)
	347	return rc;
	348
	349	dp->port = port.addr.port;
	350	debug_printk(("new port = %d\n", port.addr.port));
	351
	352	return 0;
	353	}
	354
	355	/*
	356	* delete ALSA port
	357	*/
	358	static int
080dece3	359	delete_port(struct seq_oss_devinfo *dp)
1da177e4	360	{
27f7ad53 TI	361	if (dp->port < 0) {
27f7ad53 TI	362	kfree(dp);
1da177e4	363	return 0;
27f7ad53	364	}
1da177e4 LT	365
	366	debug_printk(("delete_port %i\n", dp->port));
	367	return snd_seq_event_port_detach(dp->cseq, dp->port);
	368	}
	369
	370	/*
	371	* allocate a queue
	372	*/
	373	static int
080dece3	374	alloc_seq_queue(struct seq_oss_devinfo *dp)
1da177e4	375	{
080dece3	376	struct snd_seq_queue_info qinfo;
1da177e4 LT	377	int rc;
	378
	379	memset(&qinfo, 0, sizeof(qinfo));
	380	qinfo.owner = system_client;
	381	qinfo.locked = 1;
	382	strcpy(qinfo.name, "OSS Sequencer Emulation");
	383	if ((rc = call_ctl(SNDRV_SEQ_IOCTL_CREATE_QUEUE, &qinfo)) < 0)
	384	return rc;
	385	dp->queue = qinfo.queue;
	386	return 0;
	387	}
	388
	389	/*
	390	* release queue
	391	*/
	392	static int
	393	delete_seq_queue(int queue)
	394	{
080dece3	395	struct snd_seq_queue_info qinfo;
1da177e4 LT	396	int rc;
	397
	398	if (queue < 0)
	399	return 0;
	400	memset(&qinfo, 0, sizeof(qinfo));
	401	qinfo.queue = queue;
	402	rc = call_ctl(SNDRV_SEQ_IOCTL_DELETE_QUEUE, &qinfo);
	403	if (rc < 0)
	404	printk(KERN_ERR "seq-oss: unable to delete queue %d (%d)\n", queue, rc);
	405	return rc;
	406	}
	407
	408
	409	/*
	410	* free device informations - private_free callback of port
	411	*/
	412	static void
	413	free_devinfo(void *private)
	414	{
080dece3	415	struct seq_oss_devinfo dp = (struct seq_oss_devinfo )private;
1da177e4 LT	416
	417	if (dp->timer)
	418	snd_seq_oss_timer_delete(dp->timer);
	419
	420	if (dp->writeq)
	421	snd_seq_oss_writeq_delete(dp->writeq);
	422
	423	if (dp->readq)
	424	snd_seq_oss_readq_delete(dp->readq);
	425
	426	kfree(dp);
	427	}
	428
	429
	430	/*
	431	* close sequencer device
	432	*/
	433	void
080dece3	434	snd_seq_oss_release(struct seq_oss_devinfo *dp)
1da177e4 LT	435	{
	436	int queue;
	437
	438	client_table[dp->index] = NULL;
	439	num_clients--;
	440
	441	debug_printk(("resetting..\n"));
	442	snd_seq_oss_reset(dp);
	443
	444	debug_printk(("cleaning up..\n"));
	445	snd_seq_oss_synth_cleanup(dp);
	446	snd_seq_oss_midi_cleanup(dp);
	447
	448	/* clear slot */
	449	debug_printk(("releasing resource..\n"));
	450	queue = dp->queue;
	451	if (dp->port >= 0)
	452	delete_port(dp);
	453	delete_seq_queue(queue);
	454
	455	debug_printk(("release done\n"));
	456	}
	457
	458
1da177e4 LT	459	/*
	460	* reset sequencer devices
	461	*/
	462	void
080dece3	463	snd_seq_oss_reset(struct seq_oss_devinfo *dp)
1da177e4 LT	464	{
	465	int i;
	466
	467	/* reset all synth devices */
	468	for (i = 0; i < dp->max_synthdev; i++)
	469	snd_seq_oss_synth_reset(dp, i);
	470
	471	/* reset all midi devices */
	472	if (dp->seq_mode != SNDRV_SEQ_OSS_MODE_MUSIC) {
	473	for (i = 0; i < dp->max_mididev; i++)
	474	snd_seq_oss_midi_reset(dp, i);
	475	}
	476
	477	/* remove queues */
	478	if (dp->readq)
	479	snd_seq_oss_readq_clear(dp->readq);
	480	if (dp->writeq)
	481	snd_seq_oss_writeq_clear(dp->writeq);
	482
	483	/* reset timer */
	484	snd_seq_oss_timer_stop(dp->timer);
	485	}
	486
	487
04f141a8	488	#ifdef CONFIG_PROC_FS
1da177e4 LT	489	/*
	490	* misc. functions for proc interface
	491	*/
	492	char *
	493	enabled_str(int bool)
	494	{
	495	return bool ? "enabled" : "disabled";
	496	}
	497
	498	static char *
	499	filemode_str(int val)
	500	{
	501	static char *str[] = {
	502	"none", "read", "write", "read/write",
	503	};
	504	return str[val & SNDRV_SEQ_OSS_FILE_ACMODE];
	505	}
	506
	507
	508	/*
	509	* proc interface
	510	*/
	511	void
080dece3	512	snd_seq_oss_system_info_read(struct snd_info_buffer *buf)
1da177e4 LT	513	{
1da177e4 LT	514	int i;
080dece3	515	struct seq_oss_devinfo *dp;
1da177e4 LT	516
	517	snd_iprintf(buf, "ALSA client number %d\n", system_client);
	518	snd_iprintf(buf, "ALSA receiver port %d\n", system_port);
	519
	520	snd_iprintf(buf, "\nNumber of applications: %d\n", num_clients);
	521	for (i = 0; i < num_clients; i++) {
	522	snd_iprintf(buf, "\nApplication %d: ", i);
	523	if ((dp = client_table[i]) == NULL) {
	524	snd_iprintf(buf, "empty\n");
	525	continue;
	526	}
	527	snd_iprintf(buf, "port %d : queue %d\n", dp->port, dp->queue);
	528	snd_iprintf(buf, " sequencer mode = %s : file open mode = %s\n",
	529	(dp->seq_mode ? "music" : "synth"),
	530	filemode_str(dp->file_mode));
	531	if (dp->seq_mode)
	532	snd_iprintf(buf, " timer tempo = %d, timebase = %d\n",
	533	dp->timer->oss_tempo, dp->timer->oss_timebase);
	534	snd_iprintf(buf, " max queue length %d\n", maxqlen);
	535	if (is_read_mode(dp->file_mode) && dp->readq)
	536	snd_seq_oss_readq_info_read(dp->readq, buf);
	537	}
	538	}
04f141a8	539	#endif /* CONFIG_PROC_FS */