1 /* 2 * OSS compatible sequencer driver 3 * 4 * synth device handlers 5 * 6 * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23 #include "seq_oss_synth.h" 24 #include "seq_oss_midi.h" 25 #include "../seq_lock.h" 26 #include <linux/init.h> 27 #include <linux/module.h> 28 #include <linux/slab.h> 29 30 /* 31 * constants 32 */ 33 #define SNDRV_SEQ_OSS_MAX_SYNTH_NAME 30 34 #define MAX_SYSEX_BUFLEN 128 35 36 37 /* 38 * definition of synth info records 39 */ 40 41 /* sysex buffer */ 42 struct seq_oss_synth_sysex { 43 int len; 44 int skip; 45 unsigned char buf[MAX_SYSEX_BUFLEN]; 46 }; 47 48 /* synth info */ 49 struct seq_oss_synth { 50 int seq_device; 51 52 /* for synth_info */ 53 int synth_type; 54 int synth_subtype; 55 int nr_voices; 56 57 char name[SNDRV_SEQ_OSS_MAX_SYNTH_NAME]; 58 struct snd_seq_oss_callback oper; 59 60 int opened; 61 62 void *private_data; 63 snd_use_lock_t use_lock; 64 }; 65 66 67 /* 68 * device table 69 */ 70 static int max_synth_devs; 71 static struct seq_oss_synth *synth_devs[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; 72 static struct seq_oss_synth midi_synth_dev = { 73 -1, /* seq_device */ 74 SYNTH_TYPE_MIDI, /* synth_type */ 75 0, /* synth_subtype */ 76 16, /* nr_voices */ 77 "MIDI", /* name */ 78 }; 79 80 static DEFINE_SPINLOCK(register_lock); 81 82 /* 83 * prototypes 84 */ 85 static struct seq_oss_synth *get_synthdev(struct seq_oss_devinfo *dp, int dev); 86 static void reset_channels(struct seq_oss_synthinfo *info); 87 88 /* 89 * global initialization 90 */ 91 void __init 92 snd_seq_oss_synth_init(void) 93 { 94 snd_use_lock_init(&midi_synth_dev.use_lock); 95 } 96 97 /* 98 * registration of the synth device 99 */ 100 int 101 snd_seq_oss_synth_probe(struct device *_dev) 102 { 103 struct snd_seq_device *dev = to_seq_dev(_dev); 104 int i; 105 struct seq_oss_synth *rec; 106 struct snd_seq_oss_reg *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev); 107 unsigned long flags; 108 109 rec = kzalloc(sizeof(*rec), GFP_KERNEL); 110 if (!rec) 111 return -ENOMEM; 112 rec->seq_device = -1; 113 rec->synth_type = reg->type; 114 rec->synth_subtype = reg->subtype; 115 rec->nr_voices = reg->nvoices; 116 rec->oper = reg->oper; 117 rec->private_data = reg->private_data; 118 rec->opened = 0; 119 snd_use_lock_init(&rec->use_lock); 120 121 /* copy and truncate the name of synth device */ 122 strlcpy(rec->name, dev->name, sizeof(rec->name)); 123 124 /* registration */ 125 spin_lock_irqsave(®ister_lock, flags); 126 for (i = 0; i < max_synth_devs; i++) { 127 if (synth_devs[i] == NULL) 128 break; 129 } 130 if (i >= max_synth_devs) { 131 if (max_synth_devs >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS) { 132 spin_unlock_irqrestore(®ister_lock, flags); 133 pr_err("ALSA: seq_oss: no more synth slot\n"); 134 kfree(rec); 135 return -ENOMEM; 136 } 137 max_synth_devs++; 138 } 139 rec->seq_device = i; 140 synth_devs[i] = rec; 141 spin_unlock_irqrestore(®ister_lock, flags); 142 dev->driver_data = rec; 143 #ifdef SNDRV_OSS_INFO_DEV_SYNTH 144 if (i < SNDRV_CARDS) 145 snd_oss_info_register(SNDRV_OSS_INFO_DEV_SYNTH, i, rec->name); 146 #endif 147 return 0; 148 } 149 150 151 int 152 snd_seq_oss_synth_remove(struct device *_dev) 153 { 154 struct snd_seq_device *dev = to_seq_dev(_dev); 155 int index; 156 struct seq_oss_synth *rec = dev->driver_data; 157 unsigned long flags; 158 159 spin_lock_irqsave(®ister_lock, flags); 160 for (index = 0; index < max_synth_devs; index++) { 161 if (synth_devs[index] == rec) 162 break; 163 } 164 if (index >= max_synth_devs) { 165 spin_unlock_irqrestore(®ister_lock, flags); 166 pr_err("ALSA: seq_oss: can't unregister synth\n"); 167 return -EINVAL; 168 } 169 synth_devs[index] = NULL; 170 if (index == max_synth_devs - 1) { 171 for (index--; index >= 0; index--) { 172 if (synth_devs[index]) 173 break; 174 } 175 max_synth_devs = index + 1; 176 } 177 spin_unlock_irqrestore(®ister_lock, flags); 178 #ifdef SNDRV_OSS_INFO_DEV_SYNTH 179 if (rec->seq_device < SNDRV_CARDS) 180 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_SYNTH, rec->seq_device); 181 #endif 182 183 snd_use_lock_sync(&rec->use_lock); 184 kfree(rec); 185 186 return 0; 187 } 188 189 190 /* 191 */ 192 static struct seq_oss_synth * 193 get_sdev(int dev) 194 { 195 struct seq_oss_synth *rec; 196 unsigned long flags; 197 198 spin_lock_irqsave(®ister_lock, flags); 199 rec = synth_devs[dev]; 200 if (rec) 201 snd_use_lock_use(&rec->use_lock); 202 spin_unlock_irqrestore(®ister_lock, flags); 203 return rec; 204 } 205 206 207 /* 208 * set up synth tables 209 */ 210 211 void 212 snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp) 213 { 214 int i; 215 struct seq_oss_synth *rec; 216 struct seq_oss_synthinfo *info; 217 218 dp->max_synthdev = max_synth_devs; 219 dp->synth_opened = 0; 220 memset(dp->synths, 0, sizeof(dp->synths)); 221 for (i = 0; i < dp->max_synthdev; i++) { 222 rec = get_sdev(i); 223 if (rec == NULL) 224 continue; 225 if (rec->oper.open == NULL || rec->oper.close == NULL) { 226 snd_use_lock_free(&rec->use_lock); 227 continue; 228 } 229 info = &dp->synths[i]; 230 info->arg.app_index = dp->port; 231 info->arg.file_mode = dp->file_mode; 232 info->arg.seq_mode = dp->seq_mode; 233 if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_SYNTH) 234 info->arg.event_passing = SNDRV_SEQ_OSS_PROCESS_EVENTS; 235 else 236 info->arg.event_passing = SNDRV_SEQ_OSS_PASS_EVENTS; 237 info->opened = 0; 238 if (!try_module_get(rec->oper.owner)) { 239 snd_use_lock_free(&rec->use_lock); 240 continue; 241 } 242 if (rec->oper.open(&info->arg, rec->private_data) < 0) { 243 module_put(rec->oper.owner); 244 snd_use_lock_free(&rec->use_lock); 245 continue; 246 } 247 info->nr_voices = rec->nr_voices; 248 if (info->nr_voices > 0) { 249 info->ch = kcalloc(info->nr_voices, sizeof(struct seq_oss_chinfo), GFP_KERNEL); 250 if (!info->ch) { 251 rec->oper.close(&info->arg); 252 module_put(rec->oper.owner); 253 snd_use_lock_free(&rec->use_lock); 254 continue; 255 } 256 reset_channels(info); 257 } 258 info->opened++; 259 rec->opened++; 260 dp->synth_opened++; 261 snd_use_lock_free(&rec->use_lock); 262 } 263 } 264 265 266 /* 267 * set up synth tables for MIDI emulation - /dev/music mode only 268 */ 269 270 void 271 snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp) 272 { 273 int i; 274 275 if (dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS) 276 return; 277 278 for (i = 0; i < dp->max_mididev; i++) { 279 struct seq_oss_synthinfo *info; 280 info = &dp->synths[dp->max_synthdev]; 281 if (snd_seq_oss_midi_open(dp, i, dp->file_mode) < 0) 282 continue; 283 info->arg.app_index = dp->port; 284 info->arg.file_mode = dp->file_mode; 285 info->arg.seq_mode = dp->seq_mode; 286 info->arg.private_data = info; 287 info->is_midi = 1; 288 info->midi_mapped = i; 289 info->arg.event_passing = SNDRV_SEQ_OSS_PASS_EVENTS; 290 snd_seq_oss_midi_get_addr(dp, i, &info->arg.addr); 291 info->opened = 1; 292 midi_synth_dev.opened++; 293 dp->max_synthdev++; 294 if (dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS) 295 break; 296 } 297 } 298 299 300 /* 301 * clean up synth tables 302 */ 303 304 void 305 snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp) 306 { 307 int i; 308 struct seq_oss_synth *rec; 309 struct seq_oss_synthinfo *info; 310 311 if (snd_BUG_ON(dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS)) 312 return; 313 for (i = 0; i < dp->max_synthdev; i++) { 314 info = &dp->synths[i]; 315 if (! info->opened) 316 continue; 317 if (info->is_midi) { 318 if (midi_synth_dev.opened > 0) { 319 snd_seq_oss_midi_close(dp, info->midi_mapped); 320 midi_synth_dev.opened--; 321 } 322 } else { 323 rec = get_sdev(i); 324 if (rec == NULL) 325 continue; 326 if (rec->opened > 0) { 327 rec->oper.close(&info->arg); 328 module_put(rec->oper.owner); 329 rec->opened = 0; 330 } 331 snd_use_lock_free(&rec->use_lock); 332 } 333 kfree(info->sysex); 334 info->sysex = NULL; 335 kfree(info->ch); 336 info->ch = NULL; 337 } 338 dp->synth_opened = 0; 339 dp->max_synthdev = 0; 340 } 341 342 /* 343 * check if the specified device is MIDI mapped device 344 */ 345 static int 346 is_midi_dev(struct seq_oss_devinfo *dp, int dev) 347 { 348 if (dev < 0 || dev >= dp->max_synthdev) 349 return 0; 350 if (dp->synths[dev].is_midi) 351 return 1; 352 return 0; 353 } 354 355 /* 356 * return synth device information pointer 357 */ 358 static struct seq_oss_synth * 359 get_synthdev(struct seq_oss_devinfo *dp, int dev) 360 { 361 struct seq_oss_synth *rec; 362 if (dev < 0 || dev >= dp->max_synthdev) 363 return NULL; 364 if (! dp->synths[dev].opened) 365 return NULL; 366 if (dp->synths[dev].is_midi) 367 return &midi_synth_dev; 368 if ((rec = get_sdev(dev)) == NULL) 369 return NULL; 370 if (! rec->opened) { 371 snd_use_lock_free(&rec->use_lock); 372 return NULL; 373 } 374 return rec; 375 } 376 377 378 /* 379 * reset note and velocity on each channel. 380 */ 381 static void 382 reset_channels(struct seq_oss_synthinfo *info) 383 { 384 int i; 385 if (info->ch == NULL || ! info->nr_voices) 386 return; 387 for (i = 0; i < info->nr_voices; i++) { 388 info->ch[i].note = -1; 389 info->ch[i].vel = 0; 390 } 391 } 392 393 394 /* 395 * reset synth device: 396 * call reset callback. if no callback is defined, send a heartbeat 397 * event to the corresponding port. 398 */ 399 void 400 snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev) 401 { 402 struct seq_oss_synth *rec; 403 struct seq_oss_synthinfo *info; 404 405 if (snd_BUG_ON(dev < 0 || dev >= dp->max_synthdev)) 406 return; 407 info = &dp->synths[dev]; 408 if (! info->opened) 409 return; 410 if (info->sysex) 411 info->sysex->len = 0; /* reset sysex */ 412 reset_channels(info); 413 if (info->is_midi) { 414 if (midi_synth_dev.opened <= 0) 415 return; 416 snd_seq_oss_midi_reset(dp, info->midi_mapped); 417 /* reopen the device */ 418 snd_seq_oss_midi_close(dp, dev); 419 if (snd_seq_oss_midi_open(dp, info->midi_mapped, 420 dp->file_mode) < 0) { 421 midi_synth_dev.opened--; 422 info->opened = 0; 423 kfree(info->sysex); 424 info->sysex = NULL; 425 kfree(info->ch); 426 info->ch = NULL; 427 } 428 return; 429 } 430 431 rec = get_sdev(dev); 432 if (rec == NULL) 433 return; 434 if (rec->oper.reset) { 435 rec->oper.reset(&info->arg); 436 } else { 437 struct snd_seq_event ev; 438 memset(&ev, 0, sizeof(ev)); 439 snd_seq_oss_fill_addr(dp, &ev, info->arg.addr.client, 440 info->arg.addr.port); 441 ev.type = SNDRV_SEQ_EVENT_RESET; 442 snd_seq_oss_dispatch(dp, &ev, 0, 0); 443 } 444 snd_use_lock_free(&rec->use_lock); 445 } 446 447 448 /* 449 * load a patch record: 450 * call load_patch callback function 451 */ 452 int 453 snd_seq_oss_synth_load_patch(struct seq_oss_devinfo *dp, int dev, int fmt, 454 const char __user *buf, int p, int c) 455 { 456 struct seq_oss_synth *rec; 457 int rc; 458 459 if (dev < 0 || dev >= dp->max_synthdev) 460 return -ENXIO; 461 462 if (is_midi_dev(dp, dev)) 463 return 0; 464 if ((rec = get_synthdev(dp, dev)) == NULL) 465 return -ENXIO; 466 467 if (rec->oper.load_patch == NULL) 468 rc = -ENXIO; 469 else 470 rc = rec->oper.load_patch(&dp->synths[dev].arg, fmt, buf, p, c); 471 snd_use_lock_free(&rec->use_lock); 472 return rc; 473 } 474 475 /* 476 * check if the device is valid synth device 477 */ 478 int 479 snd_seq_oss_synth_is_valid(struct seq_oss_devinfo *dp, int dev) 480 { 481 struct seq_oss_synth *rec; 482 rec = get_synthdev(dp, dev); 483 if (rec) { 484 snd_use_lock_free(&rec->use_lock); 485 return 1; 486 } 487 return 0; 488 } 489 490 491 /* 492 * receive OSS 6 byte sysex packet: 493 * the full sysex message will be sent if it reaches to the end of data 494 * (0xff). 495 */ 496 int 497 snd_seq_oss_synth_sysex(struct seq_oss_devinfo *dp, int dev, unsigned char *buf, struct snd_seq_event *ev) 498 { 499 int i, send; 500 unsigned char *dest; 501 struct seq_oss_synth_sysex *sysex; 502 503 if (! snd_seq_oss_synth_is_valid(dp, dev)) 504 return -ENXIO; 505 506 sysex = dp->synths[dev].sysex; 507 if (sysex == NULL) { 508 sysex = kzalloc(sizeof(*sysex), GFP_KERNEL); 509 if (sysex == NULL) 510 return -ENOMEM; 511 dp->synths[dev].sysex = sysex; 512 } 513 514 send = 0; 515 dest = sysex->buf + sysex->len; 516 /* copy 6 byte packet to the buffer */ 517 for (i = 0; i < 6; i++) { 518 if (buf[i] == 0xff) { 519 send = 1; 520 break; 521 } 522 dest[i] = buf[i]; 523 sysex->len++; 524 if (sysex->len >= MAX_SYSEX_BUFLEN) { 525 sysex->len = 0; 526 sysex->skip = 1; 527 break; 528 } 529 } 530 531 if (sysex->len && send) { 532 if (sysex->skip) { 533 sysex->skip = 0; 534 sysex->len = 0; 535 return -EINVAL; /* skip */ 536 } 537 /* copy the data to event record and send it */ 538 ev->flags = SNDRV_SEQ_EVENT_LENGTH_VARIABLE; 539 if (snd_seq_oss_synth_addr(dp, dev, ev)) 540 return -EINVAL; 541 ev->data.ext.len = sysex->len; 542 ev->data.ext.ptr = sysex->buf; 543 sysex->len = 0; 544 return 0; 545 } 546 547 return -EINVAL; /* skip */ 548 } 549 550 /* 551 * fill the event source/destination addresses 552 */ 553 int 554 snd_seq_oss_synth_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_event *ev) 555 { 556 if (! snd_seq_oss_synth_is_valid(dp, dev)) 557 return -EINVAL; 558 snd_seq_oss_fill_addr(dp, ev, dp->synths[dev].arg.addr.client, 559 dp->synths[dev].arg.addr.port); 560 return 0; 561 } 562 563 564 /* 565 * OSS compatible ioctl 566 */ 567 int 568 snd_seq_oss_synth_ioctl(struct seq_oss_devinfo *dp, int dev, unsigned int cmd, unsigned long addr) 569 { 570 struct seq_oss_synth *rec; 571 int rc; 572 573 if (is_midi_dev(dp, dev)) 574 return -ENXIO; 575 if ((rec = get_synthdev(dp, dev)) == NULL) 576 return -ENXIO; 577 if (rec->oper.ioctl == NULL) 578 rc = -ENXIO; 579 else 580 rc = rec->oper.ioctl(&dp->synths[dev].arg, cmd, addr); 581 snd_use_lock_free(&rec->use_lock); 582 return rc; 583 } 584 585 586 /* 587 * send OSS raw events - SEQ_PRIVATE and SEQ_VOLUME 588 */ 589 int 590 snd_seq_oss_synth_raw_event(struct seq_oss_devinfo *dp, int dev, unsigned char *data, struct snd_seq_event *ev) 591 { 592 if (! snd_seq_oss_synth_is_valid(dp, dev) || is_midi_dev(dp, dev)) 593 return -ENXIO; 594 ev->type = SNDRV_SEQ_EVENT_OSS; 595 memcpy(ev->data.raw8.d, data, 8); 596 return snd_seq_oss_synth_addr(dp, dev, ev); 597 } 598 599 600 /* 601 * create OSS compatible synth_info record 602 */ 603 int 604 snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_info *inf) 605 { 606 struct seq_oss_synth *rec; 607 608 if (dev < 0 || dev >= dp->max_synthdev) 609 return -ENXIO; 610 611 if (dp->synths[dev].is_midi) { 612 struct midi_info minf; 613 snd_seq_oss_midi_make_info(dp, dp->synths[dev].midi_mapped, &minf); 614 inf->synth_type = SYNTH_TYPE_MIDI; 615 inf->synth_subtype = 0; 616 inf->nr_voices = 16; 617 inf->device = dev; 618 strlcpy(inf->name, minf.name, sizeof(inf->name)); 619 } else { 620 if ((rec = get_synthdev(dp, dev)) == NULL) 621 return -ENXIO; 622 inf->synth_type = rec->synth_type; 623 inf->synth_subtype = rec->synth_subtype; 624 inf->nr_voices = rec->nr_voices; 625 inf->device = dev; 626 strlcpy(inf->name, rec->name, sizeof(inf->name)); 627 snd_use_lock_free(&rec->use_lock); 628 } 629 return 0; 630 } 631 632 633 #ifdef CONFIG_PROC_FS 634 /* 635 * proc interface 636 */ 637 void 638 snd_seq_oss_synth_info_read(struct snd_info_buffer *buf) 639 { 640 int i; 641 struct seq_oss_synth *rec; 642 643 snd_iprintf(buf, "\nNumber of synth devices: %d\n", max_synth_devs); 644 for (i = 0; i < max_synth_devs; i++) { 645 snd_iprintf(buf, "\nsynth %d: ", i); 646 rec = get_sdev(i); 647 if (rec == NULL) { 648 snd_iprintf(buf, "*empty*\n"); 649 continue; 650 } 651 snd_iprintf(buf, "[%s]\n", rec->name); 652 snd_iprintf(buf, " type 0x%x : subtype 0x%x : voices %d\n", 653 rec->synth_type, rec->synth_subtype, 654 rec->nr_voices); 655 snd_iprintf(buf, " capabilities : ioctl %s / load_patch %s\n", 656 enabled_str((long)rec->oper.ioctl), 657 enabled_str((long)rec->oper.load_patch)); 658 snd_use_lock_free(&rec->use_lock); 659 } 660 } 661 #endif /* CONFIG_PROC_FS */ 662