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