[ALSA] seq: set client name in snd_seq_create_kernel_client()
[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_dummy_port *rec1, *rec2;
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 */
205         my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY,
206                                                  "Midi Through");
207         if (my_client < 0)
208                 return my_client;
209
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)