[mirror_ubuntu-hirsute-kernel.git] / sound / core / seq / seq_dummy.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * ALSA sequencer MIDI-through client
 * Copyright (c) 1999-2000 by Takashi Iwai <tiwai@suse.de>
 */

#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) {
		pr_err("ALSA: seq_dummy: 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)
{
	return register_client();
}

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