1 /* 2 * Virtual Raw MIDI client on Sequencer 3 * 4 * Copyright (c) 2000 by Takashi Iwai <tiwai@suse.de>, 5 * Jaroslav Kysela <perex@perex.cz> 6 * 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. 11 * 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. 16 * 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 20 * 21 */ 22 23 /* 24 * Virtual Raw MIDI client 25 * 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. 31 * 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. 35 * 36 */ 37 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> 51 52 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); 53 MODULE_DESCRIPTION("Virtual Raw MIDI client on Sequencer"); 54 MODULE_LICENSE("GPL"); 55 56 /* 57 * initialize an event record 58 */ 59 static void snd_virmidi_init_event(snd_virmidi_t *vmidi, snd_seq_event_t *ev) 60 { 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; 66 break; 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; 71 break; 72 } 73 ev->type = SNDRV_SEQ_EVENT_NONE; 74 } 75 76 /* 77 * decode input event and put to read buffer of each opened file 78 */ 79 static int snd_virmidi_dev_receive_event(snd_virmidi_dev_t *rdev, snd_seq_event_t *ev) 80 { 81 snd_virmidi_t *vmidi; 82 struct list_head *list; 83 unsigned char msg[4]; 84 int len; 85 86 read_lock(&rdev->filelist_lock); 87 list_for_each(list, &rdev->filelist) { 88 vmidi = list_entry(list, snd_virmidi_t, list); 89 if (!vmidi->trigger) 90 continue; 91 if (ev->type == SNDRV_SEQ_EVENT_SYSEX) { 92 if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE) 93 continue; 94 snd_seq_dump_var_event(ev, (snd_seq_dump_func_t)snd_rawmidi_receive, vmidi->substream); 95 } else { 96 len = snd_midi_event_decode(vmidi->parser, msg, sizeof(msg), ev); 97 if (len > 0) 98 snd_rawmidi_receive(vmidi->substream, msg, len); 99 } 100 } 101 read_unlock(&rdev->filelist_lock); 102 103 return 0; 104 } 105 106 /* 107 * receive an event from the remote virmidi port 108 * 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. 112 */ 113 #if 0 114 int snd_virmidi_receive(snd_rawmidi_t *rmidi, snd_seq_event_t *ev) 115 { 116 snd_virmidi_dev_t *rdev; 117 118 rdev = rmidi->private_data; 119 return snd_virmidi_dev_receive_event(rdev, ev); 120 } 121 #endif /* 0 */ 122 123 /* 124 * event handler of virmidi port 125 */ 126 static int snd_virmidi_event_input(snd_seq_event_t *ev, int direct, 127 void *private_data, int atomic, int hop) 128 { 129 snd_virmidi_dev_t *rdev; 130 131 rdev = private_data; 132 if (!(rdev->flags & SNDRV_VIRMIDI_USE)) 133 return 0; /* ignored */ 134 return snd_virmidi_dev_receive_event(rdev, ev); 135 } 136 137 /* 138 * trigger rawmidi stream for input 139 */ 140 static void snd_virmidi_input_trigger(snd_rawmidi_substream_t * substream, int up) 141 { 142 snd_virmidi_t *vmidi = substream->runtime->private_data; 143 144 if (up) { 145 vmidi->trigger = 1; 146 } else { 147 vmidi->trigger = 0; 148 } 149 } 150 151 /* 152 * trigger rawmidi stream for output 153 */ 154 static void snd_virmidi_output_trigger(snd_rawmidi_substream_t * substream, int up) 155 { 156 snd_virmidi_t *vmidi = substream->runtime->private_data; 157 int count, res; 158 unsigned char buf[32], *pbuf; 159 160 if (up) { 161 vmidi->trigger = 1; 162 if (vmidi->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH && 163 !(vmidi->rdev->flags & SNDRV_VIRMIDI_SUBSCRIBE)) { 164 snd_rawmidi_transmit_ack(substream, substream->runtime->buffer_size - substream->runtime->avail); 165 return; /* ignored */ 166 } 167 if (vmidi->event.type != SNDRV_SEQ_EVENT_NONE) { 168 if (snd_seq_kernel_client_dispatch(vmidi->client, &vmidi->event, 0, 0) < 0) 169 return; 170 vmidi->event.type = SNDRV_SEQ_EVENT_NONE; 171 } 172 while (1) { 173 count = snd_rawmidi_transmit_peek(substream, buf, sizeof(buf)); 174 if (count <= 0) 175 break; 176 pbuf = buf; 177 while (count > 0) { 178 res = snd_midi_event_encode(vmidi->parser, pbuf, count, &vmidi->event); 179 if (res < 0) { 180 snd_midi_event_reset_encode(vmidi->parser); 181 continue; 182 } 183 snd_rawmidi_transmit_ack(substream, res); 184 pbuf += res; 185 count -= res; 186 if (vmidi->event.type != SNDRV_SEQ_EVENT_NONE) { 187 if (snd_seq_kernel_client_dispatch(vmidi->client, &vmidi->event, 0, 0) < 0) 188 return; 189 vmidi->event.type = SNDRV_SEQ_EVENT_NONE; 190 } 191 } 192 } 193 } else { 194 vmidi->trigger = 0; 195 } 196 } 197 198 /* 199 * open rawmidi handle for input 200 */ 201 static int snd_virmidi_input_open(snd_rawmidi_substream_t * substream) 202 { 203 snd_virmidi_dev_t *rdev = substream->rmidi->private_data; 204 snd_rawmidi_runtime_t *runtime = substream->runtime; 205 snd_virmidi_t *vmidi; 206 unsigned long flags; 207 208 vmidi = kcalloc(1, sizeof(*vmidi), GFP_KERNEL); 209 if (vmidi == NULL) 210 return -ENOMEM; 211 vmidi->substream = substream; 212 if (snd_midi_event_new(0, &vmidi->parser) < 0) { 213 kfree(vmidi); 214 return -ENOMEM; 215 } 216 vmidi->seq_mode = rdev->seq_mode; 217 vmidi->client = rdev->client; 218 vmidi->port = rdev->port; 219 runtime->private_data = vmidi; 220 write_lock_irqsave(&rdev->filelist_lock, flags); 221 list_add_tail(&vmidi->list, &rdev->filelist); 222 write_unlock_irqrestore(&rdev->filelist_lock, flags); 223 vmidi->rdev = rdev; 224 return 0; 225 } 226 227 /* 228 * open rawmidi handle for output 229 */ 230 static int snd_virmidi_output_open(snd_rawmidi_substream_t * substream) 231 { 232 snd_virmidi_dev_t *rdev = substream->rmidi->private_data; 233 snd_rawmidi_runtime_t *runtime = substream->runtime; 234 snd_virmidi_t *vmidi; 235 236 vmidi = kcalloc(1, sizeof(*vmidi), GFP_KERNEL); 237 if (vmidi == NULL) 238 return -ENOMEM; 239 vmidi->substream = substream; 240 if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, &vmidi->parser) < 0) { 241 kfree(vmidi); 242 return -ENOMEM; 243 } 244 vmidi->seq_mode = rdev->seq_mode; 245 vmidi->client = rdev->client; 246 vmidi->port = rdev->port; 247 snd_virmidi_init_event(vmidi, &vmidi->event); 248 vmidi->rdev = rdev; 249 runtime->private_data = vmidi; 250 return 0; 251 } 252 253 /* 254 * close rawmidi handle for input 255 */ 256 static int snd_virmidi_input_close(snd_rawmidi_substream_t * substream) 257 { 258 snd_virmidi_t *vmidi = substream->runtime->private_data; 259 snd_midi_event_free(vmidi->parser); 260 list_del(&vmidi->list); 261 substream->runtime->private_data = NULL; 262 kfree(vmidi); 263 return 0; 264 } 265 266 /* 267 * close rawmidi handle for output 268 */ 269 static int snd_virmidi_output_close(snd_rawmidi_substream_t * substream) 270 { 271 snd_virmidi_t *vmidi = substream->runtime->private_data; 272 snd_midi_event_free(vmidi->parser); 273 substream->runtime->private_data = NULL; 274 kfree(vmidi); 275 return 0; 276 } 277 278 /* 279 * subscribe callback - allow output to rawmidi device 280 */ 281 static int snd_virmidi_subscribe(void *private_data, snd_seq_port_subscribe_t *info) 282 { 283 snd_virmidi_dev_t *rdev; 284 285 rdev = private_data; 286 if (!try_module_get(rdev->card->module)) 287 return -EFAULT; 288 rdev->flags |= SNDRV_VIRMIDI_SUBSCRIBE; 289 return 0; 290 } 291 292 /* 293 * unsubscribe callback - disallow output to rawmidi device 294 */ 295 static int snd_virmidi_unsubscribe(void *private_data, snd_seq_port_subscribe_t *info) 296 { 297 snd_virmidi_dev_t *rdev; 298 299 rdev = private_data; 300 rdev->flags &= ~SNDRV_VIRMIDI_SUBSCRIBE; 301 module_put(rdev->card->module); 302 return 0; 303 } 304 305 306 /* 307 * use callback - allow input to rawmidi device 308 */ 309 static int snd_virmidi_use(void *private_data, snd_seq_port_subscribe_t *info) 310 { 311 snd_virmidi_dev_t *rdev; 312 313 rdev = private_data; 314 if (!try_module_get(rdev->card->module)) 315 return -EFAULT; 316 rdev->flags |= SNDRV_VIRMIDI_USE; 317 return 0; 318 } 319 320 /* 321 * unuse callback - disallow input to rawmidi device 322 */ 323 static int snd_virmidi_unuse(void *private_data, snd_seq_port_subscribe_t *info) 324 { 325 snd_virmidi_dev_t *rdev; 326 327 rdev = private_data; 328 rdev->flags &= ~SNDRV_VIRMIDI_USE; 329 module_put(rdev->card->module); 330 return 0; 331 } 332 333 334 /* 335 * Register functions 336 */ 337 338 static snd_rawmidi_ops_t snd_virmidi_input_ops = { 339 .open = snd_virmidi_input_open, 340 .close = snd_virmidi_input_close, 341 .trigger = snd_virmidi_input_trigger, 342 }; 343 344 static snd_rawmidi_ops_t snd_virmidi_output_ops = { 345 .open = snd_virmidi_output_open, 346 .close = snd_virmidi_output_close, 347 .trigger = snd_virmidi_output_trigger, 348 }; 349 350 /* 351 * create a sequencer client and a port 352 */ 353 static int snd_virmidi_dev_attach_seq(snd_virmidi_dev_t *rdev) 354 { 355 int client; 356 snd_seq_client_callback_t callbacks; 357 snd_seq_port_callback_t pcallbacks; 358 snd_seq_client_info_t *info; 359 snd_seq_port_info_t *pinfo; 360 int err; 361 362 if (rdev->client >= 0) 363 return 0; 364 365 info = kmalloc(sizeof(*info), GFP_KERNEL); 366 pinfo = kmalloc(sizeof(*pinfo), GFP_KERNEL); 367 if (! info || ! pinfo) { 368 err = -ENOMEM; 369 goto __error; 370 } 371 372 memset(&callbacks, 0, sizeof(callbacks)); 373 callbacks.private_data = rdev; 374 callbacks.allow_input = 1; 375 callbacks.allow_output = 1; 376 client = snd_seq_create_kernel_client(rdev->card, rdev->device, &callbacks); 377 if (client < 0) { 378 err = client; 379 goto __error; 380 } 381 rdev->client = client; 382 383 /* set client name */ 384 memset(info, 0, sizeof(*info)); 385 info->client = client; 386 info->type = KERNEL_CLIENT; 387 sprintf(info->name, "%s %d-%d", rdev->rmidi->name, rdev->card->number, rdev->device); 388 snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, info); 389 390 /* create a port */ 391 memset(pinfo, 0, sizeof(*pinfo)); 392 pinfo->addr.client = client; 393 sprintf(pinfo->name, "VirMIDI %d-%d", rdev->card->number, rdev->device); 394 /* set all capabilities */ 395 pinfo->capability |= SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SYNC_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE; 396 pinfo->capability |= SNDRV_SEQ_PORT_CAP_READ | SNDRV_SEQ_PORT_CAP_SYNC_READ | SNDRV_SEQ_PORT_CAP_SUBS_READ; 397 pinfo->capability |= SNDRV_SEQ_PORT_CAP_DUPLEX; 398 pinfo->type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC; 399 pinfo->midi_channels = 16; 400 memset(&pcallbacks, 0, sizeof(pcallbacks)); 401 pcallbacks.owner = THIS_MODULE; 402 pcallbacks.private_data = rdev; 403 pcallbacks.subscribe = snd_virmidi_subscribe; 404 pcallbacks.unsubscribe = snd_virmidi_unsubscribe; 405 pcallbacks.use = snd_virmidi_use; 406 pcallbacks.unuse = snd_virmidi_unuse; 407 pcallbacks.event_input = snd_virmidi_event_input; 408 pinfo->kernel = &pcallbacks; 409 err = snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_CREATE_PORT, pinfo); 410 if (err < 0) { 411 snd_seq_delete_kernel_client(client); 412 rdev->client = -1; 413 goto __error; 414 } 415 416 rdev->port = pinfo->addr.port; 417 err = 0; /* success */ 418 419 __error: 420 kfree(info); 421 kfree(pinfo); 422 return err; 423 } 424 425 426 /* 427 * release the sequencer client 428 */ 429 static void snd_virmidi_dev_detach_seq(snd_virmidi_dev_t *rdev) 430 { 431 if (rdev->client >= 0) { 432 snd_seq_delete_kernel_client(rdev->client); 433 rdev->client = -1; 434 } 435 } 436 437 /* 438 * register the device 439 */ 440 static int snd_virmidi_dev_register(snd_rawmidi_t *rmidi) 441 { 442 snd_virmidi_dev_t *rdev = rmidi->private_data; 443 int err; 444 445 switch (rdev->seq_mode) { 446 case SNDRV_VIRMIDI_SEQ_DISPATCH: 447 err = snd_virmidi_dev_attach_seq(rdev); 448 if (err < 0) 449 return err; 450 break; 451 case SNDRV_VIRMIDI_SEQ_ATTACH: 452 if (rdev->client == 0) 453 return -EINVAL; 454 /* should check presence of port more strictly.. */ 455 break; 456 default: 457 snd_printk(KERN_ERR "seq_mode is not set: %d\n", rdev->seq_mode); 458 return -EINVAL; 459 } 460 return 0; 461 } 462 463 464 /* 465 * unregister the device 466 */ 467 static int snd_virmidi_dev_unregister(snd_rawmidi_t *rmidi) 468 { 469 snd_virmidi_dev_t *rdev = rmidi->private_data; 470 471 if (rdev->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH) 472 snd_virmidi_dev_detach_seq(rdev); 473 return 0; 474 } 475 476 /* 477 * 478 */ 479 static snd_rawmidi_global_ops_t snd_virmidi_global_ops = { 480 .dev_register = snd_virmidi_dev_register, 481 .dev_unregister = snd_virmidi_dev_unregister, 482 }; 483 484 /* 485 * free device 486 */ 487 static void snd_virmidi_free(snd_rawmidi_t *rmidi) 488 { 489 snd_virmidi_dev_t *rdev = rmidi->private_data; 490 kfree(rdev); 491 } 492 493 /* 494 * create a new device 495 * 496 */ 497 /* exported */ 498 int snd_virmidi_new(snd_card_t *card, int device, snd_rawmidi_t **rrmidi) 499 { 500 snd_rawmidi_t *rmidi; 501 snd_virmidi_dev_t *rdev; 502 int err; 503 504 *rrmidi = NULL; 505 if ((err = snd_rawmidi_new(card, "VirMidi", device, 506 16, /* may be configurable */ 507 16, /* may be configurable */ 508 &rmidi)) < 0) 509 return err; 510 strcpy(rmidi->name, rmidi->id); 511 rdev = kcalloc(1, sizeof(*rdev), GFP_KERNEL); 512 if (rdev == NULL) { 513 snd_device_free(card, rmidi); 514 return -ENOMEM; 515 } 516 rdev->card = card; 517 rdev->rmidi = rmidi; 518 rdev->device = device; 519 rdev->client = -1; 520 rwlock_init(&rdev->filelist_lock); 521 INIT_LIST_HEAD(&rdev->filelist); 522 rdev->seq_mode = SNDRV_VIRMIDI_SEQ_DISPATCH; 523 rmidi->private_data = rdev; 524 rmidi->private_free = snd_virmidi_free; 525 rmidi->ops = &snd_virmidi_global_ops; 526 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_virmidi_input_ops); 527 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_virmidi_output_ops); 528 rmidi->info_flags = SNDRV_RAWMIDI_INFO_INPUT | 529 SNDRV_RAWMIDI_INFO_OUTPUT | 530 SNDRV_RAWMIDI_INFO_DUPLEX; 531 *rrmidi = rmidi; 532 return 0; 533 } 534 535 /* 536 * ENTRY functions 537 */ 538 539 static int __init alsa_virmidi_init(void) 540 { 541 return 0; 542 } 543 544 static void __exit alsa_virmidi_exit(void) 545 { 546 } 547 548 module_init(alsa_virmidi_init) 549 module_exit(alsa_virmidi_exit) 550 551 EXPORT_SYMBOL(snd_virmidi_new); 552