[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 <sound/driver.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/moduleparam.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 /etc/modprobe.conf:

	option snd-seq-dummy ports=4

  The modle 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 int duplex = 0;

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;

/*
 * unuse callback - send ALL_SOUNDS_OFF and RESET_CONTROLLERS events
 * to subscribers.
 * Note: this callback is called only after all subscribers are removed.
 */
static int
dummy_unuse(void *private_data, struct snd_seq_port_subscribe *info)
{
	struct snd_seq_dummy_port *p;
	int i;
	struct snd_seq_event ev;

	p = private_data;
	memset(&ev, 0, sizeof(ev));
	if (p->duplex)
		ev.source.port = p->connect;
	else
		ev.source.port = p->port;
	ev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
	ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
	for (i = 0; i < 16; i++) {
		ev.data.control.channel = i;
		ev.data.control.param = MIDI_CTL_ALL_SOUNDS_OFF;
		snd_seq_kernel_client_dispatch(p->client, &ev, 0, 0);
		ev.data.control.param = MIDI_CTL_RESET_CONTROLLERS;
		snd_seq_kernel_client_dispatch(p->client, &ev, 0, 0);
	}
	return 0;
}

/*
 * 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;
	memset(&pcb, 0, sizeof(pcb));
	pcb.owner = THIS_MODULE;
	pcb.unuse = dummy_unuse;
	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_client_callback cb;
	struct snd_seq_client_info cinfo;
	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 */
	memset(&cb, 0, sizeof(cb));
	cb.allow_input = 1;
	cb.allow_output = 1;
	my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY, &cb);
	if (my_client < 0)
		return my_client;

	/* set client name */
	memset(&cinfo, 0, sizeof(cinfo));
	cinfo.client = my_client;
	cinfo.type = KERNEL_CLIENT;
	strcpy(cinfo.name, "Midi Through");
	snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo);

	/* 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
	21	#include <sound/driver.h>
	22	#include <linux/init.h>
	23	#include <linux/slab.h>
	24	#include <linux/moduleparam.h>
	25	#include <sound/core.h>
	26	#include "seq_clientmgr.h"
	27	#include <sound/initval.h>
	28	#include <sound/asoundef.h>
	29
	30	/*
	31
	32	Sequencer MIDI-through client
	33
	34	This gives a simple midi-through client. All the normal input events
	35	are redirected to output port immediately.
	36	The routing can be done via aconnect program in alsa-utils.
	37
	38	Each client has a static client number 62 (= SNDRV_SEQ_CLIENT_DUMMY).
	39	If you want to auto-load this module, you may add the following alias
	40	in your /etc/conf.modules file.
	41
	42	alias snd-seq-client-62 snd-seq-dummy
	43
	44	The module is loaded on demand for client 62, or /proc/asound/seq/
	45	is accessed. If you don't need this module to be loaded, alias
	46	snd-seq-client-62 as "off". This will help modprobe.
	47
	48	The number of ports to be created can be specified via the module
	49	parameter "ports". For example, to create four ports, add the
	50	following option in /etc/modprobe.conf:
	51
	52	option snd-seq-dummy ports=4
	53
	54	The modle option "duplex=1" enables duplex operation to the port.
	55	In duplex mode, a pair of ports are created instead of single port,
	56	and events are tunneled between pair-ports. For example, input to
	57	port A is sent to output port of another port B and vice versa.
	58	In duplex mode, each port has DUPLEX capability.
	59
	60	*/
	61
	62
	63	MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
	64	MODULE_DESCRIPTION("ALSA sequencer MIDI-through client");
65	MODULE_LICENSE("GPL");
66	MODULE_ALIAS("snd-seq-client-" __stringify(SNDRV_SEQ_CLIENT_DUMMY));
67
68	static int ports = 1;
69	static int duplex = 0;
70
71	module_param(ports, int, 0444);
72	MODULE_PARM_DESC(ports, "number of ports to be created");
73	module_param(duplex, bool, 0444);
74	MODULE_PARM_DESC(duplex, "create DUPLEX ports");
75
c7e0b5bf	76	struct snd_seq_dummy_port {
1da177e4 LT	77	int client;
	78	int port;
	79	int duplex;
	80	int connect;
c7e0b5bf	81	};
1da177e4 LT	82
	83	static int my_client = -1;
	84
	85	/*
	86	* unuse callback - send ALL_SOUNDS_OFF and RESET_CONTROLLERS events
	87	* to subscribers.
	88	* Note: this callback is called only after all subscribers are removed.
	89	*/
	90	static int
c7e0b5bf	91	dummy_unuse(void private_data, struct snd_seq_port_subscribe info)
1da177e4	92	{
c7e0b5bf	93	struct snd_seq_dummy_port *p;
1da177e4	94	int i;
c7e0b5bf	95	struct snd_seq_event ev;
1da177e4 LT	96
	97	p = private_data;
	98	memset(&ev, 0, sizeof(ev));
	99	if (p->duplex)
	100	ev.source.port = p->connect;
	101	else
	102	ev.source.port = p->port;
	103	ev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
	104	ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
	105	for (i = 0; i < 16; i++) {
	106	ev.data.control.channel = i;
	107	ev.data.control.param = MIDI_CTL_ALL_SOUNDS_OFF;
	108	snd_seq_kernel_client_dispatch(p->client, &ev, 0, 0);
	109	ev.data.control.param = MIDI_CTL_RESET_CONTROLLERS;
	110	snd_seq_kernel_client_dispatch(p->client, &ev, 0, 0);
	111	}
	112	return 0;
	113	}
	114
	115	/*
	116	* event input callback - just redirect events to subscribers
	117	*/
	118	static int
c7e0b5bf TI	119	dummy_input(struct snd_seq_event ev, int direct, void private_data,
c7e0b5bf TI	120	int atomic, int hop)
1da177e4	121	{
c7e0b5bf TI	122	struct snd_seq_dummy_port *p;
c7e0b5bf TI	123	struct snd_seq_event tmpev;
1da177e4 LT	124
	125	p = private_data;
	126	if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM \|\|
	127	ev->type == SNDRV_SEQ_EVENT_KERNEL_ERROR)
	128	return 0; /* ignore system messages */
	129	tmpev = *ev;
	130	if (p->duplex)
	131	tmpev.source.port = p->connect;
	132	else
	133	tmpev.source.port = p->port;
	134	tmpev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
	135	return snd_seq_kernel_client_dispatch(p->client, &tmpev, atomic, hop);
	136	}
	137
	138	/*
	139	* free_private callback
	140	*/
	141	static void
	142	dummy_free(void *private_data)
	143	{
4d572776	144	kfree(private_data);
1da177e4 LT	145	}
	146
	147	/*
	148	* create a port
	149	*/
c7e0b5bf	150	static struct snd_seq_dummy_port __init *
1da177e4 LT	151	create_port(int idx, int type)
1da177e4 LT	152	{
c7e0b5bf TI	153	struct snd_seq_port_info pinfo;
	154	struct snd_seq_port_callback pcb;
	155	struct snd_seq_dummy_port *rec;
1da177e4	156
ecca82b4	157	if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
1da177e4 LT	158	return NULL;
	159
	160	rec->client = my_client;
	161	rec->duplex = duplex;
	162	rec->connect = 0;
	163	memset(&pinfo, 0, sizeof(pinfo));
	164	pinfo.addr.client = my_client;
	165	if (duplex)
	166	sprintf(pinfo.name, "Midi Through Port-%d:%c", idx,
	167	(type ? 'B' : 'A'));
	168	else
	169	sprintf(pinfo.name, "Midi Through Port-%d", idx);
	170	pinfo.capability = SNDRV_SEQ_PORT_CAP_READ \| SNDRV_SEQ_PORT_CAP_SUBS_READ;
	171	pinfo.capability \|= SNDRV_SEQ_PORT_CAP_WRITE \| SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
	172	if (duplex)
	173	pinfo.capability \|= SNDRV_SEQ_PORT_CAP_DUPLEX;
	174	pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC;
	175	memset(&pcb, 0, sizeof(pcb));
	176	pcb.owner = THIS_MODULE;
	177	pcb.unuse = dummy_unuse;
	178	pcb.event_input = dummy_input;
	179	pcb.private_free = dummy_free;
	180	pcb.private_data = rec;
	181	pinfo.kernel = &pcb;
	182	if (snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_CREATE_PORT, &pinfo) < 0) {
	183	kfree(rec);
	184	return NULL;
	185	}
	186	rec->port = pinfo.addr.port;
	187	return rec;
	188	}
	189
	190	/*
	191	* register client and create ports
	192	*/
	193	static int __init
	194	register_client(void)
	195	{
c7e0b5bf TI	196	struct snd_seq_client_callback cb;
	197	struct snd_seq_client_info cinfo;
	198	struct snd_seq_dummy_port rec1, rec2;
1da177e4 LT	199	int i;
	200
	201	if (ports < 1) {
	202	snd_printk(KERN_ERR "invalid number of ports %d\n", ports);
	203	return -EINVAL;
	204	}
	205
	206	/* create client */
	207	memset(&cb, 0, sizeof(cb));
	208	cb.allow_input = 1;
	209	cb.allow_output = 1;
	210	my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY, &cb);
	211	if (my_client < 0)
	212	return my_client;
	213
	214	/* set client name */
	215	memset(&cinfo, 0, sizeof(cinfo));
	216	cinfo.client = my_client;
	217	cinfo.type = KERNEL_CLIENT;
	218	strcpy(cinfo.name, "Midi Through");
	219	snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo);
	220
	221	/* create ports */
	222	for (i = 0; i < ports; i++) {
	223	rec1 = create_port(i, 0);
	224	if (rec1 == NULL) {
	225	snd_seq_delete_kernel_client(my_client);
	226	return -ENOMEM;
	227	}
	228	if (duplex) {
	229	rec2 = create_port(i, 1);
	230	if (rec2 == NULL) {
	231	snd_seq_delete_kernel_client(my_client);
	232	return -ENOMEM;
	233	}
	234	rec1->connect = rec2->port;
	235	rec2->connect = rec1->port;
	236	}
	237	}
	238
	239	return 0;
	240	}
	241
	242	/*
	243	* delete client if exists
	244	*/
	245	static void __exit
	246	delete_client(void)
	247	{
	248	if (my_client >= 0)
	249	snd_seq_delete_kernel_client(my_client);
	250	}
	251
	252	/*
	253	* Init part
	254	*/
	255
	256	static int __init alsa_seq_dummy_init(void)
	257	{
	258	int err;
	259	snd_seq_autoload_lock();
	260	err = register_client();
	261	snd_seq_autoload_unlock();
	262	return err;
263	}
264
265	static void __exit alsa_seq_dummy_exit(void)
266	{
267	delete_client();
268	}
269
270	module_init(alsa_seq_dummy_init)
271	module_exit(alsa_seq_dummy_exit)