1 /*- 2 * Copyright (c) 2003 Mathew Kanner 3 * Copyright (c) 1998 The NetBSD Foundation, Inc. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to The NetBSD Foundation 7 * by Lennart Augustsson (augustss@netbsd.org). 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 20 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 22 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 /* 32 * Parts of this file started out as NetBSD: midi.c 1.31 33 * They are mostly gone. Still the most obvious will be the state 34 * machine midi_in 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 #include <sys/param.h> 41 #include <sys/queue.h> 42 #include <sys/kernel.h> 43 #include <sys/lock.h> 44 #include <sys/mutex.h> 45 #include <sys/proc.h> 46 #include <sys/signalvar.h> 47 #include <sys/conf.h> 48 #include <sys/selinfo.h> 49 #include <sys/sysctl.h> 50 #include <sys/types.h> 51 #include <sys/malloc.h> 52 #include <sys/param.h> 53 #include <sys/systm.h> 54 #include <sys/proc.h> 55 #include <sys/fcntl.h> 56 #include <sys/types.h> 57 #include <sys/uio.h> 58 #include <sys/poll.h> 59 #include <sys/sbuf.h> 60 #include <sys/kobj.h> 61 #include <sys/module.h> 62 63 #ifdef HAVE_KERNEL_OPTION_HEADERS 64 #include "opt_snd.h" 65 #endif 66 67 #include <dev/sound/midi/midi.h> 68 #include "mpu_if.h" 69 70 #include <dev/sound/midi/midiq.h> 71 #include "synth_if.h" 72 MALLOC_DEFINE(M_MIDI, "midi buffers", "Midi data allocation area"); 73 74 #ifndef KOBJMETHOD_END 75 #define KOBJMETHOD_END { NULL, NULL } 76 #endif 77 78 #define PCMMKMINOR(u, d, c) ((((c) & 0xff) << 16) | (((u) & 0x0f) << 4) | ((d) & 0x0f)) 79 #define MIDIMKMINOR(u, d, c) PCMMKMINOR(u, d, c) 80 81 #define MIDI_DEV_RAW 2 82 #define MIDI_DEV_MIDICTL 12 83 84 enum midi_states { 85 MIDI_IN_START, MIDI_IN_SYSEX, MIDI_IN_DATA 86 }; 87 88 /* 89 * The MPU interface current has init() uninit() inqsize(( outqsize() 90 * callback() : fiddle with the tx|rx status. 91 */ 92 93 #include "mpu_if.h" 94 95 /* 96 * /dev/rmidi Structure definitions 97 */ 98 99 #define MIDI_NAMELEN 16 100 struct snd_midi { 101 KOBJ_FIELDS; 102 struct mtx lock; /* Protects all but queues */ 103 void *cookie; 104 105 int unit; /* Should only be used in midistat */ 106 int channel; /* Should only be used in midistat */ 107 108 int busy; 109 int flags; /* File flags */ 110 char name[MIDI_NAMELEN]; 111 struct mtx qlock; /* Protects inq, outq and flags */ 112 MIDIQ_HEAD(, char) inq, outq; 113 int rchan, wchan; 114 struct selinfo rsel, wsel; 115 int hiwat; /* QLEN(outq)>High-water -> disable 116 * writes from userland */ 117 enum midi_states inq_state; 118 int inq_status, inq_left; /* Variables for the state machine in 119 * Midi_in, this is to provide that 120 * signals only get issued only 121 * complete command packets. */ 122 struct proc *async; 123 struct cdev *dev; 124 struct synth_midi *synth; 125 int synth_flags; 126 TAILQ_ENTRY(snd_midi) link; 127 }; 128 129 struct synth_midi { 130 KOBJ_FIELDS; 131 struct snd_midi *m; 132 }; 133 134 static synth_open_t midisynth_open; 135 static synth_close_t midisynth_close; 136 static synth_writeraw_t midisynth_writeraw; 137 static synth_killnote_t midisynth_killnote; 138 static synth_startnote_t midisynth_startnote; 139 static synth_setinstr_t midisynth_setinstr; 140 static synth_alloc_t midisynth_alloc; 141 static synth_controller_t midisynth_controller; 142 static synth_bender_t midisynth_bender; 143 144 145 static kobj_method_t midisynth_methods[] = { 146 KOBJMETHOD(synth_open, midisynth_open), 147 KOBJMETHOD(synth_close, midisynth_close), 148 KOBJMETHOD(synth_writeraw, midisynth_writeraw), 149 KOBJMETHOD(synth_setinstr, midisynth_setinstr), 150 KOBJMETHOD(synth_startnote, midisynth_startnote), 151 KOBJMETHOD(synth_killnote, midisynth_killnote), 152 KOBJMETHOD(synth_alloc, midisynth_alloc), 153 KOBJMETHOD(synth_controller, midisynth_controller), 154 KOBJMETHOD(synth_bender, midisynth_bender), 155 KOBJMETHOD_END 156 }; 157 158 DEFINE_CLASS(midisynth, midisynth_methods, 0); 159 160 /* 161 * Module Exports & Interface 162 * 163 * struct midi_chan *midi_init(MPU_CLASS cls, int unit, int chan) int 164 * midi_uninit(struct snd_midi *) 0 == no error EBUSY or other error int 165 * Midi_in(struct midi_chan *, char *buf, int count) int Midi_out(struct 166 * midi_chan *, char *buf, int count) 167 * 168 * midi_{in,out} return actual size transfered 169 * 170 */ 171 172 173 /* 174 * midi_devs tailq, holder of all rmidi instances protected by midistat_lock 175 */ 176 177 TAILQ_HEAD(, snd_midi) midi_devs; 178 179 /* 180 * /dev/midistat variables and declarations, protected by midistat_lock 181 */ 182 183 static struct mtx midistat_lock; 184 static int midistat_isopen = 0; 185 static struct sbuf midistat_sbuf; 186 static int midistat_bufptr; 187 static struct cdev *midistat_dev; 188 189 /* 190 * /dev/midistat dev_t declarations 191 */ 192 193 static d_open_t midistat_open; 194 static d_close_t midistat_close; 195 static d_read_t midistat_read; 196 197 static struct cdevsw midistat_cdevsw = { 198 .d_version = D_VERSION, 199 .d_open = midistat_open, 200 .d_close = midistat_close, 201 .d_read = midistat_read, 202 .d_name = "midistat", 203 }; 204 205 206 /* 207 * /dev/rmidi dev_t declarations, struct variable access is protected by 208 * locks contained within the structure. 209 */ 210 211 static d_open_t midi_open; 212 static d_close_t midi_close; 213 static d_ioctl_t midi_ioctl; 214 static d_read_t midi_read; 215 static d_write_t midi_write; 216 static d_poll_t midi_poll; 217 218 static struct cdevsw midi_cdevsw = { 219 .d_version = D_VERSION, 220 .d_open = midi_open, 221 .d_close = midi_close, 222 .d_read = midi_read, 223 .d_write = midi_write, 224 .d_ioctl = midi_ioctl, 225 .d_poll = midi_poll, 226 .d_name = "rmidi", 227 }; 228 229 /* 230 * Prototypes of library functions 231 */ 232 233 static int midi_destroy(struct snd_midi *, int); 234 static int midistat_prepare(struct sbuf * s); 235 static int midi_load(void); 236 static int midi_unload(void); 237 238 /* 239 * Misc declr. 240 */ 241 SYSCTL_NODE(_hw, OID_AUTO, midi, CTLFLAG_RD, 0, "Midi driver"); 242 static SYSCTL_NODE(_hw_midi, OID_AUTO, stat, CTLFLAG_RD, 0, "Status device"); 243 244 int midi_debug; 245 /* XXX: should this be moved into debug.midi? */ 246 SYSCTL_INT(_hw_midi, OID_AUTO, debug, CTLFLAG_RW, &midi_debug, 0, ""); 247 248 int midi_dumpraw; 249 SYSCTL_INT(_hw_midi, OID_AUTO, dumpraw, CTLFLAG_RW, &midi_dumpraw, 0, ""); 250 251 int midi_instroff; 252 SYSCTL_INT(_hw_midi, OID_AUTO, instroff, CTLFLAG_RW, &midi_instroff, 0, ""); 253 254 int midistat_verbose; 255 SYSCTL_INT(_hw_midi_stat, OID_AUTO, verbose, CTLFLAG_RW, 256 &midistat_verbose, 0, ""); 257 258 #define MIDI_DEBUG(l,a) if(midi_debug>=l) a 259 /* 260 * CODE START 261 */ 262 263 /* 264 * Register a new rmidi device. cls midi_if interface unit == 0 means 265 * auto-assign new unit number unit != 0 already assigned a unit number, eg. 266 * not the first channel provided by this device. channel, sub-unit 267 * cookie is passed back on MPU calls Typical device drivers will call with 268 * unit=0, channel=1..(number of channels) and cookie=soft_c and won't care 269 * what unit number is used. 270 * 271 * It is an error to call midi_init with an already used unit/channel combo. 272 * 273 * Returns NULL on error 274 * 275 */ 276 struct snd_midi * 277 midi_init(kobj_class_t cls, int unit, int channel, void *cookie) 278 { 279 struct snd_midi *m; 280 int i; 281 int inqsize, outqsize; 282 MIDI_TYPE *buf; 283 284 MIDI_DEBUG(1, printf("midiinit: unit %d/%d.\n", unit, channel)); 285 mtx_lock(&midistat_lock); 286 /* 287 * Protect against call with existing unit/channel or auto-allocate a 288 * new unit number. 289 */ 290 i = -1; 291 TAILQ_FOREACH(m, &midi_devs, link) { 292 mtx_lock(&m->lock); 293 if (unit != 0) { 294 if (m->unit == unit && m->channel == channel) { 295 mtx_unlock(&m->lock); 296 goto err0; 297 } 298 } else { 299 /* 300 * Find a better unit number 301 */ 302 if (m->unit > i) 303 i = m->unit; 304 } 305 mtx_unlock(&m->lock); 306 } 307 308 if (unit == 0) 309 unit = i + 1; 310 311 MIDI_DEBUG(1, printf("midiinit #2: unit %d/%d.\n", unit, channel)); 312 m = malloc(sizeof(*m), M_MIDI, M_NOWAIT | M_ZERO); 313 if (m == NULL) 314 goto err0; 315 316 m->synth = malloc(sizeof(*m->synth), M_MIDI, M_NOWAIT | M_ZERO); 317 kobj_init((kobj_t)m->synth, &midisynth_class); 318 m->synth->m = m; 319 kobj_init((kobj_t)m, cls); 320 inqsize = MPU_INQSIZE(m, cookie); 321 outqsize = MPU_OUTQSIZE(m, cookie); 322 323 MIDI_DEBUG(1, printf("midiinit queues %d/%d.\n", inqsize, outqsize)); 324 if (!inqsize && !outqsize) 325 goto err1; 326 327 mtx_init(&m->lock, "raw midi", NULL, 0); 328 mtx_init(&m->qlock, "q raw midi", NULL, 0); 329 330 mtx_lock(&m->lock); 331 mtx_lock(&m->qlock); 332 333 if (inqsize) 334 buf = malloc(sizeof(MIDI_TYPE) * inqsize, M_MIDI, M_NOWAIT); 335 else 336 buf = NULL; 337 338 MIDIQ_INIT(m->inq, buf, inqsize); 339 340 if (outqsize) 341 buf = malloc(sizeof(MIDI_TYPE) * outqsize, M_MIDI, M_NOWAIT); 342 else 343 buf = NULL; 344 m->hiwat = outqsize / 2; 345 346 MIDIQ_INIT(m->outq, buf, outqsize); 347 348 if ((inqsize && !MIDIQ_BUF(m->inq)) || 349 (outqsize && !MIDIQ_BUF(m->outq))) 350 goto err2; 351 352 353 m->busy = 0; 354 m->flags = 0; 355 m->unit = unit; 356 m->channel = channel; 357 m->cookie = cookie; 358 359 if (MPU_INIT(m, cookie)) 360 goto err2; 361 362 mtx_unlock(&m->lock); 363 mtx_unlock(&m->qlock); 364 365 TAILQ_INSERT_TAIL(&midi_devs, m, link); 366 367 mtx_unlock(&midistat_lock); 368 369 m->dev = make_dev(&midi_cdevsw, 370 MIDIMKMINOR(unit, MIDI_DEV_RAW, channel), 371 UID_ROOT, GID_WHEEL, 0666, "midi%d.%d", unit, channel); 372 m->dev->si_drv1 = m; 373 374 return m; 375 376 err2: mtx_destroy(&m->qlock); 377 mtx_destroy(&m->lock); 378 379 if (MIDIQ_BUF(m->inq)) 380 free(MIDIQ_BUF(m->inq), M_MIDI); 381 if (MIDIQ_BUF(m->outq)) 382 free(MIDIQ_BUF(m->outq), M_MIDI); 383 err1: free(m, M_MIDI); 384 err0: mtx_unlock(&midistat_lock); 385 MIDI_DEBUG(1, printf("midi_init ended in error\n")); 386 return NULL; 387 } 388 389 /* 390 * midi_uninit does not call MIDI_UNINIT, as since this is the implementors 391 * entry point. midi_unint if fact, does not send any methods. A call to 392 * midi_uninit is a defacto promise that you won't manipulate ch anymore 393 * 394 */ 395 396 int 397 midi_uninit(struct snd_midi *m) 398 { 399 int err; 400 401 err = ENXIO; 402 mtx_lock(&midistat_lock); 403 mtx_lock(&m->lock); 404 if (m->busy) { 405 if (!(m->rchan || m->wchan)) 406 goto err; 407 408 if (m->rchan) { 409 wakeup(&m->rchan); 410 m->rchan = 0; 411 } 412 if (m->wchan) { 413 wakeup(&m->wchan); 414 m->wchan = 0; 415 } 416 } 417 err = midi_destroy(m, 0); 418 if (!err) 419 goto exit; 420 421 err: mtx_unlock(&m->lock); 422 exit: mtx_unlock(&midistat_lock); 423 return err; 424 } 425 426 /* 427 * midi_in: process all data until the queue is full, then discards the rest. 428 * Since midi_in is a state machine, data discards can cause it to get out of 429 * whack. Process as much as possible. It calls, wakeup, selnotify and 430 * psignal at most once. 431 */ 432 433 #ifdef notdef 434 static int midi_lengths[] = {2, 2, 2, 2, 1, 1, 2, 0}; 435 436 #endif /* notdef */ 437 /* Number of bytes in a MIDI command */ 438 #define MIDI_LENGTH(d) (midi_lengths[((d) >> 4) & 7]) 439 #define MIDI_ACK 0xfe 440 #define MIDI_IS_STATUS(d) ((d) >= 0x80) 441 #define MIDI_IS_COMMON(d) ((d) >= 0xf0) 442 443 #define MIDI_SYSEX_START 0xF0 444 #define MIDI_SYSEX_END 0xF7 445 446 447 int 448 midi_in(struct snd_midi *m, MIDI_TYPE *buf, int size) 449 { 450 /* int i, sig, enq; */ 451 int used; 452 453 /* MIDI_TYPE data; */ 454 MIDI_DEBUG(5, printf("midi_in: m=%p size=%d\n", m, size)); 455 456 /* 457 * XXX: locking flub 458 */ 459 if (!(m->flags & M_RX)) 460 return size; 461 462 used = 0; 463 464 mtx_lock(&m->qlock); 465 #if 0 466 /* 467 * Don't bother queuing if not in read mode. Discard everything and 468 * return size so the caller doesn't freak out. 469 */ 470 471 if (!(m->flags & M_RX)) 472 return size; 473 474 for (i = sig = 0; i < size; i++) { 475 476 data = buf[i]; 477 enq = 0; 478 if (data == MIDI_ACK) 479 continue; 480 481 switch (m->inq_state) { 482 case MIDI_IN_START: 483 if (MIDI_IS_STATUS(data)) { 484 switch (data) { 485 case 0xf0: /* Sysex */ 486 m->inq_state = MIDI_IN_SYSEX; 487 break; 488 case 0xf1: /* MTC quarter frame */ 489 case 0xf3: /* Song select */ 490 m->inq_state = MIDI_IN_DATA; 491 enq = 1; 492 m->inq_left = 1; 493 break; 494 case 0xf2: /* Song position pointer */ 495 m->inq_state = MIDI_IN_DATA; 496 enq = 1; 497 m->inq_left = 2; 498 break; 499 default: 500 if (MIDI_IS_COMMON(data)) { 501 enq = 1; 502 sig = 1; 503 } else { 504 m->inq_state = MIDI_IN_DATA; 505 enq = 1; 506 m->inq_status = data; 507 m->inq_left = MIDI_LENGTH(data); 508 } 509 break; 510 } 511 } else if (MIDI_IS_STATUS(m->inq_status)) { 512 m->inq_state = MIDI_IN_DATA; 513 if (!MIDIQ_FULL(m->inq)) { 514 used++; 515 MIDIQ_ENQ(m->inq, &m->inq_status, 1); 516 } 517 enq = 1; 518 m->inq_left = MIDI_LENGTH(m->inq_status) - 1; 519 } 520 break; 521 /* 522 * End of case MIDI_IN_START: 523 */ 524 525 case MIDI_IN_DATA: 526 enq = 1; 527 if (--m->inq_left <= 0) 528 sig = 1;/* deliver data */ 529 break; 530 case MIDI_IN_SYSEX: 531 if (data == MIDI_SYSEX_END) 532 m->inq_state = MIDI_IN_START; 533 break; 534 } 535 536 if (enq) 537 if (!MIDIQ_FULL(m->inq)) { 538 MIDIQ_ENQ(m->inq, &data, 1); 539 used++; 540 } 541 /* 542 * End of the state machines main "for loop" 543 */ 544 } 545 if (sig) { 546 #endif 547 MIDI_DEBUG(6, printf("midi_in: len %jd avail %jd\n", 548 (intmax_t)MIDIQ_LEN(m->inq), 549 (intmax_t)MIDIQ_AVAIL(m->inq))); 550 if (MIDIQ_AVAIL(m->inq) > size) { 551 used = size; 552 MIDIQ_ENQ(m->inq, buf, size); 553 } else { 554 MIDI_DEBUG(4, printf("midi_in: Discarding data qu\n")); 555 mtx_unlock(&m->qlock); 556 return 0; 557 } 558 if (m->rchan) { 559 wakeup(&m->rchan); 560 m->rchan = 0; 561 } 562 selwakeup(&m->rsel); 563 if (m->async) { 564 PROC_LOCK(m->async); 565 kern_psignal(m->async, SIGIO); 566 PROC_UNLOCK(m->async); 567 } 568 #if 0 569 } 570 #endif 571 mtx_unlock(&m->qlock); 572 return used; 573 } 574 575 /* 576 * midi_out: The only clearer of the M_TXEN flag. 577 */ 578 int 579 midi_out(struct snd_midi *m, MIDI_TYPE *buf, int size) 580 { 581 int used; 582 583 /* 584 * XXX: locking flub 585 */ 586 if (!(m->flags & M_TXEN)) 587 return 0; 588 589 MIDI_DEBUG(2, printf("midi_out: %p\n", m)); 590 mtx_lock(&m->qlock); 591 used = MIN(size, MIDIQ_LEN(m->outq)); 592 MIDI_DEBUG(3, printf("midi_out: used %d\n", used)); 593 if (used) 594 MIDIQ_DEQ(m->outq, buf, used); 595 if (MIDIQ_EMPTY(m->outq)) { 596 m->flags &= ~M_TXEN; 597 MPU_CALLBACKP(m, m->cookie, m->flags); 598 } 599 if (used && MIDIQ_AVAIL(m->outq) > m->hiwat) { 600 if (m->wchan) { 601 wakeup(&m->wchan); 602 m->wchan = 0; 603 } 604 selwakeup(&m->wsel); 605 if (m->async) { 606 PROC_LOCK(m->async); 607 kern_psignal(m->async, SIGIO); 608 PROC_UNLOCK(m->async); 609 } 610 } 611 mtx_unlock(&m->qlock); 612 return used; 613 } 614 615 616 /* 617 * /dev/rmidi#.# device access functions 618 */ 619 int 620 midi_open(struct cdev *i_dev, int flags, int mode, struct thread *td) 621 { 622 struct snd_midi *m = i_dev->si_drv1; 623 int retval; 624 625 MIDI_DEBUG(1, printf("midiopen %p %s %s\n", td, 626 flags & FREAD ? "M_RX" : "", flags & FWRITE ? "M_TX" : "")); 627 if (m == NULL) 628 return ENXIO; 629 630 mtx_lock(&m->lock); 631 mtx_lock(&m->qlock); 632 633 retval = 0; 634 635 if (flags & FREAD) { 636 if (MIDIQ_SIZE(m->inq) == 0) 637 retval = ENXIO; 638 else if (m->flags & M_RX) 639 retval = EBUSY; 640 if (retval) 641 goto err; 642 } 643 if (flags & FWRITE) { 644 if (MIDIQ_SIZE(m->outq) == 0) 645 retval = ENXIO; 646 else if (m->flags & M_TX) 647 retval = EBUSY; 648 if (retval) 649 goto err; 650 } 651 m->busy++; 652 653 m->rchan = 0; 654 m->wchan = 0; 655 m->async = 0; 656 657 if (flags & FREAD) { 658 m->flags |= M_RX | M_RXEN; 659 /* 660 * Only clear the inq, the outq might still have data to drain 661 * from a previous session 662 */ 663 MIDIQ_CLEAR(m->inq); 664 }; 665 666 if (flags & FWRITE) 667 m->flags |= M_TX; 668 669 MPU_CALLBACK(m, m->cookie, m->flags); 670 671 MIDI_DEBUG(2, printf("midi_open: opened.\n")); 672 673 err: mtx_unlock(&m->qlock); 674 mtx_unlock(&m->lock); 675 return retval; 676 } 677 678 int 679 midi_close(struct cdev *i_dev, int flags, int mode, struct thread *td) 680 { 681 struct snd_midi *m = i_dev->si_drv1; 682 int retval; 683 int oldflags; 684 685 MIDI_DEBUG(1, printf("midi_close %p %s %s\n", td, 686 flags & FREAD ? "M_RX" : "", flags & FWRITE ? "M_TX" : "")); 687 688 if (m == NULL) 689 return ENXIO; 690 691 mtx_lock(&m->lock); 692 mtx_lock(&m->qlock); 693 694 if ((flags & FREAD && !(m->flags & M_RX)) || 695 (flags & FWRITE && !(m->flags & M_TX))) { 696 retval = ENXIO; 697 goto err; 698 } 699 m->busy--; 700 701 oldflags = m->flags; 702 703 if (flags & FREAD) 704 m->flags &= ~(M_RX | M_RXEN); 705 if (flags & FWRITE) 706 m->flags &= ~M_TX; 707 708 if ((m->flags & (M_TXEN | M_RXEN)) != (oldflags & (M_RXEN | M_TXEN))) 709 MPU_CALLBACK(m, m->cookie, m->flags); 710 711 MIDI_DEBUG(1, printf("midi_close: closed, busy = %d.\n", m->busy)); 712 713 mtx_unlock(&m->qlock); 714 mtx_unlock(&m->lock); 715 retval = 0; 716 err: return retval; 717 } 718 719 /* 720 * TODO: midi_read, per oss programmer's guide pg. 42 should return as soon 721 * as data is available. 722 */ 723 int 724 midi_read(struct cdev *i_dev, struct uio *uio, int ioflag) 725 { 726 #define MIDI_RSIZE 32 727 struct snd_midi *m = i_dev->si_drv1; 728 int retval; 729 int used; 730 char buf[MIDI_RSIZE]; 731 732 MIDI_DEBUG(5, printf("midiread: count=%lu\n", 733 (unsigned long)uio->uio_resid)); 734 735 retval = EIO; 736 737 if (m == NULL) 738 goto err0; 739 740 mtx_lock(&m->lock); 741 mtx_lock(&m->qlock); 742 743 if (!(m->flags & M_RX)) 744 goto err1; 745 746 while (uio->uio_resid > 0) { 747 while (MIDIQ_EMPTY(m->inq)) { 748 retval = EWOULDBLOCK; 749 if (ioflag & O_NONBLOCK) 750 goto err1; 751 mtx_unlock(&m->lock); 752 m->rchan = 1; 753 retval = msleep(&m->rchan, &m->qlock, 754 PCATCH | PDROP, "midi RX", 0); 755 /* 756 * We slept, maybe things have changed since last 757 * dying check 758 */ 759 if (retval == EINTR) 760 goto err0; 761 if (m != i_dev->si_drv1) 762 retval = ENXIO; 763 /* if (retval && retval != ERESTART) */ 764 if (retval) 765 goto err0; 766 mtx_lock(&m->lock); 767 mtx_lock(&m->qlock); 768 m->rchan = 0; 769 if (!m->busy) 770 goto err1; 771 } 772 MIDI_DEBUG(6, printf("midi_read start\n")); 773 /* 774 * At this point, it is certain that m->inq has data 775 */ 776 777 used = MIN(MIDIQ_LEN(m->inq), uio->uio_resid); 778 used = MIN(used, MIDI_RSIZE); 779 780 MIDI_DEBUG(6, printf("midiread: uiomove cc=%d\n", used)); 781 MIDIQ_DEQ(m->inq, buf, used); 782 retval = uiomove(buf, used, uio); 783 if (retval) 784 goto err1; 785 } 786 787 /* 788 * If we Made it here then transfer is good 789 */ 790 retval = 0; 791 err1: mtx_unlock(&m->qlock); 792 mtx_unlock(&m->lock); 793 err0: MIDI_DEBUG(4, printf("midi_read: ret %d\n", retval)); 794 return retval; 795 } 796 797 /* 798 * midi_write: The only setter of M_TXEN 799 */ 800 801 int 802 midi_write(struct cdev *i_dev, struct uio *uio, int ioflag) 803 { 804 #define MIDI_WSIZE 32 805 struct snd_midi *m = i_dev->si_drv1; 806 int retval; 807 int used; 808 char buf[MIDI_WSIZE]; 809 810 811 MIDI_DEBUG(4, printf("midi_write\n")); 812 retval = 0; 813 if (m == NULL) 814 goto err0; 815 816 mtx_lock(&m->lock); 817 mtx_lock(&m->qlock); 818 819 if (!(m->flags & M_TX)) 820 goto err1; 821 822 while (uio->uio_resid > 0) { 823 while (MIDIQ_AVAIL(m->outq) == 0) { 824 retval = EWOULDBLOCK; 825 if (ioflag & O_NONBLOCK) 826 goto err1; 827 mtx_unlock(&m->lock); 828 m->wchan = 1; 829 MIDI_DEBUG(3, printf("midi_write msleep\n")); 830 retval = msleep(&m->wchan, &m->qlock, 831 PCATCH | PDROP, "midi TX", 0); 832 /* 833 * We slept, maybe things have changed since last 834 * dying check 835 */ 836 if (retval == EINTR) 837 goto err0; 838 if (m != i_dev->si_drv1) 839 retval = ENXIO; 840 if (retval) 841 goto err0; 842 mtx_lock(&m->lock); 843 mtx_lock(&m->qlock); 844 m->wchan = 0; 845 if (!m->busy) 846 goto err1; 847 } 848 849 /* 850 * We are certain than data can be placed on the queue 851 */ 852 853 used = MIN(MIDIQ_AVAIL(m->outq), uio->uio_resid); 854 used = MIN(used, MIDI_WSIZE); 855 MIDI_DEBUG(5, printf("midiout: resid %zd len %jd avail %jd\n", 856 uio->uio_resid, (intmax_t)MIDIQ_LEN(m->outq), 857 (intmax_t)MIDIQ_AVAIL(m->outq))); 858 859 860 MIDI_DEBUG(5, printf("midi_write: uiomove cc=%d\n", used)); 861 retval = uiomove(buf, used, uio); 862 if (retval) 863 goto err1; 864 MIDIQ_ENQ(m->outq, buf, used); 865 /* 866 * Inform the bottom half that data can be written 867 */ 868 if (!(m->flags & M_TXEN)) { 869 m->flags |= M_TXEN; 870 MPU_CALLBACK(m, m->cookie, m->flags); 871 } 872 } 873 /* 874 * If we Made it here then transfer is good 875 */ 876 retval = 0; 877 err1: mtx_unlock(&m->qlock); 878 mtx_unlock(&m->lock); 879 err0: return retval; 880 } 881 882 int 883 midi_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode, 884 struct thread *td) 885 { 886 return ENXIO; 887 } 888 889 int 890 midi_poll(struct cdev *i_dev, int events, struct thread *td) 891 { 892 struct snd_midi *m = i_dev->si_drv1; 893 int revents; 894 895 if (m == NULL) 896 return 0; 897 898 revents = 0; 899 900 mtx_lock(&m->lock); 901 mtx_lock(&m->qlock); 902 903 if (events & (POLLIN | POLLRDNORM)) 904 if (!MIDIQ_EMPTY(m->inq)) 905 events |= events & (POLLIN | POLLRDNORM); 906 907 if (events & (POLLOUT | POLLWRNORM)) 908 if (MIDIQ_AVAIL(m->outq) < m->hiwat) 909 events |= events & (POLLOUT | POLLWRNORM); 910 911 if (revents == 0) { 912 if (events & (POLLIN | POLLRDNORM)) 913 selrecord(td, &m->rsel); 914 915 if (events & (POLLOUT | POLLWRNORM)) 916 selrecord(td, &m->wsel); 917 } 918 mtx_unlock(&m->lock); 919 mtx_unlock(&m->qlock); 920 921 return (revents); 922 } 923 924 /* 925 * /dev/midistat device functions 926 * 927 */ 928 static int 929 midistat_open(struct cdev *i_dev, int flags, int mode, struct thread *td) 930 { 931 int error; 932 933 MIDI_DEBUG(1, printf("midistat_open\n")); 934 mtx_lock(&midistat_lock); 935 936 if (midistat_isopen) { 937 mtx_unlock(&midistat_lock); 938 return EBUSY; 939 } 940 midistat_isopen = 1; 941 mtx_unlock(&midistat_lock); 942 943 if (sbuf_new(&midistat_sbuf, NULL, 4096, SBUF_AUTOEXTEND) == NULL) { 944 error = ENXIO; 945 mtx_lock(&midistat_lock); 946 goto out; 947 } 948 mtx_lock(&midistat_lock); 949 midistat_bufptr = 0; 950 error = (midistat_prepare(&midistat_sbuf) > 0) ? 0 : ENOMEM; 951 952 out: if (error) 953 midistat_isopen = 0; 954 mtx_unlock(&midistat_lock); 955 return error; 956 } 957 958 static int 959 midistat_close(struct cdev *i_dev, int flags, int mode, struct thread *td) 960 { 961 MIDI_DEBUG(1, printf("midistat_close\n")); 962 mtx_lock(&midistat_lock); 963 if (!midistat_isopen) { 964 mtx_unlock(&midistat_lock); 965 return EBADF; 966 } 967 sbuf_delete(&midistat_sbuf); 968 midistat_isopen = 0; 969 970 mtx_unlock(&midistat_lock); 971 return 0; 972 } 973 974 static int 975 midistat_read(struct cdev *i_dev, struct uio *buf, int flag) 976 { 977 int l, err; 978 979 MIDI_DEBUG(4, printf("midistat_read\n")); 980 mtx_lock(&midistat_lock); 981 if (!midistat_isopen) { 982 mtx_unlock(&midistat_lock); 983 return EBADF; 984 } 985 l = min(buf->uio_resid, sbuf_len(&midistat_sbuf) - midistat_bufptr); 986 err = 0; 987 if (l > 0) { 988 mtx_unlock(&midistat_lock); 989 err = uiomove(sbuf_data(&midistat_sbuf) + midistat_bufptr, l, 990 buf); 991 mtx_lock(&midistat_lock); 992 } else 993 l = 0; 994 midistat_bufptr += l; 995 mtx_unlock(&midistat_lock); 996 return err; 997 } 998 999 /* 1000 * Module library functions 1001 */ 1002 1003 static int 1004 midistat_prepare(struct sbuf *s) 1005 { 1006 struct snd_midi *m; 1007 1008 mtx_assert(&midistat_lock, MA_OWNED); 1009 1010 sbuf_printf(s, "FreeBSD Midi Driver (midi2)\n"); 1011 if (TAILQ_EMPTY(&midi_devs)) { 1012 sbuf_printf(s, "No devices installed.\n"); 1013 sbuf_finish(s); 1014 return sbuf_len(s); 1015 } 1016 sbuf_printf(s, "Installed devices:\n"); 1017 1018 TAILQ_FOREACH(m, &midi_devs, link) { 1019 mtx_lock(&m->lock); 1020 sbuf_printf(s, "%s [%d/%d:%s]", m->name, m->unit, m->channel, 1021 MPU_PROVIDER(m, m->cookie)); 1022 sbuf_printf(s, "%s", MPU_DESCR(m, m->cookie, midistat_verbose)); 1023 sbuf_printf(s, "\n"); 1024 mtx_unlock(&m->lock); 1025 } 1026 1027 sbuf_finish(s); 1028 return sbuf_len(s); 1029 } 1030 1031 #ifdef notdef 1032 /* 1033 * Convert IOCTL command to string for debugging 1034 */ 1035 1036 static char * 1037 midi_cmdname(int cmd) 1038 { 1039 static struct { 1040 int cmd; 1041 char *name; 1042 } *tab, cmdtab_midiioctl[] = { 1043 #define A(x) {x, ## x} 1044 /* 1045 * Once we have some real IOCTLs define, the following will 1046 * be relavant. 1047 * 1048 * A(SNDCTL_MIDI_PRETIME), A(SNDCTL_MIDI_MPUMODE), 1049 * A(SNDCTL_MIDI_MPUCMD), A(SNDCTL_SYNTH_INFO), 1050 * A(SNDCTL_MIDI_INFO), A(SNDCTL_SYNTH_MEMAVL), 1051 * A(SNDCTL_FM_LOAD_INSTR), A(SNDCTL_FM_4OP_ENABLE), 1052 * A(MIOSPASSTHRU), A(MIOGPASSTHRU), A(AIONWRITE), 1053 * A(AIOGSIZE), A(AIOSSIZE), A(AIOGFMT), A(AIOSFMT), 1054 * A(AIOGMIX), A(AIOSMIX), A(AIOSTOP), A(AIOSYNC), 1055 * A(AIOGCAP), 1056 */ 1057 #undef A 1058 { 1059 -1, "unknown" 1060 }, 1061 }; 1062 1063 for (tab = cmdtab_midiioctl; tab->cmd != cmd && tab->cmd != -1; tab++); 1064 return tab->name; 1065 } 1066 1067 #endif /* notdef */ 1068 1069 /* 1070 * midisynth 1071 */ 1072 1073 1074 int 1075 midisynth_open(void *n, void *arg, int flags) 1076 { 1077 struct snd_midi *m = ((struct synth_midi *)n)->m; 1078 int retval; 1079 1080 MIDI_DEBUG(1, printf("midisynth_open %s %s\n", 1081 flags & FREAD ? "M_RX" : "", flags & FWRITE ? "M_TX" : "")); 1082 1083 if (m == NULL) 1084 return ENXIO; 1085 1086 mtx_lock(&m->lock); 1087 mtx_lock(&m->qlock); 1088 1089 retval = 0; 1090 1091 if (flags & FREAD) { 1092 if (MIDIQ_SIZE(m->inq) == 0) 1093 retval = ENXIO; 1094 else if (m->flags & M_RX) 1095 retval = EBUSY; 1096 if (retval) 1097 goto err; 1098 } 1099 if (flags & FWRITE) { 1100 if (MIDIQ_SIZE(m->outq) == 0) 1101 retval = ENXIO; 1102 else if (m->flags & M_TX) 1103 retval = EBUSY; 1104 if (retval) 1105 goto err; 1106 } 1107 m->busy++; 1108 1109 /* 1110 * TODO: Consider m->async = 0; 1111 */ 1112 1113 if (flags & FREAD) { 1114 m->flags |= M_RX | M_RXEN; 1115 /* 1116 * Only clear the inq, the outq might still have data to drain 1117 * from a previous session 1118 */ 1119 MIDIQ_CLEAR(m->inq); 1120 m->rchan = 0; 1121 }; 1122 1123 if (flags & FWRITE) { 1124 m->flags |= M_TX; 1125 m->wchan = 0; 1126 } 1127 m->synth_flags = flags & (FREAD | FWRITE); 1128 1129 MPU_CALLBACK(m, m->cookie, m->flags); 1130 1131 1132 err: mtx_unlock(&m->qlock); 1133 mtx_unlock(&m->lock); 1134 MIDI_DEBUG(2, printf("midisynth_open: return %d.\n", retval)); 1135 return retval; 1136 } 1137 1138 int 1139 midisynth_close(void *n) 1140 { 1141 struct snd_midi *m = ((struct synth_midi *)n)->m; 1142 int retval; 1143 int oldflags; 1144 1145 MIDI_DEBUG(1, printf("midisynth_close %s %s\n", 1146 m->synth_flags & FREAD ? "M_RX" : "", 1147 m->synth_flags & FWRITE ? "M_TX" : "")); 1148 1149 if (m == NULL) 1150 return ENXIO; 1151 1152 mtx_lock(&m->lock); 1153 mtx_lock(&m->qlock); 1154 1155 if ((m->synth_flags & FREAD && !(m->flags & M_RX)) || 1156 (m->synth_flags & FWRITE && !(m->flags & M_TX))) { 1157 retval = ENXIO; 1158 goto err; 1159 } 1160 m->busy--; 1161 1162 oldflags = m->flags; 1163 1164 if (m->synth_flags & FREAD) 1165 m->flags &= ~(M_RX | M_RXEN); 1166 if (m->synth_flags & FWRITE) 1167 m->flags &= ~M_TX; 1168 1169 if ((m->flags & (M_TXEN | M_RXEN)) != (oldflags & (M_RXEN | M_TXEN))) 1170 MPU_CALLBACK(m, m->cookie, m->flags); 1171 1172 MIDI_DEBUG(1, printf("midi_close: closed, busy = %d.\n", m->busy)); 1173 1174 mtx_unlock(&m->qlock); 1175 mtx_unlock(&m->lock); 1176 retval = 0; 1177 err: return retval; 1178 } 1179 1180 /* 1181 * Always blocking. 1182 */ 1183 1184 int 1185 midisynth_writeraw(void *n, uint8_t *buf, size_t len) 1186 { 1187 struct snd_midi *m = ((struct synth_midi *)n)->m; 1188 int retval; 1189 int used; 1190 int i; 1191 1192 MIDI_DEBUG(4, printf("midisynth_writeraw\n")); 1193 1194 retval = 0; 1195 1196 if (m == NULL) 1197 return ENXIO; 1198 1199 mtx_lock(&m->lock); 1200 mtx_lock(&m->qlock); 1201 1202 if (!(m->flags & M_TX)) 1203 goto err1; 1204 1205 if (midi_dumpraw) 1206 printf("midi dump: "); 1207 1208 while (len > 0) { 1209 while (MIDIQ_AVAIL(m->outq) == 0) { 1210 if (!(m->flags & M_TXEN)) { 1211 m->flags |= M_TXEN; 1212 MPU_CALLBACK(m, m->cookie, m->flags); 1213 } 1214 mtx_unlock(&m->lock); 1215 m->wchan = 1; 1216 MIDI_DEBUG(3, printf("midisynth_writeraw msleep\n")); 1217 retval = msleep(&m->wchan, &m->qlock, 1218 PCATCH | PDROP, "midi TX", 0); 1219 /* 1220 * We slept, maybe things have changed since last 1221 * dying check 1222 */ 1223 if (retval == EINTR) 1224 goto err0; 1225 1226 if (retval) 1227 goto err0; 1228 mtx_lock(&m->lock); 1229 mtx_lock(&m->qlock); 1230 m->wchan = 0; 1231 if (!m->busy) 1232 goto err1; 1233 } 1234 1235 /* 1236 * We are certain than data can be placed on the queue 1237 */ 1238 1239 used = MIN(MIDIQ_AVAIL(m->outq), len); 1240 used = MIN(used, MIDI_WSIZE); 1241 MIDI_DEBUG(5, 1242 printf("midi_synth: resid %zu len %jd avail %jd\n", 1243 len, (intmax_t)MIDIQ_LEN(m->outq), 1244 (intmax_t)MIDIQ_AVAIL(m->outq))); 1245 1246 if (midi_dumpraw) 1247 for (i = 0; i < used; i++) 1248 printf("%x ", buf[i]); 1249 1250 MIDIQ_ENQ(m->outq, buf, used); 1251 len -= used; 1252 1253 /* 1254 * Inform the bottom half that data can be written 1255 */ 1256 if (!(m->flags & M_TXEN)) { 1257 m->flags |= M_TXEN; 1258 MPU_CALLBACK(m, m->cookie, m->flags); 1259 } 1260 } 1261 /* 1262 * If we Made it here then transfer is good 1263 */ 1264 if (midi_dumpraw) 1265 printf("\n"); 1266 1267 retval = 0; 1268 err1: mtx_unlock(&m->qlock); 1269 mtx_unlock(&m->lock); 1270 err0: return retval; 1271 } 1272 1273 static int 1274 midisynth_killnote(void *n, uint8_t chn, uint8_t note, uint8_t vel) 1275 { 1276 u_char c[3]; 1277 1278 1279 if (note > 127 || chn > 15) 1280 return (EINVAL); 1281 1282 if (vel > 127) 1283 vel = 127; 1284 1285 if (vel == 64) { 1286 c[0] = 0x90 | (chn & 0x0f); /* Note on. */ 1287 c[1] = (u_char)note; 1288 c[2] = 0; 1289 } else { 1290 c[0] = 0x80 | (chn & 0x0f); /* Note off. */ 1291 c[1] = (u_char)note; 1292 c[2] = (u_char)vel; 1293 } 1294 1295 return midisynth_writeraw(n, c, 3); 1296 } 1297 1298 static int 1299 midisynth_setinstr(void *n, uint8_t chn, uint16_t instr) 1300 { 1301 u_char c[2]; 1302 1303 if (instr > 127 || chn > 15) 1304 return EINVAL; 1305 1306 c[0] = 0xc0 | (chn & 0x0f); /* Progamme change. */ 1307 c[1] = instr + midi_instroff; 1308 1309 return midisynth_writeraw(n, c, 2); 1310 } 1311 1312 static int 1313 midisynth_startnote(void *n, uint8_t chn, uint8_t note, uint8_t vel) 1314 { 1315 u_char c[3]; 1316 1317 if (note > 127 || chn > 15) 1318 return EINVAL; 1319 1320 if (vel > 127) 1321 vel = 127; 1322 1323 c[0] = 0x90 | (chn & 0x0f); /* Note on. */ 1324 c[1] = (u_char)note; 1325 c[2] = (u_char)vel; 1326 1327 return midisynth_writeraw(n, c, 3); 1328 } 1329 static int 1330 midisynth_alloc(void *n, uint8_t chan, uint8_t note) 1331 { 1332 return chan; 1333 } 1334 1335 static int 1336 midisynth_controller(void *n, uint8_t chn, uint8_t ctrlnum, uint16_t val) 1337 { 1338 u_char c[3]; 1339 1340 if (ctrlnum > 127 || chn > 15) 1341 return EINVAL; 1342 1343 c[0] = 0xb0 | (chn & 0x0f); /* Control Message. */ 1344 c[1] = ctrlnum; 1345 c[2] = val; 1346 return midisynth_writeraw(n, c, 3); 1347 } 1348 1349 static int 1350 midisynth_bender(void *n, uint8_t chn, uint16_t val) 1351 { 1352 u_char c[3]; 1353 1354 1355 if (val > 16383 || chn > 15) 1356 return EINVAL; 1357 1358 c[0] = 0xe0 | (chn & 0x0f); /* Pitch bend. */ 1359 c[1] = (u_char)val & 0x7f; 1360 c[2] = (u_char)(val >> 7) & 0x7f; 1361 1362 return midisynth_writeraw(n, c, 3); 1363 } 1364 1365 /* 1366 * Single point of midi destructions. 1367 */ 1368 static int 1369 midi_destroy(struct snd_midi *m, int midiuninit) 1370 { 1371 1372 mtx_assert(&midistat_lock, MA_OWNED); 1373 mtx_assert(&m->lock, MA_OWNED); 1374 1375 MIDI_DEBUG(3, printf("midi_destroy\n")); 1376 m->dev->si_drv1 = NULL; 1377 mtx_unlock(&m->lock); /* XXX */ 1378 destroy_dev(m->dev); 1379 TAILQ_REMOVE(&midi_devs, m, link); 1380 if (midiuninit) 1381 MPU_UNINIT(m, m->cookie); 1382 free(MIDIQ_BUF(m->inq), M_MIDI); 1383 free(MIDIQ_BUF(m->outq), M_MIDI); 1384 mtx_destroy(&m->qlock); 1385 mtx_destroy(&m->lock); 1386 free(m, M_MIDI); 1387 return 0; 1388 } 1389 1390 /* 1391 * Load and unload functions, creates the /dev/midistat device 1392 */ 1393 1394 static int 1395 midi_load() 1396 { 1397 mtx_init(&midistat_lock, "midistat lock", NULL, 0); 1398 TAILQ_INIT(&midi_devs); /* Initialize the queue. */ 1399 1400 midistat_dev = make_dev(&midistat_cdevsw, 1401 MIDIMKMINOR(0, MIDI_DEV_MIDICTL, 0), 1402 UID_ROOT, GID_WHEEL, 0666, "midistat"); 1403 1404 return 0; 1405 } 1406 1407 static int 1408 midi_unload() 1409 { 1410 struct snd_midi *m; 1411 int retval; 1412 1413 MIDI_DEBUG(1, printf("midi_unload()\n")); 1414 retval = EBUSY; 1415 mtx_lock(&midistat_lock); 1416 if (midistat_isopen) 1417 goto exit0; 1418 1419 TAILQ_FOREACH(m, &midi_devs, link) { 1420 mtx_lock(&m->lock); 1421 if (m->busy) 1422 retval = EBUSY; 1423 else 1424 retval = midi_destroy(m, 1); 1425 if (retval) 1426 goto exit1; 1427 } 1428 1429 mtx_unlock(&midistat_lock); /* XXX */ 1430 1431 destroy_dev(midistat_dev); 1432 /* 1433 * Made it here then unload is complete 1434 */ 1435 mtx_destroy(&midistat_lock); 1436 return 0; 1437 1438 exit1: 1439 mtx_unlock(&m->lock); 1440 exit0: 1441 mtx_unlock(&midistat_lock); 1442 if (retval) 1443 MIDI_DEBUG(2, printf("midi_unload: failed\n")); 1444 return retval; 1445 } 1446 1447 extern int seq_modevent(module_t mod, int type, void *data); 1448 1449 static int 1450 midi_modevent(module_t mod, int type, void *data) 1451 { 1452 int retval; 1453 1454 retval = 0; 1455 1456 switch (type) { 1457 case MOD_LOAD: 1458 retval = midi_load(); 1459 #if 0 1460 if (retval == 0) 1461 retval = seq_modevent(mod, type, data); 1462 #endif 1463 break; 1464 1465 case MOD_UNLOAD: 1466 retval = midi_unload(); 1467 #if 0 1468 if (retval == 0) 1469 retval = seq_modevent(mod, type, data); 1470 #endif 1471 break; 1472 1473 default: 1474 break; 1475 } 1476 1477 return retval; 1478 } 1479 1480 kobj_t 1481 midimapper_addseq(void *arg1, int *unit, void **cookie) 1482 { 1483 unit = 0; 1484 1485 return (kobj_t)arg1; 1486 } 1487 1488 int 1489 midimapper_open(void *arg1, void **cookie) 1490 { 1491 int retval = 0; 1492 struct snd_midi *m; 1493 1494 mtx_lock(&midistat_lock); 1495 1496 TAILQ_FOREACH(m, &midi_devs, link) { 1497 retval++; 1498 } 1499 1500 mtx_unlock(&midistat_lock); 1501 return retval; 1502 } 1503 1504 int 1505 midimapper_close(void *arg1, void *cookie) 1506 { 1507 return 0; 1508 } 1509 1510 kobj_t 1511 midimapper_fetch_synth(void *arg, void *cookie, int unit) 1512 { 1513 struct snd_midi *m; 1514 int retval = 0; 1515 1516 mtx_lock(&midistat_lock); 1517 1518 TAILQ_FOREACH(m, &midi_devs, link) { 1519 if (unit == retval) { 1520 mtx_unlock(&midistat_lock); 1521 return (kobj_t)m->synth; 1522 } 1523 retval++; 1524 } 1525 1526 mtx_unlock(&midistat_lock); 1527 return NULL; 1528 } 1529 1530 DEV_MODULE(midi, midi_modevent, NULL); 1531 MODULE_VERSION(midi, 1); 1532