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