[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
		| SNDRV_SEQ_PORT_TYPE_SOFTWARE
		| SNDRV_SEQ_PORT_TYPE_PORT;
	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_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
	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;
450047a7 CL	174	pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
	175	\| SNDRV_SEQ_PORT_TYPE_SOFTWARE
	176	\| SNDRV_SEQ_PORT_TYPE_PORT;
1da177e4 LT	177	memset(&pcb, 0, sizeof(pcb));
	178	pcb.owner = THIS_MODULE;
	179	pcb.unuse = dummy_unuse;
	180	pcb.event_input = dummy_input;
	181	pcb.private_free = dummy_free;
	182	pcb.private_data = rec;
	183	pinfo.kernel = &pcb;
	184	if (snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_CREATE_PORT, &pinfo) < 0) {
	185	kfree(rec);
	186	return NULL;
	187	}
	188	rec->port = pinfo.addr.port;
	189	return rec;
	190	}
	191
	192	/*
	193	* register client and create ports
	194	*/
	195	static int __init
	196	register_client(void)
	197	{
c7e0b5bf	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 */
7b6d9245 CL	207	my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY,
7b6d9245 CL	208	"Midi Through");
1da177e4 LT	209	if (my_client < 0)
	210	return my_client;
	211
1da177e4 LT	212	/* create ports */
	213	for (i = 0; i < ports; i++) {
	214	rec1 = create_port(i, 0);
	215	if (rec1 == NULL) {
	216	snd_seq_delete_kernel_client(my_client);
	217	return -ENOMEM;
	218	}
	219	if (duplex) {
	220	rec2 = create_port(i, 1);
	221	if (rec2 == NULL) {
	222	snd_seq_delete_kernel_client(my_client);
	223	return -ENOMEM;
	224	}
	225	rec1->connect = rec2->port;
	226	rec2->connect = rec1->port;
	227	}
	228	}
	229
	230	return 0;
	231	}
	232
	233	/*
	234	* delete client if exists
	235	*/
	236	static void __exit
	237	delete_client(void)
	238	{
	239	if (my_client >= 0)
	240	snd_seq_delete_kernel_client(my_client);
	241	}
	242
	243	/*
	244	* Init part
	245	*/
	246
	247	static int __init alsa_seq_dummy_init(void)
	248	{
	249	int err;
	250	snd_seq_autoload_lock();
	251	err = register_client();
	252	snd_seq_autoload_unlock();
	253	return err;
	254	}
	255
	256	static void __exit alsa_seq_dummy_exit(void)
	257	{
	258	delete_client();
	259	}
	260
	261	module_init(alsa_seq_dummy_init)
	262	module_exit(alsa_seq_dummy_exit)