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/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
)
82 struct snd_virmidi
*vmidi
;
86 read_lock(&rdev
->filelist_lock
);
87 list_for_each_entry(vmidi
, &rdev
->filelist
, list
) {
90 if (ev
->type
== SNDRV_SEQ_EVENT_SYSEX
) {
91 if ((ev
->flags
& SNDRV_SEQ_EVENT_LENGTH_MASK
) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE
)
93 snd_seq_dump_var_event(ev
, (snd_seq_dump_func_t
)snd_rawmidi_receive
, vmidi
->substream
);
95 len
= snd_midi_event_decode(vmidi
->parser
, msg
, sizeof(msg
), ev
);
97 snd_rawmidi_receive(vmidi
->substream
, msg
, len
);
100 read_unlock(&rdev
->filelist_lock
);
106 * receive an event from the remote virmidi port
108 * for rawmidi inputs, you can call this function from the event
109 * handler of a remote port which is attached to the virmidi via
110 * SNDRV_VIRMIDI_SEQ_ATTACH.
113 int snd_virmidi_receive(struct snd_rawmidi
*rmidi
, struct snd_seq_event
*ev
)
115 struct snd_virmidi_dev
*rdev
;
117 rdev
= rmidi
->private_data
;
118 return snd_virmidi_dev_receive_event(rdev
, ev
);
123 * event handler of virmidi port
125 static int snd_virmidi_event_input(struct snd_seq_event
*ev
, int direct
,
126 void *private_data
, int atomic
, int hop
)
128 struct snd_virmidi_dev
*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(struct snd_rawmidi_substream
*substream
, int up
)
141 struct snd_virmidi
*vmidi
= substream
->runtime
->private_data
;
151 * trigger rawmidi stream for output
153 static void snd_virmidi_output_trigger(struct snd_rawmidi_substream
*substream
, int up
)
155 struct snd_virmidi
*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
, in_atomic(), 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
, in_atomic(), 0) < 0)
188 vmidi
->event
.type
= SNDRV_SEQ_EVENT_NONE
;
198 * open rawmidi handle for input
200 static int snd_virmidi_input_open(struct snd_rawmidi_substream
*substream
)
202 struct snd_virmidi_dev
*rdev
= substream
->rmidi
->private_data
;
203 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
204 struct snd_virmidi
*vmidi
;
207 vmidi
= kzalloc(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(struct snd_rawmidi_substream
*substream
)
231 struct snd_virmidi_dev
*rdev
= substream
->rmidi
->private_data
;
232 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
233 struct snd_virmidi
*vmidi
;
235 vmidi
= kzalloc(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(struct snd_rawmidi_substream
*substream
)
257 struct snd_virmidi
*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(struct snd_rawmidi_substream
*substream
)
270 struct snd_virmidi
*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
,
281 struct snd_seq_port_subscribe
*info
)
283 struct snd_virmidi_dev
*rdev
;
286 if (!try_module_get(rdev
->card
->module
))
288 rdev
->flags
|= SNDRV_VIRMIDI_SUBSCRIBE
;
293 * unsubscribe callback - disallow output to rawmidi device
295 static int snd_virmidi_unsubscribe(void *private_data
,
296 struct snd_seq_port_subscribe
*info
)
298 struct snd_virmidi_dev
*rdev
;
301 rdev
->flags
&= ~SNDRV_VIRMIDI_SUBSCRIBE
;
302 module_put(rdev
->card
->module
);
308 * use callback - allow input to rawmidi device
310 static int snd_virmidi_use(void *private_data
,
311 struct snd_seq_port_subscribe
*info
)
313 struct snd_virmidi_dev
*rdev
;
316 if (!try_module_get(rdev
->card
->module
))
318 rdev
->flags
|= SNDRV_VIRMIDI_USE
;
323 * unuse callback - disallow input to rawmidi device
325 static int snd_virmidi_unuse(void *private_data
,
326 struct snd_seq_port_subscribe
*info
)
328 struct snd_virmidi_dev
*rdev
;
331 rdev
->flags
&= ~SNDRV_VIRMIDI_USE
;
332 module_put(rdev
->card
->module
);
341 static struct snd_rawmidi_ops snd_virmidi_input_ops
= {
342 .open
= snd_virmidi_input_open
,
343 .close
= snd_virmidi_input_close
,
344 .trigger
= snd_virmidi_input_trigger
,
347 static struct snd_rawmidi_ops snd_virmidi_output_ops
= {
348 .open
= snd_virmidi_output_open
,
349 .close
= snd_virmidi_output_close
,
350 .trigger
= snd_virmidi_output_trigger
,
354 * create a sequencer client and a port
356 static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev
*rdev
)
359 struct snd_seq_port_callback pcallbacks
;
360 struct snd_seq_port_info
*pinfo
;
363 if (rdev
->client
>= 0)
366 pinfo
= kzalloc(sizeof(*pinfo
), GFP_KERNEL
);
372 client
= snd_seq_create_kernel_client(rdev
->card
, rdev
->device
,
373 "%s %d-%d", rdev
->rmidi
->name
,
380 rdev
->client
= client
;
383 pinfo
->addr
.client
= client
;
384 sprintf(pinfo
->name
, "VirMIDI %d-%d", rdev
->card
->number
, rdev
->device
);
385 /* set all capabilities */
386 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_WRITE
| SNDRV_SEQ_PORT_CAP_SYNC_WRITE
| SNDRV_SEQ_PORT_CAP_SUBS_WRITE
;
387 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_READ
| SNDRV_SEQ_PORT_CAP_SYNC_READ
| SNDRV_SEQ_PORT_CAP_SUBS_READ
;
388 pinfo
->capability
|= SNDRV_SEQ_PORT_CAP_DUPLEX
;
389 pinfo
->type
= SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
390 | SNDRV_SEQ_PORT_TYPE_SOFTWARE
391 | SNDRV_SEQ_PORT_TYPE_PORT
;
392 pinfo
->midi_channels
= 16;
393 memset(&pcallbacks
, 0, sizeof(pcallbacks
));
394 pcallbacks
.owner
= THIS_MODULE
;
395 pcallbacks
.private_data
= rdev
;
396 pcallbacks
.subscribe
= snd_virmidi_subscribe
;
397 pcallbacks
.unsubscribe
= snd_virmidi_unsubscribe
;
398 pcallbacks
.use
= snd_virmidi_use
;
399 pcallbacks
.unuse
= snd_virmidi_unuse
;
400 pcallbacks
.event_input
= snd_virmidi_event_input
;
401 pinfo
->kernel
= &pcallbacks
;
402 err
= snd_seq_kernel_client_ctl(client
, SNDRV_SEQ_IOCTL_CREATE_PORT
, pinfo
);
404 snd_seq_delete_kernel_client(client
);
409 rdev
->port
= pinfo
->addr
.port
;
410 err
= 0; /* success */
419 * release the sequencer client
421 static void snd_virmidi_dev_detach_seq(struct snd_virmidi_dev
*rdev
)
423 if (rdev
->client
>= 0) {
424 snd_seq_delete_kernel_client(rdev
->client
);
430 * register the device
432 static int snd_virmidi_dev_register(struct snd_rawmidi
*rmidi
)
434 struct snd_virmidi_dev
*rdev
= rmidi
->private_data
;
437 switch (rdev
->seq_mode
) {
438 case SNDRV_VIRMIDI_SEQ_DISPATCH
:
439 err
= snd_virmidi_dev_attach_seq(rdev
);
443 case SNDRV_VIRMIDI_SEQ_ATTACH
:
444 if (rdev
->client
== 0)
446 /* should check presence of port more strictly.. */
449 snd_printk(KERN_ERR
"seq_mode is not set: %d\n", rdev
->seq_mode
);
457 * unregister the device
459 static int snd_virmidi_dev_unregister(struct snd_rawmidi
*rmidi
)
461 struct snd_virmidi_dev
*rdev
= rmidi
->private_data
;
463 if (rdev
->seq_mode
== SNDRV_VIRMIDI_SEQ_DISPATCH
)
464 snd_virmidi_dev_detach_seq(rdev
);
471 static struct snd_rawmidi_global_ops snd_virmidi_global_ops
= {
472 .dev_register
= snd_virmidi_dev_register
,
473 .dev_unregister
= snd_virmidi_dev_unregister
,
479 static void snd_virmidi_free(struct snd_rawmidi
*rmidi
)
481 struct snd_virmidi_dev
*rdev
= rmidi
->private_data
;
486 * create a new device
490 int snd_virmidi_new(struct snd_card
*card
, int device
, struct snd_rawmidi
**rrmidi
)
492 struct snd_rawmidi
*rmidi
;
493 struct snd_virmidi_dev
*rdev
;
497 if ((err
= snd_rawmidi_new(card
, "VirMidi", device
,
498 16, /* may be configurable */
499 16, /* may be configurable */
502 strcpy(rmidi
->name
, rmidi
->id
);
503 rdev
= kzalloc(sizeof(*rdev
), GFP_KERNEL
);
505 snd_device_free(card
, rmidi
);
510 rdev
->device
= device
;
512 rwlock_init(&rdev
->filelist_lock
);
513 INIT_LIST_HEAD(&rdev
->filelist
);
514 rdev
->seq_mode
= SNDRV_VIRMIDI_SEQ_DISPATCH
;
515 rmidi
->private_data
= rdev
;
516 rmidi
->private_free
= snd_virmidi_free
;
517 rmidi
->ops
= &snd_virmidi_global_ops
;
518 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
, &snd_virmidi_input_ops
);
519 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
, &snd_virmidi_output_ops
);
520 rmidi
->info_flags
= SNDRV_RAWMIDI_INFO_INPUT
|
521 SNDRV_RAWMIDI_INFO_OUTPUT
|
522 SNDRV_RAWMIDI_INFO_DUPLEX
;
531 static int __init
alsa_virmidi_init(void)
536 static void __exit
alsa_virmidi_exit(void)
540 module_init(alsa_virmidi_init
)
541 module_exit(alsa_virmidi_exit
)
543 EXPORT_SYMBOL(snd_virmidi_new
);