[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_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;
	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	196	struct snd_seq_dummy_port rec1, rec2;
1da177e4 LT	197	int i;
	198
	199	if (ports < 1) {
	200	snd_printk(KERN_ERR "invalid number of ports %d\n", ports);
	201	return -EINVAL;
	202	}
	203
	204	/* create client */
7b6d9245 CL	205	my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY,
7b6d9245 CL	206	"Midi Through");
1da177e4 LT	207	if (my_client < 0)
	208	return my_client;
	209
1da177e4 LT	210	/* create ports */
	211	for (i = 0; i < ports; i++) {
	212	rec1 = create_port(i, 0);
	213	if (rec1 == NULL) {
	214	snd_seq_delete_kernel_client(my_client);
	215	return -ENOMEM;
	216	}
	217	if (duplex) {
	218	rec2 = create_port(i, 1);
	219	if (rec2 == NULL) {
	220	snd_seq_delete_kernel_client(my_client);
	221	return -ENOMEM;
	222	}
	223	rec1->connect = rec2->port;
	224	rec2->connect = rec1->port;
	225	}
	226	}
	227
	228	return 0;
	229	}
	230
	231	/*
	232	* delete client if exists
	233	*/
	234	static void __exit
	235	delete_client(void)
	236	{
	237	if (my_client >= 0)
	238	snd_seq_delete_kernel_client(my_client);
	239	}
	240
	241	/*
	242	* Init part
	243	*/
	244
	245	static int __init alsa_seq_dummy_init(void)
	246	{
	247	int err;
	248	snd_seq_autoload_lock();
	249	err = register_client();
	250	snd_seq_autoload_unlock();
	251	return err;
	252	}
	253
	254	static void __exit alsa_seq_dummy_exit(void)
	255	{
	256	delete_client();
	257	}
	258
	259	module_init(alsa_seq_dummy_init)
	260	module_exit(alsa_seq_dummy_exit)