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