2 * Virtual Raw MIDI client on Sequencer
4 * Copyright (c) 2000 by Takashi Iwai <tiwai@suse.de>,
5 * Jaroslav Kysela <perex@perex.cz>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * Virtual Raw MIDI client
26 * The virtual rawmidi client is a sequencer client which associate
27 * a rawmidi device file. The created rawmidi device file can be
28 * accessed as a normal raw midi, but its MIDI source and destination
29 * are arbitrary. For example, a user-client software synth connected
30 * to this port can be used as a normal midi device as well.
32 * The virtual rawmidi device accepts also multiple opens. Each file
33 * has its own input buffer, so that no conflict would occur. The drain
34 * of input/output buffer acts only to the local buffer.
38 #include <sound/driver.h>
39 #include <linux/init.h>
40 #include <linux/wait.h>
41 #include <linux/sched.h>
42 #include <linux/slab.h>
43 #include <sound/core.h>
44 #include <sound/rawmidi.h>
45 #include <sound/info.h>
46 #include <sound/control.h>
47 #include <sound/minors.h>
48 #include <sound/seq_kernel.h>
49 #include <sound/seq_midi_event.h>
50 #include <sound/seq_virmidi.h>
52 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
53 MODULE_DESCRIPTION("Virtual Raw MIDI client on Sequencer");
54 MODULE_LICENSE("GPL");
57 * initialize an event record
59 static void snd_virmidi_init_event(snd_virmidi_t
*vmidi
, snd_seq_event_t
*ev
)
61 memset(ev
, 0, sizeof(*ev
));
62 ev
->source
.port
= vmidi
->port
;
63 switch (vmidi
->seq_mode
) {
64 case SNDRV_VIRMIDI_SEQ_DISPATCH
:
65 ev
->dest
.client
= SNDRV_SEQ_ADDRESS_SUBSCRIBERS
;
67 case SNDRV_VIRMIDI_SEQ_ATTACH
:
68 /* FIXME: source and destination are same - not good.. */
69 ev
->dest
.client
= vmidi
->client
;
70 ev
->dest
.port
= vmidi
->port
;
73 ev
->type
= SNDRV_SEQ_EVENT_NONE
;
77 * decode input event and put to read buffer of each opened file
79 static int snd_virmidi_dev_receive_event(snd_virmidi_dev_t
*rdev
, snd_seq_event_t
*ev
)
82 struct list_head
*list
;
86 read_lock(&rdev
->filelist_lock
);
87 list_for_each(list
, &rdev
->filelist
) {
88 vmidi
= list_entry(list
, snd_virmidi_t
, list
);
91 if (ev
->type
== SNDRV_SEQ_EVENT_SYSEX
) {
92 if ((ev
->flags
& SNDRV_SEQ_EVENT_LENGTH_MASK
) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE
)
94 snd_seq_dump_var_event(ev
, (snd_seq_dump_func_t
)snd_rawmidi_receive
, vmidi
->substream
);
96 len
= snd_midi_event_decode(vmidi
->parser
, msg
, sizeof(msg
), ev
);
98 snd_rawmidi_receive(vmidi
->substream
, msg
, len
);
101 read_unlock(&rdev
->filelist_lock
);
107 * receive an event from the remote virmidi port
109 * for rawmidi inputs, you can call this function from the event
110 * handler of a remote port which is attached to the virmidi via
111 * SNDRV_VIRMIDI_SEQ_ATTACH.
114 int snd_virmidi_receive(snd_rawmidi_t
*rmidi
, snd_seq_event_t
*ev
)
116 snd_virmidi_dev_t
*rdev
;
118 rdev
= rmidi
->private_data
;
119 return snd_virmidi_dev_receive_event(rdev
, ev
);
123 * event handler of virmidi port
125 static int snd_virmidi_event_input(snd_seq_event_t
*ev
, int direct
,
126 void *private_data
, int atomic
, int hop
)
128 snd_virmidi_dev_t
*rdev
;
131 if (!(rdev
->flags
& SNDRV_VIRMIDI_USE
))
132 return 0; /* ignored */
133 return snd_virmidi_dev_receive_event(rdev
, ev
);
137 * trigger rawmidi stream for input
139 static void snd_virmidi_input_trigger(snd_rawmidi_substream_t
* substream
, int up
)
141 snd_virmidi_t
*vmidi
= substream
->runtime
->private_data
;
151 * trigger rawmidi stream for output
153 static void snd_virmidi_output_trigger(snd_rawmidi_substream_t
* substream
, int up
)
155 snd_virmidi_t
*vmidi
= substream
->runtime
->private_data
;
157 unsigned char buf
[32], *pbuf
;
161 if (vmidi
->seq_mode
== SNDRV_VIRMIDI_SEQ_DISPATCH
&&
162 !(vmidi
->rdev
->flags
& SNDRV_VIRMIDI_SUBSCRIBE
)) {
163 snd_rawmidi_transmit_ack(substream
, substream
->runtime
->buffer_size
- substream
->runtime
->avail
);
164 return; /* ignored */
166 if (vmidi
->event
.type
!= SNDRV_SEQ_EVENT_NONE
) {
167 if (snd_seq_kernel_client_dispatch(vmidi
->client
, &vmidi
->event
, 0, 0) < 0)
169 vmidi
->event
.type
= SNDRV_SEQ_EVENT_NONE
;
172 count
= snd_rawmidi_transmit_peek(substream
, buf
, sizeof(buf
));
177 res
= snd_midi_event_encode(vmidi
->parser
, pbuf
, count
, &vmidi
->event
);
179 snd_midi_event_reset_encode(vmidi
->parser
);
182 snd_rawmidi_transmit_ack(substream
, res
);
185 if (vmidi
->event
.type
!= SNDRV_SEQ_EVENT_NONE
) {
186 if (snd_seq_kernel_client_dispatch(vmidi
->client
, &vmidi
->event
, 0, 0) < 0)
188 vmidi
->event
.type
= SNDRV_SEQ_EVENT_NONE
;
198 * open rawmidi handle for input
200 static int snd_virmidi_input_open(snd_rawmidi_substream_t
* substream
)
202 snd_virmidi_dev_t
*rdev
= substream
->rmidi
->private_data
;
203 snd_rawmidi_runtime_t
*runtime
= substream
->runtime
;
204 snd_virmidi_t
*vmidi
;
207 vmidi
= kcalloc(1, sizeof(*vmidi
), GFP_KERNEL
);
210 vmidi
->substream
= substream
;
211 if (snd_midi_event_new(0, &vmidi
->parser
) < 0) {
215 vmidi
->seq_mode
= rdev
->seq_mode
;
216 vmidi
->client
= rdev
->client
;
217 vmidi
->port
= rdev
->port
;
218 runtime
->private_data
= vmidi
;
219 write_lock_irqsave(&rdev
->filelist_lock
, flags
);
220 list_add_tail(&vmidi
->list
, &rdev
->filelist
);
221 write_unlock_irqrestore(&rdev
->filelist_lock
, flags
);
227 * open rawmidi handle for output
229 static int snd_virmidi_output_open(snd_rawmidi_substream_t
* substream
)
231 snd_virmidi_dev_t
*rdev
= substream
->rmidi
->private_data
;
232 snd_rawmidi_runtime_t
*runtime
= substream
->runtime
;
233 snd_virmidi_t
*vmidi
;
235 vmidi
= kcalloc(1, sizeof(*vmidi
), GFP_KERNEL
);
238 vmidi
->substream
= substream
;
239 if (snd_midi_event_new(MAX_MIDI_EVENT_BUF
, &vmidi
->parser
) < 0) {
243 vmidi
->seq_mode
= rdev
->seq_mode
;
244 vmidi
->client
= rdev
->client
;
245 vmidi
->port
= rdev
->port
;
246 snd_virmidi_init_event(vmidi
, &vmidi
->event
);
248 runtime
->private_data
= vmidi
;
253 * close rawmidi handle for input
255 static int snd_virmidi_input_close(snd_rawmidi_substream_t
* substream
)
257 snd_virmidi_t
*vmidi
= substream
->runtime
->private_data
;
258 snd_midi_event_free(vmidi
->parser
);
259 list_del(&vmidi
->list
);
260 substream
->runtime
->private_data
= NULL
;
266 * close rawmidi handle for output
268 static int snd_virmidi_output_close(snd_rawmidi_substream_t
* substream
)
270 snd_virmidi_t
*vmidi
= substream
->runtime
->private_data
;
271 snd_midi_event_free(vmidi
->parser
);
272 substream
->runtime
->private_data
= NULL
;
278 * subscribe callback - allow output to rawmidi device
280 static int snd_virmidi_subscribe(void *private_data
, snd_seq_port_subscribe_t
*info
)
282 snd_virmidi_dev_t
*rdev
;
285 if (!try_module_get(rdev
->card
->module
))
287 rdev
->flags
|= SNDRV_VIRMIDI_SUBSCRIBE
;
292 * unsubscribe callback - disallow output to rawmidi device
294 static int snd_virmidi_unsubscribe(void *private_data
, snd_seq_port_subscribe_t
*info
)
296 snd_virmidi_dev_t
*rdev
;
299 rdev
->flags
&= ~SNDRV_VIRMIDI_SUBSCRIBE
;
300 module_put(rdev
->card
->module
);
306 * use callback - allow input to rawmidi device
308 static int snd_virmidi_use(void *private_data
, snd_seq_port_subscribe_t
*info
)
310 snd_virmidi_dev_t
*rdev
;
313 if (!try_module_get(rdev
->card
->module
))
315 rdev
->flags
|= SNDRV_VIRMIDI_USE
;
320 * unuse callback - disallow input to rawmidi device
322 static int snd_virmidi_unuse(void *private_data
, snd_seq_port_subscribe_t
*info
)
324 snd_virmidi_dev_t
*rdev
;
327 rdev
->flags
&= ~SNDRV_VIRMIDI_USE
;
328 module_put(rdev
->card
->module
);
337 static snd_rawmidi_ops_t snd_virmidi_input_ops
= {
338 .open
= snd_virmidi_input_open
,
339 .close
= snd_virmidi_input_close
,
340 .trigger
= snd_virmidi_input_trigger
,
343 static snd_rawmidi_ops_t snd_virmidi_output_ops
= {
344 .open
= snd_virmidi_output_open
,
345 .close
= snd_virmidi_output_close
,
346 .trigger
= snd_virmidi_output_trigger
,
350 * create a sequencer client and a port
352 static int snd_virmidi_dev_attach_seq(snd_virmidi_dev_t
*rdev
)
355 snd_seq_client_callback_t callbacks
;
356 snd_seq_port_callback_t pcallbacks
;
357 snd_seq_client_info_t
*info
;
358 snd_seq_port_info_t
*pinfo
;
361 if (rdev
->client
>= 0)
364 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
365 pinfo
= kmalloc(sizeof(*pinfo
), GFP_KERNEL
);
366 if (! info
|| ! pinfo
) {
371 memset(&callbacks
, 0, sizeof(callbacks
));
372 callbacks
.private_data
= rdev
;
373 callbacks
.allow_input
= 1;
374 callbacks
.allow_output
= 1;
375 client
= snd_seq_create_kernel_client(rdev
->card
, rdev
->device
, &callbacks
);
380 rdev
->client
= client
;
382 /* set client name */
383 memset(info
, 0, sizeof(*info
));
384 info
->client
= client
;
385 info
->type
= KERNEL_CLIENT
;
386 sprintf(info
->name
, "%s %d-%d", rdev
->rmidi
->name
, rdev
->card
->number
, rdev
->device
);
387 snd_seq_kernel_client_ctl(client
, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO
, &info
);
390 memset(pinfo
, 0, sizeof(*pinfo
));
391 pinfo
->addr
.client
= client
;
392 sprintf(pinfo
->name
, "VirMIDI %d-%d", rdev
->card
->number
, rdev
->device
);
393 /* set all capabilities */
394 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_WRITE
| SNDRV_SEQ_PORT_CAP_SYNC_WRITE
| SNDRV_SEQ_PORT_CAP_SUBS_WRITE
;
395 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_READ
| SNDRV_SEQ_PORT_CAP_SYNC_READ
| SNDRV_SEQ_PORT_CAP_SUBS_READ
;
396 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_DUPLEX
;
397 pinfo
->type
= SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
;
398 pinfo
->midi_channels
= 16;
399 memset(&pcallbacks
, 0, sizeof(pcallbacks
));
400 pcallbacks
.owner
= THIS_MODULE
;
401 pcallbacks
.private_data
= rdev
;
402 pcallbacks
.subscribe
= snd_virmidi_subscribe
;
403 pcallbacks
.unsubscribe
= snd_virmidi_unsubscribe
;
404 pcallbacks
.use
= snd_virmidi_use
;
405 pcallbacks
.unuse
= snd_virmidi_unuse
;
406 pcallbacks
.event_input
= snd_virmidi_event_input
;
407 pinfo
->kernel
= &pcallbacks
;
408 err
= snd_seq_kernel_client_ctl(client
, SNDRV_SEQ_IOCTL_CREATE_PORT
, &pinfo
);
410 snd_seq_delete_kernel_client(client
);
415 rdev
->port
= pinfo
->addr
.port
;
416 err
= 0; /* success */
426 * release the sequencer client
428 static void snd_virmidi_dev_detach_seq(snd_virmidi_dev_t
*rdev
)
430 if (rdev
->client
>= 0) {
431 snd_seq_delete_kernel_client(rdev
->client
);
437 * register the device
439 static int snd_virmidi_dev_register(snd_rawmidi_t
*rmidi
)
441 snd_virmidi_dev_t
*rdev
= rmidi
->private_data
;
444 switch (rdev
->seq_mode
) {
445 case SNDRV_VIRMIDI_SEQ_DISPATCH
:
446 err
= snd_virmidi_dev_attach_seq(rdev
);
450 case SNDRV_VIRMIDI_SEQ_ATTACH
:
451 if (rdev
->client
== 0)
453 /* should check presence of port more strictly.. */
456 snd_printk(KERN_ERR
"seq_mode is not set: %d\n", rdev
->seq_mode
);
464 * unregister the device
466 static int snd_virmidi_dev_unregister(snd_rawmidi_t
*rmidi
)
468 snd_virmidi_dev_t
*rdev
= rmidi
->private_data
;
470 if (rdev
->seq_mode
== SNDRV_VIRMIDI_SEQ_DISPATCH
)
471 snd_virmidi_dev_detach_seq(rdev
);
478 static snd_rawmidi_global_ops_t snd_virmidi_global_ops
= {
479 .dev_register
= snd_virmidi_dev_register
,
480 .dev_unregister
= snd_virmidi_dev_unregister
,
486 static void snd_virmidi_free(snd_rawmidi_t
*rmidi
)
488 snd_virmidi_dev_t
*rdev
= rmidi
->private_data
;
493 * create a new device
497 int snd_virmidi_new(snd_card_t
*card
, int device
, snd_rawmidi_t
**rrmidi
)
499 snd_rawmidi_t
*rmidi
;
500 snd_virmidi_dev_t
*rdev
;
504 if ((err
= snd_rawmidi_new(card
, "VirMidi", device
,
505 16, /* may be configurable */
506 16, /* may be configurable */
509 strcpy(rmidi
->name
, rmidi
->id
);
510 rdev
= kcalloc(1, sizeof(*rdev
), GFP_KERNEL
);
512 snd_device_free(card
, rmidi
);
517 rdev
->device
= device
;
519 rwlock_init(&rdev
->filelist_lock
);
520 INIT_LIST_HEAD(&rdev
->filelist
);
521 rdev
->seq_mode
= SNDRV_VIRMIDI_SEQ_DISPATCH
;
522 rmidi
->private_data
= rdev
;
523 rmidi
->private_free
= snd_virmidi_free
;
524 rmidi
->ops
= &snd_virmidi_global_ops
;
525 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
, &snd_virmidi_input_ops
);
526 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
, &snd_virmidi_output_ops
);
527 rmidi
->info_flags
= SNDRV_RAWMIDI_INFO_INPUT
|
528 SNDRV_RAWMIDI_INFO_OUTPUT
|
529 SNDRV_RAWMIDI_INFO_DUPLEX
;
538 static int __init
alsa_virmidi_init(void)
543 static void __exit
alsa_virmidi_exit(void)
547 module_init(alsa_virmidi_init
)
548 module_exit(alsa_virmidi_exit
)
550 EXPORT_SYMBOL(snd_virmidi_new
);
551 EXPORT_SYMBOL(snd_virmidi_receive
);