[deliverable/linux.git] / sound / drivers / opl4 / opl4_seq.c

/*
 * OPL4 sequencer functions
 *
 * Copyright (c) 2003 by Clemens Ladisch <clemens@ladisch.de>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed and/or modified 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 SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "opl4_local.h"
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <linux/module.h>
#include <sound/initval.h>

MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
MODULE_DESCRIPTION("OPL4 wavetable synth driver");
MODULE_LICENSE("Dual BSD/GPL");

int volume_boost = 8;

module_param(volume_boost, int, 0644);
MODULE_PARM_DESC(volume_boost, "Additional volume for OPL4 wavetable sounds.");

static int snd_opl4_seq_use_inc(struct snd_opl4 *opl4)
{
	if (!try_module_get(opl4->card->module))
		return -EFAULT;
	return 0;
}

static void snd_opl4_seq_use_dec(struct snd_opl4 *opl4)
{
	module_put(opl4->card->module);
}

static int snd_opl4_seq_use(void *private_data, struct snd_seq_port_subscribe *info)
{
	struct snd_opl4 *opl4 = private_data;
	int err;

	mutex_lock(&opl4->access_mutex);

	if (opl4->used) {
		mutex_unlock(&opl4->access_mutex);
		return -EBUSY;
	}
	opl4->used++;

	if (info->sender.client != SNDRV_SEQ_CLIENT_SYSTEM) {
		err = snd_opl4_seq_use_inc(opl4);
		if (err < 0) {
			mutex_unlock(&opl4->access_mutex);
			return err;
		}
	}

	mutex_unlock(&opl4->access_mutex);

	snd_opl4_synth_reset(opl4);
	return 0;
}

static int snd_opl4_seq_unuse(void *private_data, struct snd_seq_port_subscribe *info)
{
	struct snd_opl4 *opl4 = private_data;

	snd_opl4_synth_shutdown(opl4);

	mutex_lock(&opl4->access_mutex);
	opl4->used--;
	mutex_unlock(&opl4->access_mutex);

	if (info->sender.client != SNDRV_SEQ_CLIENT_SYSTEM)
		snd_opl4_seq_use_dec(opl4);
	return 0;
}

static struct snd_midi_op opl4_ops = {
	.note_on =		snd_opl4_note_on,
	.note_off =		snd_opl4_note_off,
	.note_terminate =	snd_opl4_terminate_note,
	.control =		snd_opl4_control,
	.sysex =		snd_opl4_sysex,
};

static int snd_opl4_seq_event_input(struct snd_seq_event *ev, int direct,
				    void *private_data, int atomic, int hop)
{
	struct snd_opl4 *opl4 = private_data;

	snd_midi_process_event(&opl4_ops, ev, opl4->chset);
	return 0;
}

static void snd_opl4_seq_free_port(void *private_data)
{
	struct snd_opl4 *opl4 = private_data;

	snd_midi_channel_free_set(opl4->chset);
}

static int snd_opl4_seq_new_device(struct snd_seq_device *dev)
{
	struct snd_opl4 *opl4;
	int client;
	struct snd_seq_port_callback pcallbacks;

	opl4 = *(struct snd_opl4 **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
	if (!opl4)
		return -EINVAL;

	if (snd_yrw801_detect(opl4) < 0)
		return -ENODEV;

	opl4->chset = snd_midi_channel_alloc_set(16);
	if (!opl4->chset)
		return -ENOMEM;
	opl4->chset->private_data = opl4;

	/* allocate new client */
	client = snd_seq_create_kernel_client(opl4->card, opl4->seq_dev_num,
					      "OPL4 Wavetable");
	if (client < 0) {
		snd_midi_channel_free_set(opl4->chset);
		return client;
	}
	opl4->seq_client = client;
	opl4->chset->client = client;

	/* create new port */
	memset(&pcallbacks, 0, sizeof(pcallbacks));
	pcallbacks.owner = THIS_MODULE;
	pcallbacks.use = snd_opl4_seq_use;
	pcallbacks.unuse = snd_opl4_seq_unuse;
	pcallbacks.event_input = snd_opl4_seq_event_input;
	pcallbacks.private_free = snd_opl4_seq_free_port;
	pcallbacks.private_data = opl4;

	opl4->chset->port = snd_seq_event_port_attach(client, &pcallbacks,
						      SNDRV_SEQ_PORT_CAP_WRITE |
						      SNDRV_SEQ_PORT_CAP_SUBS_WRITE,
						      SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
						      SNDRV_SEQ_PORT_TYPE_MIDI_GM |
						      SNDRV_SEQ_PORT_TYPE_HARDWARE |
						      SNDRV_SEQ_PORT_TYPE_SYNTHESIZER,
						      16, 24,
						      "OPL4 Wavetable Port");
	if (opl4->chset->port < 0) {
		int err = opl4->chset->port;
		snd_midi_channel_free_set(opl4->chset);
		snd_seq_delete_kernel_client(client);
		opl4->seq_client = -1;
		return err;
	}
	return 0;
}

static int snd_opl4_seq_delete_device(struct snd_seq_device *dev)
{
	struct snd_opl4 *opl4;

	opl4 = *(struct snd_opl4 **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
	if (!opl4)
		return -EINVAL;

	if (opl4->seq_client >= 0) {
		snd_seq_delete_kernel_client(opl4->seq_client);
		opl4->seq_client = -1;
	}
	return 0;
}

static int __init alsa_opl4_synth_init(void)
{
	static struct snd_seq_dev_ops ops = {
		snd_opl4_seq_new_device,
		snd_opl4_seq_delete_device
	};

	return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OPL4, &ops,
					      sizeof(struct snd_opl4 *));
}

static void __exit alsa_opl4_synth_exit(void)
{
	snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_OPL4);
}

module_init(alsa_opl4_synth_init)
module_exit(alsa_opl4_synth_exit)
Commit	Line	Data
1da177e4 LT	1	/*
	2	* OPL4 sequencer functions
	3	*
	4	* Copyright (c) 2003 by Clemens Ladisch <clemens@ladisch.de>
	5	* All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	* 1. Redistributions of source code must retain the above copyright
	11	* notice, this list of conditions, and the following disclaimer,
	12	* without modification.
	13	* 2. The name of the author may not be used to endorse or promote products
	14	* derived from this software without specific prior written permission.
	15	*
	16	* Alternatively, this software may be distributed and/or modified under the
	17	* terms of the GNU General Public License as published by the Free Software
	18	* Foundation; either version 2 of the License, or (at your option) any later
	19	* version.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
	25	* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
	34	#include "opl4_local.h"
	35	#include <linux/init.h>
	36	#include <linux/moduleparam.h>
da155d5b	37	#include <linux/module.h>
1da177e4 LT	38	#include <sound/initval.h>
	39
	40	MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
	41	MODULE_DESCRIPTION("OPL4 wavetable synth driver");
	42	MODULE_LICENSE("Dual BSD/GPL");
	43
	44	int volume_boost = 8;
	45
	46	module_param(volume_boost, int, 0644);
	47	MODULE_PARM_DESC(volume_boost, "Additional volume for OPL4 wavetable sounds.");
	48
a42dd420	49	static int snd_opl4_seq_use_inc(struct snd_opl4 *opl4)
1da177e4 LT	50	{
	51	if (!try_module_get(opl4->card->module))
	52	return -EFAULT;
	53	return 0;
	54	}
	55
a42dd420	56	static void snd_opl4_seq_use_dec(struct snd_opl4 *opl4)
1da177e4 LT	57	{
	58	module_put(opl4->card->module);
	59	}
	60
a42dd420	61	static int snd_opl4_seq_use(void private_data, struct snd_seq_port_subscribe info)
1da177e4	62	{
a42dd420	63	struct snd_opl4 *opl4 = private_data;
1da177e4 LT	64	int err;
1da177e4 LT	65
ef9f0a42	66	mutex_lock(&opl4->access_mutex);
1da177e4 LT	67
1da177e4 LT	68	if (opl4->used) {
ef9f0a42	69	mutex_unlock(&opl4->access_mutex);
1da177e4 LT	70	return -EBUSY;
	71	}
	72	opl4->used++;
	73
	74	if (info->sender.client != SNDRV_SEQ_CLIENT_SYSTEM) {
	75	err = snd_opl4_seq_use_inc(opl4);
	76	if (err < 0) {
ef9f0a42	77	mutex_unlock(&opl4->access_mutex);
1da177e4 LT	78	return err;
	79	}
	80	}
	81
ef9f0a42	82	mutex_unlock(&opl4->access_mutex);
1da177e4 LT	83
	84	snd_opl4_synth_reset(opl4);
	85	return 0;
	86	}
	87
a42dd420	88	static int snd_opl4_seq_unuse(void private_data, struct snd_seq_port_subscribe info)
1da177e4	89	{
a42dd420	90	struct snd_opl4 *opl4 = private_data;
1da177e4 LT	91
	92	snd_opl4_synth_shutdown(opl4);
	93
ef9f0a42	94	mutex_lock(&opl4->access_mutex);
1da177e4	95	opl4->used--;
ef9f0a42	96	mutex_unlock(&opl4->access_mutex);
1da177e4 LT	97
	98	if (info->sender.client != SNDRV_SEQ_CLIENT_SYSTEM)
	99	snd_opl4_seq_use_dec(opl4);
	100	return 0;
	101	}
	102
a42dd420	103	static struct snd_midi_op opl4_ops = {
1da177e4 LT	104	.note_on = snd_opl4_note_on,
	105	.note_off = snd_opl4_note_off,
	106	.note_terminate = snd_opl4_terminate_note,
	107	.control = snd_opl4_control,
	108	.sysex = snd_opl4_sysex,
	109	};
	110
a42dd420	111	static int snd_opl4_seq_event_input(struct snd_seq_event *ev, int direct,
1da177e4 LT	112	void *private_data, int atomic, int hop)
1da177e4 LT	113	{
a42dd420	114	struct snd_opl4 *opl4 = private_data;
1da177e4 LT	115
	116	snd_midi_process_event(&opl4_ops, ev, opl4->chset);
	117	return 0;
	118	}
	119
	120	static void snd_opl4_seq_free_port(void *private_data)
	121	{
a42dd420	122	struct snd_opl4 *opl4 = private_data;
1da177e4 LT	123
	124	snd_midi_channel_free_set(opl4->chset);
	125	}
	126
a42dd420	127	static int snd_opl4_seq_new_device(struct snd_seq_device *dev)
1da177e4	128	{
a42dd420	129	struct snd_opl4 *opl4;
1da177e4	130	int client;
a42dd420	131	struct snd_seq_port_callback pcallbacks;
1da177e4	132
a42dd420	133	opl4 = (struct snd_opl4 *)SNDRV_SEQ_DEVICE_ARGPTR(dev);
1da177e4 LT	134	if (!opl4)
	135	return -EINVAL;
	136
	137	if (snd_yrw801_detect(opl4) < 0)
	138	return -ENODEV;
	139
	140	opl4->chset = snd_midi_channel_alloc_set(16);
	141	if (!opl4->chset)
	142	return -ENOMEM;
	143	opl4->chset->private_data = opl4;
	144
	145	/* allocate new client */
7b6d9245 CL	146	client = snd_seq_create_kernel_client(opl4->card, opl4->seq_dev_num,
7b6d9245 CL	147	"OPL4 Wavetable");
1da177e4 LT	148	if (client < 0) {
	149	snd_midi_channel_free_set(opl4->chset);
	150	return client;
	151	}
	152	opl4->seq_client = client;
	153	opl4->chset->client = client;
	154
1da177e4 LT	155	/* create new port */
	156	memset(&pcallbacks, 0, sizeof(pcallbacks));
	157	pcallbacks.owner = THIS_MODULE;
	158	pcallbacks.use = snd_opl4_seq_use;
	159	pcallbacks.unuse = snd_opl4_seq_unuse;
	160	pcallbacks.event_input = snd_opl4_seq_event_input;
	161	pcallbacks.private_free = snd_opl4_seq_free_port;
	162	pcallbacks.private_data = opl4;
	163
	164	opl4->chset->port = snd_seq_event_port_attach(client, &pcallbacks,
	165	SNDRV_SEQ_PORT_CAP_WRITE \|
	166	SNDRV_SEQ_PORT_CAP_SUBS_WRITE,
	167	SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC \|
450047a7 CL	168	SNDRV_SEQ_PORT_TYPE_MIDI_GM \|
	169	SNDRV_SEQ_PORT_TYPE_HARDWARE \|
	170	SNDRV_SEQ_PORT_TYPE_SYNTHESIZER,
1da177e4 LT	171	16, 24,
	172	"OPL4 Wavetable Port");
	173	if (opl4->chset->port < 0) {
	174	int err = opl4->chset->port;
	175	snd_midi_channel_free_set(opl4->chset);
	176	snd_seq_delete_kernel_client(client);
	177	opl4->seq_client = -1;
	178	return err;
	179	}
	180	return 0;
	181	}
	182
a42dd420	183	static int snd_opl4_seq_delete_device(struct snd_seq_device *dev)
1da177e4	184	{
a42dd420	185	struct snd_opl4 *opl4;
1da177e4	186
a42dd420	187	opl4 = (struct snd_opl4 *)SNDRV_SEQ_DEVICE_ARGPTR(dev);
1da177e4 LT	188	if (!opl4)
	189	return -EINVAL;
	190
	191	if (opl4->seq_client >= 0) {
	192	snd_seq_delete_kernel_client(opl4->seq_client);
	193	opl4->seq_client = -1;
	194	}
	195	return 0;
	196	}
	197
	198	static int __init alsa_opl4_synth_init(void)
	199	{
a42dd420	200	static struct snd_seq_dev_ops ops = {
1da177e4 LT	201	snd_opl4_seq_new_device,
	202	snd_opl4_seq_delete_device
	203	};
	204
	205	return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OPL4, &ops,
a42dd420	206	sizeof(struct snd_opl4 *));
1da177e4 LT	207	}
	208
	209	static void __exit alsa_opl4_synth_exit(void)
	210	{
	211	snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_OPL4);
	212	}
	213
	214	module_init(alsa_opl4_synth_init)
	215	module_exit(alsa_opl4_synth_exit)