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 <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> 50 51 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); 52 MODULE_DESCRIPTION("Virtual Raw MIDI client on Sequencer"); 53 MODULE_LICENSE("GPL"); 54 55 /* 56 * initialize an event record 57 */ 58 static void snd_virmidi_init_event(struct snd_virmidi *vmidi, 59 struct snd_seq_event *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(struct snd_virmidi_dev *rdev, 80 struct snd_seq_event *ev, 81 bool atomic) 82 { 83 struct snd_virmidi *vmidi; 84 unsigned char msg[4]; 85 int len; 86 87 if (atomic) 88 read_lock(&rdev->filelist_lock); 89 else 90 down_read(&rdev->filelist_sem); 91 list_for_each_entry(vmidi, &rdev->filelist, list) { 92 if (!vmidi->trigger) 93 continue; 94 if (ev->type == SNDRV_SEQ_EVENT_SYSEX) { 95 if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE) 96 continue; 97 snd_seq_dump_var_event(ev, (snd_seq_dump_func_t)snd_rawmidi_receive, vmidi->substream); 98 } else { 99 len = snd_midi_event_decode(vmidi->parser, msg, sizeof(msg), ev); 100 if (len > 0) 101 snd_rawmidi_receive(vmidi->substream, msg, len); 102 } 103 } 104 if (atomic) 105 read_unlock(&rdev->filelist_lock); 106 else 107 up_read(&rdev->filelist_sem); 108 109 return 0; 110 } 111 112 /* 113 * receive an event from the remote virmidi port 114 * 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. 118 */ 119 #if 0 120 int snd_virmidi_receive(struct snd_rawmidi *rmidi, struct snd_seq_event *ev) 121 { 122 struct snd_virmidi_dev *rdev; 123 124 rdev = rmidi->private_data; 125 return snd_virmidi_dev_receive_event(rdev, ev, true); 126 } 127 #endif /* 0 */ 128 129 /* 130 * event handler of virmidi port 131 */ 132 static int snd_virmidi_event_input(struct snd_seq_event *ev, int direct, 133 void *private_data, int atomic, int hop) 134 { 135 struct snd_virmidi_dev *rdev; 136 137 rdev = private_data; 138 if (!(rdev->flags & SNDRV_VIRMIDI_USE)) 139 return 0; /* ignored */ 140 return snd_virmidi_dev_receive_event(rdev, ev, atomic); 141 } 142 143 /* 144 * trigger rawmidi stream for input 145 */ 146 static void snd_virmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) 147 { 148 struct snd_virmidi *vmidi = substream->runtime->private_data; 149 150 if (up) { 151 vmidi->trigger = 1; 152 } else { 153 vmidi->trigger = 0; 154 } 155 } 156 157 /* 158 * trigger rawmidi stream for output 159 */ 160 static void snd_virmidi_output_trigger(struct snd_rawmidi_substream *substream, int up) 161 { 162 struct snd_virmidi *vmidi = substream->runtime->private_data; 163 int count, res; 164 unsigned char buf[32], *pbuf; 165 unsigned long flags; 166 167 if (up) { 168 vmidi->trigger = 1; 169 if (vmidi->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH && 170 !(vmidi->rdev->flags & SNDRV_VIRMIDI_SUBSCRIBE)) { 171 while (snd_rawmidi_transmit(substream, buf, 172 sizeof(buf)) > 0) { 173 /* ignored */ 174 } 175 return; 176 } 177 if (vmidi->event.type != SNDRV_SEQ_EVENT_NONE) { 178 if (snd_seq_kernel_client_dispatch(vmidi->client, &vmidi->event, in_atomic(), 0) < 0) 179 return; 180 vmidi->event.type = SNDRV_SEQ_EVENT_NONE; 181 } 182 spin_lock_irqsave(&substream->runtime->lock, flags); 183 while (1) { 184 count = __snd_rawmidi_transmit_peek(substream, buf, sizeof(buf)); 185 if (count <= 0) 186 break; 187 pbuf = buf; 188 while (count > 0) { 189 res = snd_midi_event_encode(vmidi->parser, pbuf, count, &vmidi->event); 190 if (res < 0) { 191 snd_midi_event_reset_encode(vmidi->parser); 192 continue; 193 } 194 __snd_rawmidi_transmit_ack(substream, res); 195 pbuf += res; 196 count -= 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) 199 goto out; 200 vmidi->event.type = SNDRV_SEQ_EVENT_NONE; 201 } 202 } 203 } 204 out: 205 spin_unlock_irqrestore(&substream->runtime->lock, flags); 206 } else { 207 vmidi->trigger = 0; 208 } 209 } 210 211 /* 212 * open rawmidi handle for input 213 */ 214 static int snd_virmidi_input_open(struct snd_rawmidi_substream *substream) 215 { 216 struct snd_virmidi_dev *rdev = substream->rmidi->private_data; 217 struct snd_rawmidi_runtime *runtime = substream->runtime; 218 struct snd_virmidi *vmidi; 219 220 vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL); 221 if (vmidi == NULL) 222 return -ENOMEM; 223 vmidi->substream = substream; 224 if (snd_midi_event_new(0, &vmidi->parser) < 0) { 225 kfree(vmidi); 226 return -ENOMEM; 227 } 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); 237 vmidi->rdev = rdev; 238 return 0; 239 } 240 241 /* 242 * open rawmidi handle for output 243 */ 244 static int snd_virmidi_output_open(struct snd_rawmidi_substream *substream) 245 { 246 struct snd_virmidi_dev *rdev = substream->rmidi->private_data; 247 struct snd_rawmidi_runtime *runtime = substream->runtime; 248 struct snd_virmidi *vmidi; 249 250 vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL); 251 if (vmidi == NULL) 252 return -ENOMEM; 253 vmidi->substream = substream; 254 if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, &vmidi->parser) < 0) { 255 kfree(vmidi); 256 return -ENOMEM; 257 } 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); 262 vmidi->rdev = rdev; 263 runtime->private_data = vmidi; 264 return 0; 265 } 266 267 /* 268 * close rawmidi handle for input 269 */ 270 static int snd_virmidi_input_close(struct snd_rawmidi_substream *substream) 271 { 272 struct snd_virmidi_dev *rdev = substream->rmidi->private_data; 273 struct snd_virmidi *vmidi = substream->runtime->private_data; 274 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; 282 kfree(vmidi); 283 return 0; 284 } 285 286 /* 287 * close rawmidi handle for output 288 */ 289 static int snd_virmidi_output_close(struct snd_rawmidi_substream *substream) 290 { 291 struct snd_virmidi *vmidi = substream->runtime->private_data; 292 snd_midi_event_free(vmidi->parser); 293 substream->runtime->private_data = NULL; 294 kfree(vmidi); 295 return 0; 296 } 297 298 /* 299 * subscribe callback - allow output to rawmidi device 300 */ 301 static int snd_virmidi_subscribe(void *private_data, 302 struct snd_seq_port_subscribe *info) 303 { 304 struct snd_virmidi_dev *rdev; 305 306 rdev = private_data; 307 if (!try_module_get(rdev->card->module)) 308 return -EFAULT; 309 rdev->flags |= SNDRV_VIRMIDI_SUBSCRIBE; 310 return 0; 311 } 312 313 /* 314 * unsubscribe callback - disallow output to rawmidi device 315 */ 316 static int snd_virmidi_unsubscribe(void *private_data, 317 struct snd_seq_port_subscribe *info) 318 { 319 struct snd_virmidi_dev *rdev; 320 321 rdev = private_data; 322 rdev->flags &= ~SNDRV_VIRMIDI_SUBSCRIBE; 323 module_put(rdev->card->module); 324 return 0; 325 } 326 327 328 /* 329 * use callback - allow input to rawmidi device 330 */ 331 static int snd_virmidi_use(void *private_data, 332 struct snd_seq_port_subscribe *info) 333 { 334 struct snd_virmidi_dev *rdev; 335 336 rdev = private_data; 337 if (!try_module_get(rdev->card->module)) 338 return -EFAULT; 339 rdev->flags |= SNDRV_VIRMIDI_USE; 340 return 0; 341 } 342 343 /* 344 * unuse callback - disallow input to rawmidi device 345 */ 346 static int snd_virmidi_unuse(void *private_data, 347 struct snd_seq_port_subscribe *info) 348 { 349 struct snd_virmidi_dev *rdev; 350 351 rdev = private_data; 352 rdev->flags &= ~SNDRV_VIRMIDI_USE; 353 module_put(rdev->card->module); 354 return 0; 355 } 356 357 358 /* 359 * Register functions 360 */ 361 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, 366 }; 367 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, 372 }; 373 374 /* 375 * create a sequencer client and a port 376 */ 377 static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev) 378 { 379 int client; 380 struct snd_seq_port_callback pcallbacks; 381 struct snd_seq_port_info *pinfo; 382 int err; 383 384 if (rdev->client >= 0) 385 return 0; 386 387 pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL); 388 if (!pinfo) { 389 err = -ENOMEM; 390 goto __error; 391 } 392 393 client = snd_seq_create_kernel_client(rdev->card, rdev->device, 394 "%s %d-%d", rdev->rmidi->name, 395 rdev->card->number, 396 rdev->device); 397 if (client < 0) { 398 err = client; 399 goto __error; 400 } 401 rdev->client = client; 402 403 /* create a port */ 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); 424 if (err < 0) { 425 snd_seq_delete_kernel_client(client); 426 rdev->client = -1; 427 goto __error; 428 } 429 430 rdev->port = pinfo->addr.port; 431 err = 0; /* success */ 432 433 __error: 434 kfree(pinfo); 435 return err; 436 } 437 438 439 /* 440 * release the sequencer client 441 */ 442 static void snd_virmidi_dev_detach_seq(struct snd_virmidi_dev *rdev) 443 { 444 if (rdev->client >= 0) { 445 snd_seq_delete_kernel_client(rdev->client); 446 rdev->client = -1; 447 } 448 } 449 450 /* 451 * register the device 452 */ 453 static int snd_virmidi_dev_register(struct snd_rawmidi *rmidi) 454 { 455 struct snd_virmidi_dev *rdev = rmidi->private_data; 456 int err; 457 458 switch (rdev->seq_mode) { 459 case SNDRV_VIRMIDI_SEQ_DISPATCH: 460 err = snd_virmidi_dev_attach_seq(rdev); 461 if (err < 0) 462 return err; 463 break; 464 case SNDRV_VIRMIDI_SEQ_ATTACH: 465 if (rdev->client == 0) 466 return -EINVAL; 467 /* should check presence of port more strictly.. */ 468 break; 469 default: 470 pr_err("ALSA: seq_virmidi: seq_mode is not set: %d\n", rdev->seq_mode); 471 return -EINVAL; 472 } 473 return 0; 474 } 475 476 477 /* 478 * unregister the device 479 */ 480 static int snd_virmidi_dev_unregister(struct snd_rawmidi *rmidi) 481 { 482 struct snd_virmidi_dev *rdev = rmidi->private_data; 483 484 if (rdev->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH) 485 snd_virmidi_dev_detach_seq(rdev); 486 return 0; 487 } 488 489 /* 490 * 491 */ 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, 495 }; 496 497 /* 498 * free device 499 */ 500 static void snd_virmidi_free(struct snd_rawmidi *rmidi) 501 { 502 struct snd_virmidi_dev *rdev = rmidi->private_data; 503 kfree(rdev); 504 } 505 506 /* 507 * create a new device 508 * 509 */ 510 /* exported */ 511 int snd_virmidi_new(struct snd_card *card, int device, struct snd_rawmidi **rrmidi) 512 { 513 struct snd_rawmidi *rmidi; 514 struct snd_virmidi_dev *rdev; 515 int err; 516 517 *rrmidi = NULL; 518 if ((err = snd_rawmidi_new(card, "VirMidi", device, 519 16, /* may be configurable */ 520 16, /* may be configurable */ 521 &rmidi)) < 0) 522 return err; 523 strcpy(rmidi->name, rmidi->id); 524 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL); 525 if (rdev == NULL) { 526 snd_device_free(card, rmidi); 527 return -ENOMEM; 528 } 529 rdev->card = card; 530 rdev->rmidi = rmidi; 531 rdev->device = device; 532 rdev->client = -1; 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; 545 *rrmidi = rmidi; 546 return 0; 547 } 548 EXPORT_SYMBOL(snd_virmidi_new); 549 550 /* 551 * ENTRY functions 552 */ 553 554 static int __init alsa_virmidi_init(void) 555 { 556 return 0; 557 } 558 559 static void __exit alsa_virmidi_exit(void) 560 { 561 } 562 563 module_init(alsa_virmidi_init) 564 module_exit(alsa_virmidi_exit) 565