[mirror_ubuntu-bionic-kernel.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/moduleparam.h>
#include <linux/slab.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)


/*
 * 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));

	/* look up midi devices */
	snd_seq_oss_midi_lookup_ports(system_client);

	/* 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;

 __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)
{
	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_writeq_delete(dp->writeq);
	snd_seq_oss_readq_delete(dp->readq);
	snd_seq_oss_synth_cleanup(dp);
	snd_seq_oss_midi_cleanup(dp);
	delete_port(dp);
	delete_seq_queue(dp->queue);
	kfree(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)
		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"));
}


/*
 * Wait until the queue is empty (if we don't have nonblock)
 */
void
snd_seq_oss_drain_write(struct seq_oss_devinfo *dp)
{
	if (! dp->timer->running)
		return;
	if (is_write_mode(dp->file_mode) && !is_nonblock_mode(dp->file_mode) &&
	    dp->writeq) {
		debug_printk(("syncing..\n"));
		while (snd_seq_oss_writeq_sync(dp->writeq))
			;
	}
}


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