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 <linux/init.h> 22 #include <linux/slab.h> 23 #include <linux/module.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 a configuration file under /etc/modprobe.d/: 50 51 option snd-seq-dummy ports=4 52 53 The model option "duplex=1" enables duplex operation to the port. 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; 68 static bool duplex; 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 75 struct snd_seq_dummy_port { 76 int client; 77 int port; 78 int duplex; 79 int connect; 80 }; 81 82 static int my_client = -1; 83 84 /* 85 * event input callback - just redirect events to subscribers 86 */ 87 static int 88 dummy_input(struct snd_seq_event *ev, int direct, void *private_data, 89 int atomic, int hop) 90 { 91 struct snd_seq_dummy_port *p; 92 struct snd_seq_event tmpev; 93 94 p = private_data; 95 if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM || 96 ev->type == SNDRV_SEQ_EVENT_KERNEL_ERROR) 97 return 0; /* ignore system messages */ 98 tmpev = *ev; 99 if (p->duplex) 100 tmpev.source.port = p->connect; 101 else 102 tmpev.source.port = p->port; 103 tmpev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS; 104 return snd_seq_kernel_client_dispatch(p->client, &tmpev, atomic, hop); 105 } 106 107 /* 108 * free_private callback 109 */ 110 static void 111 dummy_free(void *private_data) 112 { 113 kfree(private_data); 114 } 115 116 /* 117 * create a port 118 */ 119 static struct snd_seq_dummy_port __init * 120 create_port(int idx, int type) 121 { 122 struct snd_seq_port_info pinfo; 123 struct snd_seq_port_callback pcb; 124 struct snd_seq_dummy_port *rec; 125 126 if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) 127 return NULL; 128 129 rec->client = my_client; 130 rec->duplex = duplex; 131 rec->connect = 0; 132 memset(&pinfo, 0, sizeof(pinfo)); 133 pinfo.addr.client = my_client; 134 if (duplex) 135 sprintf(pinfo.name, "Midi Through Port-%d:%c", idx, 136 (type ? 'B' : 'A')); 137 else 138 sprintf(pinfo.name, "Midi Through Port-%d", idx); 139 pinfo.capability = SNDRV_SEQ_PORT_CAP_READ | SNDRV_SEQ_PORT_CAP_SUBS_READ; 140 pinfo.capability |= SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE; 141 if (duplex) 142 pinfo.capability |= SNDRV_SEQ_PORT_CAP_DUPLEX; 143 pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC 144 | SNDRV_SEQ_PORT_TYPE_SOFTWARE 145 | SNDRV_SEQ_PORT_TYPE_PORT; 146 memset(&pcb, 0, sizeof(pcb)); 147 pcb.owner = THIS_MODULE; 148 pcb.event_input = dummy_input; 149 pcb.private_free = dummy_free; 150 pcb.private_data = rec; 151 pinfo.kernel = &pcb; 152 if (snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_CREATE_PORT, &pinfo) < 0) { 153 kfree(rec); 154 return NULL; 155 } 156 rec->port = pinfo.addr.port; 157 return rec; 158 } 159 160 /* 161 * register client and create ports 162 */ 163 static int __init 164 register_client(void) 165 { 166 struct snd_seq_dummy_port *rec1, *rec2; 167 int i; 168 169 if (ports < 1) { 170 pr_err("ALSA: seq_dummy: invalid number of ports %d\n", ports); 171 return -EINVAL; 172 } 173 174 /* create client */ 175 my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY, 176 "Midi Through"); 177 if (my_client < 0) 178 return my_client; 179 180 /* create ports */ 181 for (i = 0; i < ports; i++) { 182 rec1 = create_port(i, 0); 183 if (rec1 == NULL) { 184 snd_seq_delete_kernel_client(my_client); 185 return -ENOMEM; 186 } 187 if (duplex) { 188 rec2 = create_port(i, 1); 189 if (rec2 == NULL) { 190 snd_seq_delete_kernel_client(my_client); 191 return -ENOMEM; 192 } 193 rec1->connect = rec2->port; 194 rec2->connect = rec1->port; 195 } 196 } 197 198 return 0; 199 } 200 201 /* 202 * delete client if exists 203 */ 204 static void __exit 205 delete_client(void) 206 { 207 if (my_client >= 0) 208 snd_seq_delete_kernel_client(my_client); 209 } 210 211 /* 212 * Init part 213 */ 214 215 static int __init alsa_seq_dummy_init(void) 216 { 217 return register_client(); 218 } 219 220 static void __exit alsa_seq_dummy_exit(void) 221 { 222 delete_client(); 223 } 224 225 module_init(alsa_seq_dummy_init) 226 module_exit(alsa_seq_dummy_exit) 227