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 <linux/init.h>
39 #include <linux/wait.h>
40 #include <linux/module.h>
41 #include <linux/slab.h>
42 #include <sound/core.h>
43 #include <sound/rawmidi.h>
44 #include <sound/info.h>
45 #include <sound/control.h>
46 #include <sound/minors.h>
47 #include <sound/seq_kernel.h>
48 #include <sound/seq_midi_event.h>
49 #include <sound/seq_virmidi.h>
51 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
52 MODULE_DESCRIPTION("Virtual Raw MIDI client on Sequencer");
53 MODULE_LICENSE("GPL");
56 * initialize an event record
58 static void snd_virmidi_init_event(struct snd_virmidi
*vmidi
,
59 struct snd_seq_event
*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(struct snd_virmidi_dev
*rdev
,
80 struct snd_seq_event
*ev
,
83 struct snd_virmidi
*vmidi
;
88 read_lock(&rdev
->filelist_lock
);
90 down_read(&rdev
->filelist_sem
);
91 list_for_each_entry(vmidi
, &rdev
->filelist
, list
) {
94 if (ev
->type
== SNDRV_SEQ_EVENT_SYSEX
) {
95 if ((ev
->flags
& SNDRV_SEQ_EVENT_LENGTH_MASK
) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE
)
97 snd_seq_dump_var_event(ev
, (snd_seq_dump_func_t
)snd_rawmidi_receive
, vmidi
->substream
);
99 len
= snd_midi_event_decode(vmidi
->parser
, msg
, sizeof(msg
), ev
);
101 snd_rawmidi_receive(vmidi
->substream
, msg
, len
);
105 read_unlock(&rdev
->filelist_lock
);
107 up_read(&rdev
->filelist_sem
);
113 * receive an event from the remote virmidi port
115 * for rawmidi inputs, you can call this function from the event
116 * handler of a remote port which is attached to the virmidi via
117 * SNDRV_VIRMIDI_SEQ_ATTACH.
120 int snd_virmidi_receive(struct snd_rawmidi
*rmidi
, struct snd_seq_event
*ev
)
122 struct snd_virmidi_dev
*rdev
;
124 rdev
= rmidi
->private_data
;
125 return snd_virmidi_dev_receive_event(rdev
, ev
, true);
130 * event handler of virmidi port
132 static int snd_virmidi_event_input(struct snd_seq_event
*ev
, int direct
,
133 void *private_data
, int atomic
, int hop
)
135 struct snd_virmidi_dev
*rdev
;
138 if (!(rdev
->flags
& SNDRV_VIRMIDI_USE
))
139 return 0; /* ignored */
140 return snd_virmidi_dev_receive_event(rdev
, ev
, atomic
);
144 * trigger rawmidi stream for input
146 static void snd_virmidi_input_trigger(struct snd_rawmidi_substream
*substream
, int up
)
148 struct snd_virmidi
*vmidi
= substream
->runtime
->private_data
;
158 * trigger rawmidi stream for output
160 static void snd_virmidi_output_trigger(struct snd_rawmidi_substream
*substream
, int up
)
162 struct snd_virmidi
*vmidi
= substream
->runtime
->private_data
;
164 unsigned char buf
[32], *pbuf
;
169 if (vmidi
->seq_mode
== SNDRV_VIRMIDI_SEQ_DISPATCH
&&
170 !(vmidi
->rdev
->flags
& SNDRV_VIRMIDI_SUBSCRIBE
)) {
171 while (snd_rawmidi_transmit(substream
, buf
,
177 spin_lock_irqsave(&substream
->runtime
->lock
, flags
);
178 if (vmidi
->event
.type
!= SNDRV_SEQ_EVENT_NONE
) {
179 if (snd_seq_kernel_client_dispatch(vmidi
->client
, &vmidi
->event
, in_atomic(), 0) < 0)
181 vmidi
->event
.type
= SNDRV_SEQ_EVENT_NONE
;
184 count
= __snd_rawmidi_transmit_peek(substream
, buf
, sizeof(buf
));
189 res
= snd_midi_event_encode(vmidi
->parser
, pbuf
, count
, &vmidi
->event
);
191 snd_midi_event_reset_encode(vmidi
->parser
);
194 __snd_rawmidi_transmit_ack(substream
, res
);
197 if (vmidi
->event
.type
!= SNDRV_SEQ_EVENT_NONE
) {
198 if (snd_seq_kernel_client_dispatch(vmidi
->client
, &vmidi
->event
, in_atomic(), 0) < 0)
200 vmidi
->event
.type
= SNDRV_SEQ_EVENT_NONE
;
205 spin_unlock_irqrestore(&substream
->runtime
->lock
, flags
);
212 * open rawmidi handle for input
214 static int snd_virmidi_input_open(struct snd_rawmidi_substream
*substream
)
216 struct snd_virmidi_dev
*rdev
= substream
->rmidi
->private_data
;
217 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
218 struct snd_virmidi
*vmidi
;
220 vmidi
= kzalloc(sizeof(*vmidi
), GFP_KERNEL
);
223 vmidi
->substream
= substream
;
224 if (snd_midi_event_new(0, &vmidi
->parser
) < 0) {
228 vmidi
->seq_mode
= rdev
->seq_mode
;
229 vmidi
->client
= rdev
->client
;
230 vmidi
->port
= rdev
->port
;
231 runtime
->private_data
= vmidi
;
232 down_write(&rdev
->filelist_sem
);
233 write_lock_irq(&rdev
->filelist_lock
);
234 list_add_tail(&vmidi
->list
, &rdev
->filelist
);
235 write_unlock_irq(&rdev
->filelist_lock
);
236 up_write(&rdev
->filelist_sem
);
242 * open rawmidi handle for output
244 static int snd_virmidi_output_open(struct snd_rawmidi_substream
*substream
)
246 struct snd_virmidi_dev
*rdev
= substream
->rmidi
->private_data
;
247 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
248 struct snd_virmidi
*vmidi
;
250 vmidi
= kzalloc(sizeof(*vmidi
), GFP_KERNEL
);
253 vmidi
->substream
= substream
;
254 if (snd_midi_event_new(MAX_MIDI_EVENT_BUF
, &vmidi
->parser
) < 0) {
258 vmidi
->seq_mode
= rdev
->seq_mode
;
259 vmidi
->client
= rdev
->client
;
260 vmidi
->port
= rdev
->port
;
261 snd_virmidi_init_event(vmidi
, &vmidi
->event
);
263 runtime
->private_data
= vmidi
;
268 * close rawmidi handle for input
270 static int snd_virmidi_input_close(struct snd_rawmidi_substream
*substream
)
272 struct snd_virmidi_dev
*rdev
= substream
->rmidi
->private_data
;
273 struct snd_virmidi
*vmidi
= substream
->runtime
->private_data
;
275 down_write(&rdev
->filelist_sem
);
276 write_lock_irq(&rdev
->filelist_lock
);
277 list_del(&vmidi
->list
);
278 write_unlock_irq(&rdev
->filelist_lock
);
279 up_write(&rdev
->filelist_sem
);
280 snd_midi_event_free(vmidi
->parser
);
281 substream
->runtime
->private_data
= NULL
;
287 * close rawmidi handle for output
289 static int snd_virmidi_output_close(struct snd_rawmidi_substream
*substream
)
291 struct snd_virmidi
*vmidi
= substream
->runtime
->private_data
;
292 snd_midi_event_free(vmidi
->parser
);
293 substream
->runtime
->private_data
= NULL
;
299 * subscribe callback - allow output to rawmidi device
301 static int snd_virmidi_subscribe(void *private_data
,
302 struct snd_seq_port_subscribe
*info
)
304 struct snd_virmidi_dev
*rdev
;
307 if (!try_module_get(rdev
->card
->module
))
309 rdev
->flags
|= SNDRV_VIRMIDI_SUBSCRIBE
;
314 * unsubscribe callback - disallow output to rawmidi device
316 static int snd_virmidi_unsubscribe(void *private_data
,
317 struct snd_seq_port_subscribe
*info
)
319 struct snd_virmidi_dev
*rdev
;
322 rdev
->flags
&= ~SNDRV_VIRMIDI_SUBSCRIBE
;
323 module_put(rdev
->card
->module
);
329 * use callback - allow input to rawmidi device
331 static int snd_virmidi_use(void *private_data
,
332 struct snd_seq_port_subscribe
*info
)
334 struct snd_virmidi_dev
*rdev
;
337 if (!try_module_get(rdev
->card
->module
))
339 rdev
->flags
|= SNDRV_VIRMIDI_USE
;
344 * unuse callback - disallow input to rawmidi device
346 static int snd_virmidi_unuse(void *private_data
,
347 struct snd_seq_port_subscribe
*info
)
349 struct snd_virmidi_dev
*rdev
;
352 rdev
->flags
&= ~SNDRV_VIRMIDI_USE
;
353 module_put(rdev
->card
->module
);
362 static const struct snd_rawmidi_ops snd_virmidi_input_ops
= {
363 .open
= snd_virmidi_input_open
,
364 .close
= snd_virmidi_input_close
,
365 .trigger
= snd_virmidi_input_trigger
,
368 static const struct snd_rawmidi_ops snd_virmidi_output_ops
= {
369 .open
= snd_virmidi_output_open
,
370 .close
= snd_virmidi_output_close
,
371 .trigger
= snd_virmidi_output_trigger
,
375 * create a sequencer client and a port
377 static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev
*rdev
)
380 struct snd_seq_port_callback pcallbacks
;
381 struct snd_seq_port_info
*pinfo
;
384 if (rdev
->client
>= 0)
387 pinfo
= kzalloc(sizeof(*pinfo
), GFP_KERNEL
);
393 client
= snd_seq_create_kernel_client(rdev
->card
, rdev
->device
,
394 "%s %d-%d", rdev
->rmidi
->name
,
401 rdev
->client
= client
;
404 pinfo
->addr
.client
= client
;
405 sprintf(pinfo
->name
, "VirMIDI %d-%d", rdev
->card
->number
, rdev
->device
);
406 /* set all capabilities */
407 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_WRITE
| SNDRV_SEQ_PORT_CAP_SYNC_WRITE
| SNDRV_SEQ_PORT_CAP_SUBS_WRITE
;
408 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_READ
| SNDRV_SEQ_PORT_CAP_SYNC_READ
| SNDRV_SEQ_PORT_CAP_SUBS_READ
;
409 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_DUPLEX
;
410 pinfo
->type
= SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
411 | SNDRV_SEQ_PORT_TYPE_SOFTWARE
412 | SNDRV_SEQ_PORT_TYPE_PORT
;
413 pinfo
->midi_channels
= 16;
414 memset(&pcallbacks
, 0, sizeof(pcallbacks
));
415 pcallbacks
.owner
= THIS_MODULE
;
416 pcallbacks
.private_data
= rdev
;
417 pcallbacks
.subscribe
= snd_virmidi_subscribe
;
418 pcallbacks
.unsubscribe
= snd_virmidi_unsubscribe
;
419 pcallbacks
.use
= snd_virmidi_use
;
420 pcallbacks
.unuse
= snd_virmidi_unuse
;
421 pcallbacks
.event_input
= snd_virmidi_event_input
;
422 pinfo
->kernel
= &pcallbacks
;
423 err
= snd_seq_kernel_client_ctl(client
, SNDRV_SEQ_IOCTL_CREATE_PORT
, pinfo
);
425 snd_seq_delete_kernel_client(client
);
430 rdev
->port
= pinfo
->addr
.port
;
431 err
= 0; /* success */
440 * release the sequencer client
442 static void snd_virmidi_dev_detach_seq(struct snd_virmidi_dev
*rdev
)
444 if (rdev
->client
>= 0) {
445 snd_seq_delete_kernel_client(rdev
->client
);
451 * register the device
453 static int snd_virmidi_dev_register(struct snd_rawmidi
*rmidi
)
455 struct snd_virmidi_dev
*rdev
= rmidi
->private_data
;
458 switch (rdev
->seq_mode
) {
459 case SNDRV_VIRMIDI_SEQ_DISPATCH
:
460 err
= snd_virmidi_dev_attach_seq(rdev
);
464 case SNDRV_VIRMIDI_SEQ_ATTACH
:
465 if (rdev
->client
== 0)
467 /* should check presence of port more strictly.. */
470 pr_err("ALSA: seq_virmidi: seq_mode is not set: %d\n", rdev
->seq_mode
);
478 * unregister the device
480 static int snd_virmidi_dev_unregister(struct snd_rawmidi
*rmidi
)
482 struct snd_virmidi_dev
*rdev
= rmidi
->private_data
;
484 if (rdev
->seq_mode
== SNDRV_VIRMIDI_SEQ_DISPATCH
)
485 snd_virmidi_dev_detach_seq(rdev
);
492 static const struct snd_rawmidi_global_ops snd_virmidi_global_ops
= {
493 .dev_register
= snd_virmidi_dev_register
,
494 .dev_unregister
= snd_virmidi_dev_unregister
,
500 static void snd_virmidi_free(struct snd_rawmidi
*rmidi
)
502 struct snd_virmidi_dev
*rdev
= rmidi
->private_data
;
507 * create a new device
511 int snd_virmidi_new(struct snd_card
*card
, int device
, struct snd_rawmidi
**rrmidi
)
513 struct snd_rawmidi
*rmidi
;
514 struct snd_virmidi_dev
*rdev
;
518 if ((err
= snd_rawmidi_new(card
, "VirMidi", device
,
519 16, /* may be configurable */
520 16, /* may be configurable */
523 strcpy(rmidi
->name
, rmidi
->id
);
524 rdev
= kzalloc(sizeof(*rdev
), GFP_KERNEL
);
526 snd_device_free(card
, rmidi
);
531 rdev
->device
= device
;
533 init_rwsem(&rdev
->filelist_sem
);
534 rwlock_init(&rdev
->filelist_lock
);
535 INIT_LIST_HEAD(&rdev
->filelist
);
536 rdev
->seq_mode
= SNDRV_VIRMIDI_SEQ_DISPATCH
;
537 rmidi
->private_data
= rdev
;
538 rmidi
->private_free
= snd_virmidi_free
;
539 rmidi
->ops
= &snd_virmidi_global_ops
;
540 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
, &snd_virmidi_input_ops
);
541 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
, &snd_virmidi_output_ops
);
542 rmidi
->info_flags
= SNDRV_RAWMIDI_INFO_INPUT
|
543 SNDRV_RAWMIDI_INFO_OUTPUT
|
544 SNDRV_RAWMIDI_INFO_DUPLEX
;
548 EXPORT_SYMBOL(snd_virmidi_new
);
554 static int __init
alsa_virmidi_init(void)
559 static void __exit
alsa_virmidi_exit(void)
563 module_init(alsa_virmidi_init
)
564 module_exit(alsa_virmidi_exit
)