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

/*
 * ALSA sequencer MIDI-through client
 * Copyright (c) 1999-2000 by 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 <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <sound/core.h>
#include "seq_clientmgr.h"
#include <sound/initval.h>
#include <sound/asoundef.h>

/*

  Sequencer MIDI-through client

  This gives a simple midi-through client.  All the normal input events
  are redirected to output port immediately.
  The routing can be done via aconnect program in alsa-utils.

  Each client has a static client number 62 (= SNDRV_SEQ_CLIENT_DUMMY).
  If you want to auto-load this module, you may add the following alias
  in your /etc/conf.modules file.

	alias snd-seq-client-62  snd-seq-dummy

  The module is loaded on demand for client 62, or /proc/asound/seq/
  is accessed.  If you don't need this module to be loaded, alias
  snd-seq-client-62 as "off".  This will help modprobe.

  The number of ports to be created can be specified via the module
  parameter "ports".  For example, to create four ports, add the
  following option in a configuration file under /etc/modprobe.d/:

	option snd-seq-dummy ports=4

  The model option "duplex=1" enables duplex operation to the port.
  In duplex mode, a pair of ports are created instead of single port,
  and events are tunneled between pair-ports.  For example, input to
  port A is sent to output port of another port B and vice versa.
  In duplex mode, each port has DUPLEX capability.

 */


MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("ALSA sequencer MIDI-through client");
MODULE_LICENSE("GPL");
MODULE_ALIAS("snd-seq-client-" __stringify(SNDRV_SEQ_CLIENT_DUMMY));

static int ports = 1;
static bool duplex;

module_param(ports, int, 0444);
MODULE_PARM_DESC(ports, "number of ports to be created");
module_param(duplex, bool, 0444);
MODULE_PARM_DESC(duplex, "create DUPLEX ports");

struct snd_seq_dummy_port {
	int client;
	int port;
	int duplex;
	int connect;
};

static int my_client = -1;

/*
 * event input callback - just redirect events to subscribers
 */
static int
dummy_input(struct snd_seq_event *ev, int direct, void *private_data,
	    int atomic, int hop)
{
	struct snd_seq_dummy_port *p;
	struct snd_seq_event tmpev;

	p = private_data;
	if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM ||
	    ev->type == SNDRV_SEQ_EVENT_KERNEL_ERROR)
		return 0; /* ignore system messages */
	tmpev = *ev;
	if (p->duplex)
		tmpev.source.port = p->connect;
	else
		tmpev.source.port = p->port;
	tmpev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
	return snd_seq_kernel_client_dispatch(p->client, &tmpev, atomic, hop);
}

/*
 * free_private callback
 */
static void
dummy_free(void *private_data)
{
	kfree(private_data);
}

/*
 * create a port
 */
static struct snd_seq_dummy_port __init *
create_port(int idx, int type)
{
	struct snd_seq_port_info pinfo;
	struct snd_seq_port_callback pcb;
	struct snd_seq_dummy_port *rec;

	if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
		return NULL;

	rec->client = my_client;
	rec->duplex = duplex;
	rec->connect = 0;
	memset(&pinfo, 0, sizeof(pinfo));
	pinfo.addr.client = my_client;
	if (duplex)
		sprintf(pinfo.name, "Midi Through Port-%d:%c", idx,
			(type ? 'B' : 'A'));
	else
		sprintf(pinfo.name, "Midi Through Port-%d", idx);
	pinfo.capability = SNDRV_SEQ_PORT_CAP_READ | SNDRV_SEQ_PORT_CAP_SUBS_READ;
	pinfo.capability |= SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
	if (duplex)
		pinfo.capability |= SNDRV_SEQ_PORT_CAP_DUPLEX;
	pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
		| SNDRV_SEQ_PORT_TYPE_SOFTWARE
		| SNDRV_SEQ_PORT_TYPE_PORT;
	memset(&pcb, 0, sizeof(pcb));
	pcb.owner = THIS_MODULE;
	pcb.event_input = dummy_input;
	pcb.private_free = dummy_free;
	pcb.private_data = rec;
	pinfo.kernel = &pcb;
	if (snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_CREATE_PORT, &pinfo) < 0) {
		kfree(rec);
		return NULL;
	}
	rec->port = pinfo.addr.port;
	return rec;
}

/*
 * register client and create ports
 */
static int __init
register_client(void)
{
	struct snd_seq_dummy_port *rec1, *rec2;
	int i;

	if (ports < 1) {
		snd_printk(KERN_ERR "invalid number of ports %d\n", ports);
		return -EINVAL;
	}

	/* create client */
	my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY,
						 "Midi Through");
	if (my_client < 0)
		return my_client;

	/* create ports */
	for (i = 0; i < ports; i++) {
		rec1 = create_port(i, 0);
		if (rec1 == NULL) {
			snd_seq_delete_kernel_client(my_client);
			return -ENOMEM;
		}
		if (duplex) {
			rec2 = create_port(i, 1);
			if (rec2 == NULL) {
				snd_seq_delete_kernel_client(my_client);
				return -ENOMEM;
			}
			rec1->connect = rec2->port;
			rec2->connect = rec1->port;
		}
	}

	return 0;
}

/*
 * delete client if exists
 */
static void __exit
delete_client(void)
{
	if (my_client >= 0)
		snd_seq_delete_kernel_client(my_client);
}

/*
 *  Init part
 */

static int __init alsa_seq_dummy_init(void)
{
	int err;
	snd_seq_autoload_lock();
	err = register_client();
	snd_seq_autoload_unlock();
	return err;
}

static void __exit alsa_seq_dummy_exit(void)
{
	delete_client();
}

module_init(alsa_seq_dummy_init)
module_exit(alsa_seq_dummy_exit)
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ALSA sequencer MIDI-through client
	3	* Copyright (c) 1999-2000 by Takashi Iwai <tiwai@suse.de>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*
	19	*/
	20
1da177e4 LT	21	#include <linux/init.h>
1da177e4 LT	22	#include <linux/slab.h>
65a77217	23	#include <linux/module.h>
1da177e4 LT	24	#include <sound/core.h>
	25	#include "seq_clientmgr.h"
	26	#include <sound/initval.h>
	27	#include <sound/asoundef.h>
	28
	29	/*
	30
	31	Sequencer MIDI-through client
	32
	33	This gives a simple midi-through client. All the normal input events
	34	are redirected to output port immediately.
	35	The routing can be done via aconnect program in alsa-utils.
	36
	37	Each client has a static client number 62 (= SNDRV_SEQ_CLIENT_DUMMY).
	38	If you want to auto-load this module, you may add the following alias
	39	in your /etc/conf.modules file.
	40
	41	alias snd-seq-client-62 snd-seq-dummy
	42
	43	The module is loaded on demand for client 62, or /proc/asound/seq/
	44	is accessed. If you don't need this module to be loaded, alias
	45	snd-seq-client-62 as "off". This will help modprobe.
	46
	47	The number of ports to be created can be specified via the module
	48	parameter "ports". For example, to create four ports, add the
970e2486	49	following option in a configuration file under /etc/modprobe.d/:
1da177e4 LT	50
	51	option snd-seq-dummy ports=4
	52
25985edc	53	The model option "duplex=1" enables duplex operation to the port.
1da177e4 LT	54	In duplex mode, a pair of ports are created instead of single port,
	55	and events are tunneled between pair-ports. For example, input to
	56	port A is sent to output port of another port B and vice versa.
	57	In duplex mode, each port has DUPLEX capability.
	58
	59	*/
	60
	61
	62	MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
	63	MODULE_DESCRIPTION("ALSA sequencer MIDI-through client");
	64	MODULE_LICENSE("GPL");
	65	MODULE_ALIAS("snd-seq-client-" __stringify(SNDRV_SEQ_CLIENT_DUMMY));
	66
	67	static int ports = 1;
a67ff6a5	68	static bool duplex;
1da177e4 LT	69
	70	module_param(ports, int, 0444);
	71	MODULE_PARM_DESC(ports, "number of ports to be created");
	72	module_param(duplex, bool, 0444);
	73	MODULE_PARM_DESC(duplex, "create DUPLEX ports");
	74
c7e0b5bf	75	struct snd_seq_dummy_port {
1da177e4 LT	76	int client;
	77	int port;
	78	int duplex;
	79	int connect;
c7e0b5bf	80	};
1da177e4 LT	81
	82	static int my_client = -1;
	83
1da177e4 LT	84	/*
	85	* event input callback - just redirect events to subscribers
	86	*/
	87	static int
c7e0b5bf TI	88	dummy_input(struct snd_seq_event ev, int direct, void private_data,
c7e0b5bf TI	89	int atomic, int hop)
1da177e4	90	{
c7e0b5bf TI	91	struct snd_seq_dummy_port *p;
c7e0b5bf TI	92	struct snd_seq_event tmpev;
1da177e4 LT	93
	94	p = private_data;
	95	if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM \|\|
	96	ev->type == SNDRV_SEQ_EVENT_KERNEL_ERROR)
	97	return 0; /* ignore system messages */
	98	tmpev = *ev;
	99	if (p->duplex)
	100	tmpev.source.port = p->connect;
	101	else
	102	tmpev.source.port = p->port;
	103	tmpev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
	104	return snd_seq_kernel_client_dispatch(p->client, &tmpev, atomic, hop);
	105	}
	106
	107	/*
	108	* free_private callback
	109	*/
	110	static void
	111	dummy_free(void *private_data)
	112	{
4d572776	113	kfree(private_data);
1da177e4 LT	114	}
	115
	116	/*
	117	* create a port
	118	*/
c7e0b5bf	119	static struct snd_seq_dummy_port __init *
1da177e4 LT	120	create_port(int idx, int type)
1da177e4 LT	121	{
c7e0b5bf TI	122	struct snd_seq_port_info pinfo;
	123	struct snd_seq_port_callback pcb;
	124	struct snd_seq_dummy_port *rec;
1da177e4	125
ecca82b4	126	if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
1da177e4 LT	127	return NULL;
	128
	129	rec->client = my_client;
	130	rec->duplex = duplex;
	131	rec->connect = 0;
	132	memset(&pinfo, 0, sizeof(pinfo));
	133	pinfo.addr.client = my_client;
	134	if (duplex)
	135	sprintf(pinfo.name, "Midi Through Port-%d:%c", idx,
	136	(type ? 'B' : 'A'));
	137	else
	138	sprintf(pinfo.name, "Midi Through Port-%d", idx);
	139	pinfo.capability = SNDRV_SEQ_PORT_CAP_READ \| SNDRV_SEQ_PORT_CAP_SUBS_READ;
	140	pinfo.capability \|= SNDRV_SEQ_PORT_CAP_WRITE \| SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
	141	if (duplex)
	142	pinfo.capability \|= SNDRV_SEQ_PORT_CAP_DUPLEX;
450047a7 CL	143	pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
	144	\| SNDRV_SEQ_PORT_TYPE_SOFTWARE
	145	\| SNDRV_SEQ_PORT_TYPE_PORT;
1da177e4 LT	146	memset(&pcb, 0, sizeof(pcb));
1da177e4 LT	147	pcb.owner = THIS_MODULE;
1da177e4 LT	148	pcb.event_input = dummy_input;
	149	pcb.private_free = dummy_free;
	150	pcb.private_data = rec;
	151	pinfo.kernel = &pcb;
	152	if (snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_CREATE_PORT, &pinfo) < 0) {
	153	kfree(rec);
	154	return NULL;
	155	}
	156	rec->port = pinfo.addr.port;
	157	return rec;
	158	}
	159
	160	/*
	161	* register client and create ports
	162	*/
	163	static int __init
	164	register_client(void)
	165	{
c7e0b5bf	166	struct snd_seq_dummy_port rec1, rec2;
1da177e4 LT	167	int i;
	168
	169	if (ports < 1) {
	170	snd_printk(KERN_ERR "invalid number of ports %d\n", ports);
	171	return -EINVAL;
	172	}
	173
	174	/* create client */
7b6d9245 CL	175	my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY,
7b6d9245 CL	176	"Midi Through");
1da177e4 LT	177	if (my_client < 0)
	178	return my_client;
	179
1da177e4 LT	180	/* create ports */
	181	for (i = 0; i < ports; i++) {
	182	rec1 = create_port(i, 0);
	183	if (rec1 == NULL) {
	184	snd_seq_delete_kernel_client(my_client);
	185	return -ENOMEM;
	186	}
	187	if (duplex) {
	188	rec2 = create_port(i, 1);
	189	if (rec2 == NULL) {
	190	snd_seq_delete_kernel_client(my_client);
	191	return -ENOMEM;
	192	}
	193	rec1->connect = rec2->port;
	194	rec2->connect = rec1->port;
	195	}
	196	}
	197
	198	return 0;
	199	}
	200
	201	/*
	202	* delete client if exists
	203	*/
	204	static void __exit
	205	delete_client(void)
	206	{
	207	if (my_client >= 0)
	208	snd_seq_delete_kernel_client(my_client);
	209	}
	210
	211	/*
	212	* Init part
	213	*/
	214
	215	static int __init alsa_seq_dummy_init(void)
	216	{
	217	int err;
	218	snd_seq_autoload_lock();
	219	err = register_client();
	220	snd_seq_autoload_unlock();
	221	return err;
	222	}
	223
	224	static void __exit alsa_seq_dummy_exit(void)
	225	{
	226	delete_client();
	227	}
	228
	229	module_init(alsa_seq_dummy_init)
	230	module_exit(alsa_seq_dummy_exit)