[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/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 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 int 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;

/*
 * 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
1da177e4 LT	21	#include <linux/init.h>
	22	#include <linux/slab.h>
	23	#include <linux/moduleparam.h>
	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
	49	following option in /etc/modprobe.conf:
	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;
6581f4e7	68	static int 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
	84	/*
	85	* unuse callback - send ALL_SOUNDS_OFF and RESET_CONTROLLERS events
	86	* to subscribers.
	87	* Note: this callback is called only after all subscribers are removed.
	88	*/
	89	static int
c7e0b5bf	90	dummy_unuse(void private_data, struct snd_seq_port_subscribe info)
1da177e4	91	{
c7e0b5bf	92	struct snd_seq_dummy_port *p;
1da177e4	93	int i;
c7e0b5bf	94	struct snd_seq_event ev;
1da177e4 LT	95
	96	p = private_data;
	97	memset(&ev, 0, sizeof(ev));
	98	if (p->duplex)
	99	ev.source.port = p->connect;
	100	else
	101	ev.source.port = p->port;
	102	ev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
	103	ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
	104	for (i = 0; i < 16; i++) {
	105	ev.data.control.channel = i;
	106	ev.data.control.param = MIDI_CTL_ALL_SOUNDS_OFF;
	107	snd_seq_kernel_client_dispatch(p->client, &ev, 0, 0);
	108	ev.data.control.param = MIDI_CTL_RESET_CONTROLLERS;
	109	snd_seq_kernel_client_dispatch(p->client, &ev, 0, 0);
	110	}
	111	return 0;
	112	}
	113
	114	/*
	115	* event input callback - just redirect events to subscribers
	116	*/
	117	static int
c7e0b5bf TI	118	dummy_input(struct snd_seq_event ev, int direct, void private_data,
c7e0b5bf TI	119	int atomic, int hop)
1da177e4	120	{
c7e0b5bf TI	121	struct snd_seq_dummy_port *p;
c7e0b5bf TI	122	struct snd_seq_event tmpev;
1da177e4 LT	123
	124	p = private_data;
	125	if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM \|\|
	126	ev->type == SNDRV_SEQ_EVENT_KERNEL_ERROR)
	127	return 0; /* ignore system messages */
	128	tmpev = *ev;
	129	if (p->duplex)
	130	tmpev.source.port = p->connect;
	131	else
	132	tmpev.source.port = p->port;
	133	tmpev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
	134	return snd_seq_kernel_client_dispatch(p->client, &tmpev, atomic, hop);
	135	}
	136
	137	/*
	138	* free_private callback
	139	*/
	140	static void
	141	dummy_free(void *private_data)
	142	{
4d572776	143	kfree(private_data);
1da177e4 LT	144	}
	145
	146	/*
	147	* create a port
	148	*/
c7e0b5bf	149	static struct snd_seq_dummy_port __init *
1da177e4 LT	150	create_port(int idx, int type)
1da177e4 LT	151	{
c7e0b5bf TI	152	struct snd_seq_port_info pinfo;
	153	struct snd_seq_port_callback pcb;
	154	struct snd_seq_dummy_port *rec;
1da177e4	155
ecca82b4	156	if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
1da177e4 LT	157	return NULL;
	158
	159	rec->client = my_client;
	160	rec->duplex = duplex;
	161	rec->connect = 0;
	162	memset(&pinfo, 0, sizeof(pinfo));
	163	pinfo.addr.client = my_client;
	164	if (duplex)
	165	sprintf(pinfo.name, "Midi Through Port-%d:%c", idx,
	166	(type ? 'B' : 'A'));
	167	else
	168	sprintf(pinfo.name, "Midi Through Port-%d", idx);
	169	pinfo.capability = SNDRV_SEQ_PORT_CAP_READ \| SNDRV_SEQ_PORT_CAP_SUBS_READ;
	170	pinfo.capability \|= SNDRV_SEQ_PORT_CAP_WRITE \| SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
	171	if (duplex)
	172	pinfo.capability \|= SNDRV_SEQ_PORT_CAP_DUPLEX;
450047a7 CL	173	pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
	174	\| SNDRV_SEQ_PORT_TYPE_SOFTWARE
	175	\| SNDRV_SEQ_PORT_TYPE_PORT;
1da177e4 LT	176	memset(&pcb, 0, sizeof(pcb));
	177	pcb.owner = THIS_MODULE;
	178	pcb.unuse = dummy_unuse;
	179	pcb.event_input = dummy_input;
	180	pcb.private_free = dummy_free;
	181	pcb.private_data = rec;
	182	pinfo.kernel = &pcb;
	183	if (snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_CREATE_PORT, &pinfo) < 0) {
	184	kfree(rec);
	185	return NULL;
	186	}
	187	rec->port = pinfo.addr.port;
	188	return rec;
	189	}
	190
	191	/*
	192	* register client and create ports
	193	*/
	194	static int __init
	195	register_client(void)
	196	{
c7e0b5bf	197	struct snd_seq_dummy_port rec1, rec2;
1da177e4 LT	198	int i;
	199
	200	if (ports < 1) {
	201	snd_printk(KERN_ERR "invalid number of ports %d\n", ports);
	202	return -EINVAL;
	203	}
	204
	205	/* create client */
7b6d9245 CL	206	my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY,
7b6d9245 CL	207	"Midi Through");
1da177e4 LT	208	if (my_client < 0)
	209	return my_client;
	210
1da177e4 LT	211	/* create ports */
	212	for (i = 0; i < ports; i++) {
	213	rec1 = create_port(i, 0);
	214	if (rec1 == NULL) {
	215	snd_seq_delete_kernel_client(my_client);
	216	return -ENOMEM;
	217	}
	218	if (duplex) {
	219	rec2 = create_port(i, 1);
	220	if (rec2 == NULL) {
	221	snd_seq_delete_kernel_client(my_client);
	222	return -ENOMEM;
	223	}
	224	rec1->connect = rec2->port;
	225	rec2->connect = rec1->port;
	226	}
	227	}
	228
	229	return 0;
	230	}
	231
	232	/*
	233	* delete client if exists
	234	*/
	235	static void __exit
	236	delete_client(void)
	237	{
	238	if (my_client >= 0)
	239	snd_seq_delete_kernel_client(my_client);
	240	}
	241
	242	/*
	243	* Init part
	244	*/
	245
	246	static int __init alsa_seq_dummy_init(void)
	247	{
	248	int err;
	249	snd_seq_autoload_lock();
	250	err = register_client();
	251	snd_seq_autoload_unlock();
	252	return err;
	253	}
	254
	255	static void __exit alsa_seq_dummy_exit(void)
	256	{
	257	delete_client();
	258	}
	259
	260	module_init(alsa_seq_dummy_init)
	261	module_exit(alsa_seq_dummy_exit)