e7344b6332daf5f8e2214b8e9196e07d38590a6e
[linux-2.6.git] / sound / core / seq / seq_dummy.c
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
76 struct snd_seq_dummy_port {
77         int client;
78         int port;
79         int duplex;
80         int connect;
81 };
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
91 dummy_unuse(void *private_data, struct snd_seq_port_subscribe *info)
92 {
93         struct snd_seq_dummy_port *p;
94         int i;
95         struct snd_seq_event ev;
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
119 dummy_input(struct snd_seq_event *ev, int direct, void *private_data,
120             int atomic, int hop)
121 {
122         struct snd_seq_dummy_port *p;
123         struct snd_seq_event tmpev;
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 {
144         kfree(private_data);
145 }
146
147 /*
148  * create a port
149  */
150 static struct snd_seq_dummy_port __init *
151 create_port(int idx, int type)
152 {
153         struct snd_seq_port_info pinfo;
154         struct snd_seq_port_callback pcb;
155         struct snd_seq_dummy_port *rec;
156
157         if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
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 {
196         struct snd_seq_client_info cinfo;
197         struct snd_seq_dummy_port *rec1, *rec2;
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 */
206         my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY);
207         if (my_client < 0)
208                 return my_client;
209
210         /* set client name */
211         memset(&cinfo, 0, sizeof(cinfo));
212         cinfo.client = my_client;
213         cinfo.type = KERNEL_CLIENT;
214         strcpy(cinfo.name, "Midi Through");
215         snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo);
216
217         /* create ports */
218         for (i = 0; i < ports; i++) {
219                 rec1 = create_port(i, 0);
220                 if (rec1 == NULL) {
221                         snd_seq_delete_kernel_client(my_client);
222                         return -ENOMEM;
223                 }
224                 if (duplex) {
225                         rec2 = create_port(i, 1);
226                         if (rec2 == NULL) {
227                                 snd_seq_delete_kernel_client(my_client);
228                                 return -ENOMEM;
229                         }
230                         rec1->connect = rec2->port;
231                         rec2->connect = rec1->port;
232                 }
233         }
234
235         return 0;
236 }
237
238 /*
239  * delete client if exists
240  */
241 static void __exit
242 delete_client(void)
243 {
244         if (my_client >= 0)
245                 snd_seq_delete_kernel_client(my_client);
246 }
247
248 /*
249  *  Init part
250  */
251
252 static int __init alsa_seq_dummy_init(void)
253 {
254         int err;
255         snd_seq_autoload_lock();
256         err = register_client();
257         snd_seq_autoload_unlock();
258         return err;
259 }
260
261 static void __exit alsa_seq_dummy_exit(void)
262 {
263         delete_client();
264 }
265
266 module_init(alsa_seq_dummy_init)
267 module_exit(alsa_seq_dummy_exit)