1 /* $NetBSD: midi.c,v 1.101 2022/10/23 23:03:30 riastradh Exp $ */
2
3 /*
4 * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (augustss@NetBSD.org), (MIDI FST and Active
9 * Sense handling) Chapman Flack (chap@NetBSD.org), and Andrew Doran.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: midi.c,v 1.101 2022/10/23 23:03:30 riastradh Exp $");
35
36 #ifdef _KERNEL_OPT
37 #include "midi.h"
38 #endif
39
40 #include <sys/param.h>
41 #include <sys/ioctl.h>
42 #include <sys/fcntl.h>
43 #include <sys/vnode.h>
44 #include <sys/select.h>
45 #include <sys/poll.h>
46 #include <sys/proc.h>
47 #include <sys/systm.h>
48 #include <sys/callout.h>
49 #include <sys/syslog.h>
50 #include <sys/kernel.h>
51 #include <sys/signalvar.h>
52 #include <sys/conf.h>
53 #include <sys/audioio.h>
54 #include <sys/midiio.h>
55 #include <sys/device.h>
56 #include <sys/intr.h>
57 #include <sys/module.h>
58
59 #include <dev/audio/audio_if.h>
60 #include <dev/midi_if.h>
61 #include <dev/midivar.h>
62
63 #include "ioconf.h"
64
65 #if NMIDI > 0
66
67 #ifdef AUDIO_DEBUG
68 #define DPRINTF(x) if (mididebug) printf x
69 #define DPRINTFN(n,x) if (mididebug >= (n)) printf x
70 int mididebug = 0;
71 /*
72 * 1: detected protocol errors and buffer overflows
73 * 2: probe, attach, detach
74 * 3: open, close
75 * 4: data received except realtime
76 * 5: ioctl
77 * 6: read, write, poll
78 * 7: data transmitted
79 * 8: uiomoves, synchronization
80 * 9: realtime data received
81 */
82 #else
83 #define DPRINTF(x)
84 #define DPRINTFN(n,x)
85 #endif
86
87 static struct midi_softc *hwif_softc = NULL;
88 static kmutex_t hwif_softc_lock;
89
90 static void midi_in(void *, int);
91 static void midi_out(void *);
92 static int midi_poll_out(struct midi_softc *);
93 static int midi_intr_out(struct midi_softc *);
94 static int midi_msg_out(struct midi_softc *, u_char **, u_char **,
95 u_char **, u_char **);
96 static int midi_start_output(struct midi_softc *);
97 static void midi_initbuf(struct midi_buffer *);
98 static void midi_xmt_asense(void *);
99 static void midi_rcv_asense(void *);
100 static void midi_softint(void *);
101
102 static int midiprobe(device_t, cfdata_t, void *);
103 static void midiattach(device_t, device_t, void *);
104 int mididetach(device_t, int);
105 static int midiactivate(device_t, enum devact);
106
107 static dev_type_open(midiopen);
108 static dev_type_close(midiclose);
109 static dev_type_read(midiread);
110 static dev_type_write(midiwrite);
111 static dev_type_ioctl(midiioctl);
112 static dev_type_poll(midipoll);
113 static dev_type_kqfilter(midikqfilter);
114
115 const struct cdevsw midi_cdevsw = {
116 .d_open = midiopen,
117 .d_close = midiclose,
118 .d_read = midiread,
119 .d_write = midiwrite,
120 .d_ioctl = midiioctl,
121 .d_stop = nostop,
122 .d_tty = notty,
123 .d_poll = midipoll,
124 .d_mmap = nommap,
125 .d_kqfilter = midikqfilter,
126 .d_discard = nodiscard,
127 .d_flag = D_OTHER | D_MPSAFE
128 };
129
130 CFATTACH_DECL_NEW(midi, sizeof(struct midi_softc),
131 midiprobe, midiattach, mididetach, midiactivate);
132
133 #define MIDI_XMT_ASENSE_PERIOD mstohz(275)
134 #define MIDI_RCV_ASENSE_PERIOD mstohz(300)
135
136 static int
midiprobe(device_t parent,cfdata_t match,void * aux)137 midiprobe(device_t parent, cfdata_t match, void *aux)
138 {
139 struct audio_attach_args *sa;
140
141 sa = aux;
142
143 DPRINTFN(2,("midiprobe: type=%d sa=%p hw=%p\n", sa->type, sa,
144 sa->hwif));
145
146 return sa->type == AUDIODEV_TYPE_MIDI;
147 }
148
149 static void
midiattach(device_t parent,device_t self,void * aux)150 midiattach(device_t parent, device_t self, void *aux)
151 {
152 struct midi_softc *sc = device_private(self);
153 struct audio_attach_args *sa = aux;
154 const struct midi_hw_if *hwp;
155 void *hdlp;
156
157 hwp = sa->hwif;
158 hdlp = sa->hdl;
159
160 aprint_naive("\n");
161
162 DPRINTFN(2, ("MIDI attach\n"));
163
164 #ifdef DIAGNOSTIC
165 if (hwp == 0 ||
166 hwp->open == 0 ||
167 hwp->close == 0 ||
168 hwp->output == 0 ||
169 hwp->getinfo == 0) {
170 aprint_error_dev(self, "missing method\n");
171 return;
172 }
173 #endif
174
175 sc->dev = self;
176 sc->hw_if = hwp;
177 sc->hw_hdl = hdlp;
178 midi_attach(sc);
179 }
180
181 static int
midiactivate(device_t self,enum devact act)182 midiactivate(device_t self, enum devact act)
183 {
184 struct midi_softc *sc = device_private(self);
185
186 switch (act) {
187 case DVACT_DEACTIVATE:
188 mutex_enter(sc->lock);
189 sc->dying = 1;
190 mutex_exit(sc->lock);
191 return 0;
192 default:
193 return EOPNOTSUPP;
194 }
195 }
196
197 int
mididetach(device_t self,int flags)198 mididetach(device_t self, int flags)
199 {
200 struct midi_softc *sc = device_private(self);
201 int maj, mn;
202
203 DPRINTFN(2,("%s: sc=%p flags=%d\n", __func__, sc, flags));
204
205 pmf_device_deregister(self);
206
207 mutex_enter(sc->lock);
208 sc->dying = 1;
209 cv_broadcast(&sc->wchan);
210 cv_broadcast(&sc->rchan);
211
212 if (--sc->refcnt >= 0) {
213 (void)cv_timedwait(&sc->detach_cv, sc->lock, hz * 60);
214 if (sc->refcnt >= 0) {
215 aprint_error_dev(self, "refcnt failed to drain,"
216 " bashing my brains out anyway\n");
217 }
218 }
219 mutex_exit(sc->lock);
220
221 /* locate the major number */
222 maj = cdevsw_lookup_major(&midi_cdevsw);
223
224 /*
225 * Nuke the vnodes for any open instances (calls close).
226 * Will wait until any activity on the device nodes has ceased.
227 *
228 * XXXAD NOT YET.
229 *
230 * XXXAD NEED TO PREVENT NEW REFERENCES THROUGH AUDIO_ENTER().
231 */
232 mn = device_unit(self);
233 vdevgone(maj, mn, mn, VCHR);
234
235 if (!(sc->props & MIDI_PROP_NO_OUTPUT)) {
236 evcnt_detach(&sc->xmt.bytesDiscarded);
237 evcnt_detach(&sc->xmt.incompleteMessages);
238 }
239 if (sc->props & MIDI_PROP_CAN_INPUT) {
240 evcnt_detach(&sc->rcv.bytesDiscarded);
241 evcnt_detach(&sc->rcv.incompleteMessages);
242 }
243
244 if (sc->sih != NULL) {
245 softint_disestablish(sc->sih);
246 sc->sih = NULL;
247 }
248
249 callout_halt(&sc->xmt_asense_co, NULL);
250 callout_halt(&sc->rcv_asense_co, NULL);
251
252 callout_destroy(&sc->xmt_asense_co);
253 callout_destroy(&sc->rcv_asense_co);
254
255 cv_destroy(&sc->wchan);
256 cv_destroy(&sc->rchan);
257 cv_destroy(&sc->detach_cv);
258
259 return (0);
260 }
261
262 void
midi_attach(struct midi_softc * sc)263 midi_attach(struct midi_softc *sc)
264 {
265 struct midi_info mi;
266 kmutex_t *dummy;
267 static int first = 1;
268
269 if (first) {
270 mutex_init(&hwif_softc_lock, MUTEX_DEFAULT, IPL_NONE);
271 first = 0;
272 }
273
274 sc->hw_if->get_locks(sc->hw_hdl, &sc->lock, &dummy);
275
276 callout_init(&sc->xmt_asense_co, CALLOUT_MPSAFE);
277 callout_init(&sc->rcv_asense_co, CALLOUT_MPSAFE);
278 callout_setfunc(&sc->xmt_asense_co, midi_xmt_asense, sc);
279 callout_setfunc(&sc->rcv_asense_co, midi_rcv_asense, sc);
280
281 sc->sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE,
282 midi_softint, sc);
283
284 cv_init(&sc->rchan, "midird");
285 cv_init(&sc->wchan, "midiwr");
286 cv_init(&sc->detach_cv, "mididet");
287
288 sc->dying = 0;
289 sc->isopen = 0;
290 sc->refcnt = 0;
291
292 mutex_enter(&hwif_softc_lock);
293 mutex_enter(sc->lock);
294 hwif_softc = sc;
295 sc->hw_if->getinfo(sc->hw_hdl, &mi);
296 hwif_softc = NULL;
297 mutex_exit(sc->lock);
298 mutex_exit(&hwif_softc_lock);
299
300 sc->props = mi.props;
301
302 if (!(sc->props & MIDI_PROP_NO_OUTPUT)) {
303 evcnt_attach_dynamic(&sc->xmt.bytesDiscarded,
304 EVCNT_TYPE_MISC, NULL,
305 device_xname(sc->dev), "xmt bytes discarded");
306 evcnt_attach_dynamic(&sc->xmt.incompleteMessages,
307 EVCNT_TYPE_MISC, NULL,
308 device_xname(sc->dev), "xmt incomplete msgs");
309 }
310 if (sc->props & MIDI_PROP_CAN_INPUT) {
311 evcnt_attach_dynamic(&sc->rcv.bytesDiscarded,
312 EVCNT_TYPE_MISC, NULL,
313 device_xname(sc->dev), "rcv bytes discarded");
314 evcnt_attach_dynamic(&sc->rcv.incompleteMessages,
315 EVCNT_TYPE_MISC, NULL,
316 device_xname(sc->dev), "rcv incomplete msgs");
317 }
318
319 aprint_naive("\n");
320 aprint_normal(": %s\n", mi.name);
321
322 if (!pmf_device_register(sc->dev, NULL, NULL))
323 aprint_error_dev(sc->dev, "couldn't establish power handler\n");
324 }
325
326 void
midi_register_hw_if_ext(struct midi_hw_if_ext * exthw)327 midi_register_hw_if_ext(struct midi_hw_if_ext *exthw)
328 {
329 if (hwif_softc != NULL) /* ignore calls resulting from non-init */
330 hwif_softc->hw_if_ext = exthw; /* uses of getinfo */
331 }
332
333 int
midi_unit_count(void)334 midi_unit_count(void)
335 {
336 int i;
337 for ( i = 0; i < midi_cd.cd_ndevs; ++i)
338 if (NULL == device_lookup(&midi_cd, i))
339 break;
340 return i;
341 }
342
343 static void
midi_initbuf(struct midi_buffer * mb)344 midi_initbuf(struct midi_buffer *mb)
345 {
346 mb->idx_producerp = mb->idx_consumerp = mb->idx;
347 mb->buf_producerp = mb->buf_consumerp = mb->buf;
348 }
349
350 #define PACK_MB_IDX(cat,len) (((cat)<<4)|(len))
351 #define MB_IDX_CAT(idx) ((idx)>>4)
352 #define MB_IDX_LEN(idx) ((idx)&0xf)
353
354 static char const midi_cats[] = "\0\0\0\0\0\0\0\0\2\2\2\2\1\1\2\3";
355 #define MIDI_CAT(d) (midi_cats[((d)>>4)&15])
356 #define FST_RETURN(offp,endp,ret) \
357 return (s->pos=s->msg+(offp)), (s->end=s->msg+(endp)), (ret)
358
359 enum fst_ret { FST_CHN, FST_CHV, FST_COM, FST_SYX, FST_RT, FST_MORE, FST_ERR,
360 FST_HUH, FST_SXP };
361 enum fst_form { FST_CANON, FST_COMPR, FST_VCOMP };
362 static struct {
363 int off;
364 enum fst_ret tag;
365 } const midi_forms[] = {
366 [FST_CANON] = { .off=0, .tag=FST_CHN },
367 [FST_COMPR] = { .off=1, .tag=FST_CHN },
368 [FST_VCOMP] = { .off=0, .tag=FST_CHV }
369 };
370 #define FST_CRETURN(endp) \
371 FST_RETURN(midi_forms[form].off,endp,midi_forms[form].tag)
372
373 /*
374 * A MIDI finite state transducer suitable for receiving or transmitting. It
375 * will accept correct MIDI input that uses, doesn't use, or sometimes uses the
376 * 'running status' compression technique, and transduce it to fully expanded
377 * (form=FST_CANON) or fully compressed (form=FST_COMPR or FST_VCOMP) form.
378 *
379 * Returns FST_MORE if a complete message has not been parsed yet (SysEx
380 * messages are the exception), FST_ERR or FST_HUH if the input does not
381 * conform to the protocol, or FST_CHN (channel messages), FST_COM (System
382 * Common messages), FST_RT (System Real-Time messages), or FST_SYX (System
383 * Exclusive) to broadly categorize the message parsed. s->pos and s->end
384 * locate the parsed message; while (s->pos<s->end) putchar(*(s->pos++));
385 * would output it.
386 *
387 * FST_HUH means the character c wasn't valid in the original state, but the
388 * state has now been reset to START and the caller should try again passing
389 * the same c. FST_ERR means c isn't valid in the start state; the caller
390 * should kiss it goodbye and continue to try successive characters from the
391 * input until something other than FST_ERR or FST_HUH is returned, at which
392 * point things are resynchronized.
393 *
394 * A FST_SYX return means that between pos and end are from 1 to 3
395 * bytes of a system exclusive message. A SysEx message will be delivered in
396 * one or more chunks of that form, where the first begins with 0xf0 and the
397 * last (which is the only one that might have length < 3) ends with 0xf7.
398 *
399 * Messages corrupted by a protocol error are discarded and won't be seen at
400 * all; again SysEx is the exception, as one or more chunks of it may already
401 * have been parsed.
402 *
403 * For FST_CHN messages, s->msg[0] always contains the status byte even if
404 * FST_COMPR form was requested (pos then points to msg[1]). That way, the
405 * caller can always identify the exact message if there is a need to do so.
406 * For all other message types except FST_SYX, the status byte is at *pos
407 * (which may not necessarily be msg[0]!). There is only one SysEx status
408 * byte, so the return value FST_SYX is sufficient to identify it.
409 *
410 * To simplify some use cases, compression can also be requested with
411 * form=FST_VCOMP. In this form a compressible channel message is indicated
412 * by returning a classification of FST_CHV instead of FST_CHN, and pos points
413 * to the status byte rather than being advanced past it. If the caller in this
414 * case saves the bytes from pos to end, it will have saved the entire message,
415 * and can act on the FST_CHV tag to drop the first byte later. In this form,
416 * unlike FST_CANON, hidden note-off (i.e. note-on with velocity 0) may occur.
417 *
418 * Two obscure points in the MIDI protocol complicate things further, both to
419 * do with the EndSysEx code, 0xf7. First, this code is permitted (and
420 * meaningless) outside of a System Exclusive message, anywhere a status byte
421 * could appear. Second, it is allowed to be absent at the end of a System
422 * Exclusive message (!) - any status byte at all (non-realtime) is allowed to
423 * terminate the message. Both require accommodation in the interface to
424 * midi_fst's caller. A stray 0xf7 should be ignored BUT should count as a
425 * message received for purposes of Active Sense timeout; the case is
426 * represented by a return of FST_COM with a length of zero (pos == end). A
427 * status byte other than 0xf7 during a system exclusive message will cause an
428 * FST_SXP (sysex plus) return; the bytes from pos to end are the end of the
429 * system exclusive message, and after handling those the caller should call
430 * midi_fst again with the same input byte.
431 *
432 * midi(4) will never produce either such form of rubbish.
433 */
434 static enum fst_ret
midi_fst(struct midi_state * s,u_char c,enum fst_form form)435 midi_fst(struct midi_state *s, u_char c, enum fst_form form)
436 {
437 int syxpos = 0;
438
439 if (c >= 0xf8) { /* All realtime messages bypass state machine */
440 if (c == 0xf9 || c == 0xfd) {
441 DPRINTF( ("midi_fst: s=%p c=0x%02x undefined\n",
442 s, c));
443 s->bytesDiscarded.ev_count++;
444 return FST_ERR;
445 }
446 DPRINTFN(9, ("midi_fst: s=%p System Real-Time data=0x%02x\n",
447 s, c));
448 s->msg[2] = c;
449 FST_RETURN(2,3,FST_RT);
450 }
451
452 DPRINTFN(4, ("midi_fst: s=%p data=0x%02x state=%d\n",
453 s, c, s->state));
454
455 switch (s->state | MIDI_CAT(c)) { /* break ==> return FST_MORE */
456 case MIDI_IN_START | MIDI_CAT_COMMON:
457 case MIDI_IN_RUN1_1 | MIDI_CAT_COMMON:
458 case MIDI_IN_RUN2_2 | MIDI_CAT_COMMON:
459 case MIDI_IN_RXX2_2 | MIDI_CAT_COMMON:
460 s->msg[0] = c;
461 switch ( c) {
462 case 0xf0: s->state = MIDI_IN_SYX1_3; break;
463 case 0xf1: s->state = MIDI_IN_COM0_1; break;
464 case 0xf2: s->state = MIDI_IN_COM0_2; break;
465 case 0xf3: s->state = MIDI_IN_COM0_1; break;
466 case 0xf6: s->state = MIDI_IN_START; FST_RETURN(0,1,FST_COM);
467 case 0xf7: s->state = MIDI_IN_START; FST_RETURN(0,0,FST_COM);
468 default: goto protocol_violation;
469 }
470 break;
471
472 case MIDI_IN_RUN1_1 | MIDI_CAT_STATUS1:
473 if (c == s->msg[0]) {
474 s->state = MIDI_IN_RNX0_1;
475 break;
476 }
477 /* FALLTHROUGH */
478 case MIDI_IN_RUN2_2 | MIDI_CAT_STATUS1:
479 case MIDI_IN_RXX2_2 | MIDI_CAT_STATUS1:
480 case MIDI_IN_START | MIDI_CAT_STATUS1:
481 s->state = MIDI_IN_RUN0_1;
482 s->msg[0] = c;
483 break;
484
485 case MIDI_IN_RUN2_2 | MIDI_CAT_STATUS2:
486 case MIDI_IN_RXX2_2 | MIDI_CAT_STATUS2:
487 if (c == s->msg[0]) {
488 s->state = MIDI_IN_RNX0_2;
489 break;
490 }
491 if ((c ^ s->msg[0]) == 0x10 && (c & 0xe0) == 0x80) {
492 s->state = MIDI_IN_RXX0_2;
493 s->msg[0] = c;
494 break;
495 }
496 /* FALLTHROUGH */
497 case MIDI_IN_RUN1_1 | MIDI_CAT_STATUS2:
498 case MIDI_IN_START | MIDI_CAT_STATUS2:
499 s->state = MIDI_IN_RUN0_2;
500 s->msg[0] = c;
501 break;
502
503 case MIDI_IN_COM0_1 | MIDI_CAT_DATA:
504 s->state = MIDI_IN_START;
505 s->msg[1] = c;
506 FST_RETURN(0,2,FST_COM);
507
508 case MIDI_IN_COM0_2 | MIDI_CAT_DATA:
509 s->state = MIDI_IN_COM1_2;
510 s->msg[1] = c;
511 break;
512
513 case MIDI_IN_COM1_2 | MIDI_CAT_DATA:
514 s->state = MIDI_IN_START;
515 s->msg[2] = c;
516 FST_RETURN(0,3,FST_COM);
517
518 case MIDI_IN_RUN0_1 | MIDI_CAT_DATA:
519 s->state = MIDI_IN_RUN1_1;
520 s->msg[1] = c;
521 FST_RETURN(0,2,FST_CHN);
522
523 case MIDI_IN_RUN1_1 | MIDI_CAT_DATA:
524 case MIDI_IN_RNX0_1 | MIDI_CAT_DATA:
525 s->state = MIDI_IN_RUN1_1;
526 s->msg[1] = c;
527 FST_CRETURN(2);
528
529 case MIDI_IN_RUN0_2 | MIDI_CAT_DATA:
530 s->state = MIDI_IN_RUN1_2;
531 s->msg[1] = c;
532 break;
533
534 case MIDI_IN_RUN1_2 | MIDI_CAT_DATA:
535 if (FST_CANON == form && 0 == c && (s->msg[0]&0xf0) == 0x90) {
536 s->state = MIDI_IN_RXX2_2;
537 s->msg[0] ^= 0x10;
538 s->msg[2] = 64;
539 } else {
540 s->state = MIDI_IN_RUN2_2;
541 s->msg[2] = c;
542 }
543 FST_RETURN(0,3,FST_CHN);
544
545 case MIDI_IN_RUN2_2 | MIDI_CAT_DATA:
546 s->state = MIDI_IN_RNX1_2;
547 s->msg[1] = c;
548 break;
549
550 case MIDI_IN_RXX2_2 | MIDI_CAT_DATA:
551 s->state = MIDI_IN_RXX1_2;
552 s->msg[0] ^= 0x10;
553 s->msg[1] = c;
554 break;
555
556 case MIDI_IN_RNX0_2 | MIDI_CAT_DATA:
557 s->state = MIDI_IN_RNY1_2;
558 s->msg[1] = c;
559 break;
560
561 case MIDI_IN_RXX0_2 | MIDI_CAT_DATA:
562 s->state = MIDI_IN_RXY1_2;
563 s->msg[1] = c;
564 break;
565
566 case MIDI_IN_RNX1_2 | MIDI_CAT_DATA:
567 case MIDI_IN_RNY1_2 | MIDI_CAT_DATA:
568 if (FST_CANON == form && 0 == c && (s->msg[0]&0xf0) == 0x90) {
569 s->state = MIDI_IN_RXX2_2;
570 s->msg[0] ^= 0x10;
571 s->msg[2] = 64;
572 FST_RETURN(0,3,FST_CHN);
573 }
574 s->state = MIDI_IN_RUN2_2;
575 s->msg[2] = c;
576 FST_CRETURN(3);
577
578 case MIDI_IN_RXX1_2 | MIDI_CAT_DATA:
579 case MIDI_IN_RXY1_2 | MIDI_CAT_DATA:
580 if (( 0 == c && (s->msg[0]&0xf0) == 0x90)
581 || (64 == c && (s->msg[0]&0xf0) == 0x80
582 && FST_CANON != form)) {
583 s->state = MIDI_IN_RXX2_2;
584 s->msg[0] ^= 0x10;
585 s->msg[2] = 64 - c;
586 FST_CRETURN(3);
587 }
588 s->state = MIDI_IN_RUN2_2;
589 s->msg[2] = c;
590 FST_RETURN(0,3,FST_CHN);
591
592 case MIDI_IN_SYX1_3 | MIDI_CAT_DATA:
593 s->state = MIDI_IN_SYX2_3;
594 s->msg[1] = c;
595 break;
596
597 case MIDI_IN_SYX2_3 | MIDI_CAT_DATA:
598 s->state = MIDI_IN_SYX0_3;
599 s->msg[2] = c;
600 FST_RETURN(0,3,FST_SYX);
601
602 case MIDI_IN_SYX0_3 | MIDI_CAT_DATA:
603 s->state = MIDI_IN_SYX1_3;
604 s->msg[0] = c;
605 break;
606
607 case MIDI_IN_SYX2_3 | MIDI_CAT_COMMON:
608 case MIDI_IN_SYX2_3 | MIDI_CAT_STATUS1:
609 case MIDI_IN_SYX2_3 | MIDI_CAT_STATUS2:
610 ++ syxpos;
611 /* FALLTHROUGH */
612 case MIDI_IN_SYX1_3 | MIDI_CAT_COMMON:
613 case MIDI_IN_SYX1_3 | MIDI_CAT_STATUS1:
614 case MIDI_IN_SYX1_3 | MIDI_CAT_STATUS2:
615 ++ syxpos;
616 /* FALLTHROUGH */
617 case MIDI_IN_SYX0_3 | MIDI_CAT_COMMON:
618 case MIDI_IN_SYX0_3 | MIDI_CAT_STATUS1:
619 case MIDI_IN_SYX0_3 | MIDI_CAT_STATUS2:
620 s->state = MIDI_IN_START;
621 if (c == 0xf7) {
622 s->msg[syxpos] = c;
623 FST_RETURN(0,1+syxpos,FST_SYX);
624 }
625 s->msg[syxpos] = 0xf7;
626 FST_RETURN(0,1+syxpos,FST_SXP);
627
628 default:
629 protocol_violation:
630 DPRINTF(("midi_fst: unexpected %#02x in state %u\n",
631 c, s->state));
632 switch ( s->state) {
633 case MIDI_IN_RUN1_1: /* can only get here by seeing an */
634 case MIDI_IN_RUN2_2: /* INVALID System Common message */
635 case MIDI_IN_RXX2_2:
636 s->state = MIDI_IN_START;
637 /* FALLTHROUGH */
638 case MIDI_IN_START:
639 s->bytesDiscarded.ev_count++;
640 return FST_ERR;
641 case MIDI_IN_COM1_2:
642 case MIDI_IN_RUN1_2:
643 case MIDI_IN_RNY1_2:
644 case MIDI_IN_RXY1_2:
645 s->bytesDiscarded.ev_count++;
646 /* FALLTHROUGH */
647 case MIDI_IN_COM0_1:
648 case MIDI_IN_RUN0_1:
649 case MIDI_IN_RNX0_1:
650 case MIDI_IN_COM0_2:
651 case MIDI_IN_RUN0_2:
652 case MIDI_IN_RNX0_2:
653 case MIDI_IN_RXX0_2:
654 case MIDI_IN_RNX1_2:
655 case MIDI_IN_RXX1_2:
656 s->bytesDiscarded.ev_count++;
657 s->incompleteMessages.ev_count++;
658 break;
659 default:
660 DPRINTF(("midi_fst: mishandled %#02x(%u) in state %u?!\n",
661 c, MIDI_CAT(c), s->state));
662 break;
663 }
664 s->state = MIDI_IN_START;
665 return FST_HUH;
666 }
667 return FST_MORE;
668 }
669
670 static void
midi_softint(void * cookie)671 midi_softint(void *cookie)
672 {
673 struct midi_softc *sc;
674 proc_t *p;
675 pid_t pid;
676
677 sc = cookie;
678
679 mutex_enter(&proc_lock);
680 pid = sc->async;
681 if (pid != 0 && (p = proc_find(pid)) != NULL)
682 psignal(p, SIGIO);
683 mutex_exit(&proc_lock);
684 }
685
686 static void
midi_in(void * addr,int data)687 midi_in(void *addr, int data)
688 {
689 struct midi_softc *sc;
690 struct midi_buffer *mb;
691 int i, count;
692 enum fst_ret got;
693 MIDI_BUF_DECLARE(idx);
694 MIDI_BUF_DECLARE(buf);
695
696 sc = addr;
697 mb = &sc->inbuf;
698
699 KASSERT(mutex_owned(sc->lock));
700
701 if (!sc->isopen)
702 return;
703
704 if ((sc->flags & FREAD) == 0)
705 return; /* discard data if not reading */
706
707 sxp_again:
708 do {
709 got = midi_fst(&sc->rcv, data, FST_CANON);
710 } while (got == FST_HUH);
711
712 switch (got) {
713 case FST_MORE:
714 case FST_ERR:
715 return;
716 case FST_CHN:
717 case FST_COM:
718 case FST_RT:
719 #if NSEQUENCER > 0
720 if (sc->seqopen) {
721 extern void midiseq_in(struct midi_dev *,u_char *,int);
722 count = sc->rcv.end - sc->rcv.pos;
723 midiseq_in(sc->seq_md, sc->rcv.pos, count);
724 return;
725 }
726 #endif
727 /*
728 * Pass Active Sense to the sequencer if it's open, but not to
729 * a raw reader. (Really should do something intelligent with
730 * it then, though....)
731 */
732 if (got == FST_RT && MIDI_ACK == sc->rcv.pos[0]) {
733 if (!sc->rcv_expect_asense) {
734 sc->rcv_expect_asense = 1;
735 callout_schedule(&sc->rcv_asense_co,
736 MIDI_RCV_ASENSE_PERIOD);
737 }
738 sc->rcv_quiescent = 0;
739 sc->rcv_eof = 0;
740 return;
741 }
742 /* FALLTHROUGH */
743 /*
744 * Ultimately SysEx msgs should be offered to the sequencer also; the
745 * sequencer API addresses them - but maybe our sequencer can't handle
746 * them yet, so offer only to raw reader. (Which means, ultimately,
747 * discard them if the sequencer's open, as it's not doing reads!)
748 * -> When SysEx support is added to the sequencer, be sure to handle
749 * FST_SXP there too.
750 */
751 case FST_SYX:
752 case FST_SXP:
753 count = sc->rcv.end - sc->rcv.pos;
754 sc->rcv_quiescent = 0;
755 sc->rcv_eof = 0;
756 if (0 == count)
757 break;
758 MIDI_BUF_PRODUCER_INIT(mb,idx);
759 MIDI_BUF_PRODUCER_INIT(mb,buf);
760 if (count > buf_lim - buf_cur
761 || 1 > idx_lim - idx_cur) {
762 sc->rcv.bytesDiscarded.ev_count += count;
763 DPRINTF(("midi_in: buffer full, discard data=0x%02x\n",
764 sc->rcv.pos[0]));
765 return;
766 }
767 for (i = 0; i < count; i++) {
768 *buf_cur++ = sc->rcv.pos[i];
769 MIDI_BUF_WRAP(buf);
770 }
771 *idx_cur++ = PACK_MB_IDX(got,count);
772 MIDI_BUF_WRAP(idx);
773 MIDI_BUF_PRODUCER_WBACK(mb,buf);
774 MIDI_BUF_PRODUCER_WBACK(mb,idx);
775 cv_broadcast(&sc->rchan);
776 selnotify(&sc->rsel, 0, NOTE_SUBMIT);
777 if (sc->async != 0)
778 softint_schedule(sc->sih);
779 break;
780 default: /* don't #ifdef this away, gcc will say FST_HUH not handled */
781 printf("midi_in: midi_fst returned %d?!\n", got);
782 }
783 if (FST_SXP == got)
784 goto sxp_again;
785 }
786
787 static void
midi_out(void * addr)788 midi_out(void *addr)
789 {
790 struct midi_softc *sc = addr;
791
792 KASSERT(mutex_owned(sc->lock));
793
794 if (!sc->isopen)
795 return;
796 DPRINTFN(8, ("midi_out: %p\n", sc));
797 midi_intr_out(sc);
798 }
799
800 static int
midiopen(dev_t dev,int flags,int ifmt,struct lwp * l)801 midiopen(dev_t dev, int flags, int ifmt, struct lwp *l)
802 {
803 struct midi_softc *sc;
804 const struct midi_hw_if *hw;
805 int error;
806
807 sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
808 if (sc == NULL)
809 return (ENXIO);
810 DPRINTFN(3,("midiopen %p\n", sc));
811
812 mutex_enter(sc->lock);
813 if (sc->dying) {
814 mutex_exit(sc->lock);
815 return (EIO);
816 }
817 hw = sc->hw_if;
818 if (hw == NULL) {
819 mutex_exit(sc->lock);
820 return ENXIO;
821 }
822 if (sc->isopen) {
823 mutex_exit(sc->lock);
824 return EBUSY;
825 }
826
827 /* put both state machines into known states */
828 sc->rcv.state = MIDI_IN_START;
829 sc->rcv.pos = sc->rcv.msg;
830 sc->rcv.end = sc->rcv.msg;
831 sc->xmt.state = MIDI_IN_START;
832 sc->xmt.pos = sc->xmt.msg;
833 sc->xmt.end = sc->xmt.msg;
834
835 /* copy error counters so an ioctl (TBA) can give since-open stats */
836 sc->rcv.atOpen.bytesDiscarded = sc->rcv.bytesDiscarded.ev_count;
837 sc->rcv.atQuery.bytesDiscarded = sc->rcv.bytesDiscarded.ev_count;
838
839 sc->xmt.atOpen.bytesDiscarded = sc->xmt.bytesDiscarded.ev_count;
840 sc->xmt.atQuery.bytesDiscarded = sc->xmt.bytesDiscarded.ev_count;
841
842 /* and the buffers */
843 midi_initbuf(&sc->outbuf);
844 midi_initbuf(&sc->inbuf);
845
846 /* and the receive flags */
847 sc->rcv_expect_asense = 0;
848 sc->rcv_quiescent = 0;
849 sc->rcv_eof = 0;
850 sc->isopen++;
851 sc->flags = flags;
852 sc->pbus = 0;
853 sc->async = 0;
854
855 #ifdef MIDI_SAVE
856 if (midicnt != 0) {
857 midisave.cnt = midicnt;
858 midicnt = 0;
859 }
860 #endif
861
862 error = hw->open(sc->hw_hdl, flags, midi_in, midi_out, sc);
863 if (error) {
864 mutex_exit(sc->lock);
865 return error;
866 }
867
868 mutex_exit(sc->lock);
869 return 0;
870 }
871
872 static int
midiclose(dev_t dev,int flags,int ifmt,struct lwp * l)873 midiclose(dev_t dev, int flags, int ifmt, struct lwp *l)
874 {
875 struct midi_softc *sc;
876 const struct midi_hw_if *hw;
877
878 sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
879 hw = sc->hw_if;
880
881 DPRINTFN(3,("midiclose %p\n", sc));
882
883 mutex_enter(sc->lock);
884 /* midi_start_output(sc); anything buffered => pbus already set! */
885 while (sc->pbus) {
886 if (sc->dying)
887 break;
888 DPRINTFN(8,("midiclose sleep ...\n"));
889 cv_wait(&sc->wchan, sc->lock);
890 }
891 sc->isopen = 0;
892 callout_halt(&sc->xmt_asense_co, sc->lock);
893 callout_halt(&sc->rcv_asense_co, sc->lock);
894 hw->close(sc->hw_hdl);
895 sc->seqopen = 0;
896 sc->seq_md = 0;
897 mutex_exit(sc->lock);
898
899 return 0;
900 }
901
902 static int
midiread(dev_t dev,struct uio * uio,int ioflag)903 midiread(dev_t dev, struct uio *uio, int ioflag)
904 {
905 struct midi_softc *sc;
906 struct midi_buffer *mb;
907 int appetite, error, first;
908 MIDI_BUF_DECLARE(idx);
909 MIDI_BUF_DECLARE(buf);
910
911 sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
912 mb = &sc->inbuf;
913 first = 1;
914
915 DPRINTFN(6,("midiread: %p, count=%lu\n", sc,
916 (unsigned long)uio->uio_resid));
917
918 mutex_enter(sc->lock);
919 if (sc->dying) {
920 mutex_exit(sc->lock);
921 return EIO;
922 }
923 if ((sc->props & MIDI_PROP_CAN_INPUT) == 0) {
924 mutex_exit(sc->lock);
925 return ENXIO;
926 }
927 MIDI_BUF_CONSUMER_INIT(mb,idx);
928 MIDI_BUF_CONSUMER_INIT(mb,buf);
929 error = 0;
930 for (;;) {
931 /*
932 * If the used portion of idx wraps around the end, just take
933 * the first part on this iteration, and we'll get the rest on
934 * the next.
935 */
936 if (idx_lim > idx_end)
937 idx_lim = idx_end;
938 /*
939 * Count bytes through the last complete message that will
940 * fit in the requested read.
941 */
942 for (appetite = uio->uio_resid; idx_cur < idx_lim; ++idx_cur) {
943 if (appetite < MB_IDX_LEN(*idx_cur))
944 break;
945 appetite -= MB_IDX_LEN(*idx_cur);
946 }
947 appetite = uio->uio_resid - appetite;
948
949 /*
950 * Only if the read is too small to hold even the first
951 * complete message will we return a partial one (updating idx
952 * to reflect the remaining length of the message).
953 */
954 if (appetite == 0 && idx_cur < idx_lim) {
955 if (!first)
956 break;
957 appetite = uio->uio_resid;
958 *idx_cur = PACK_MB_IDX(MB_IDX_CAT(*idx_cur),
959 MB_IDX_LEN(*idx_cur) - appetite);
960 }
961 KASSERT(buf_cur + appetite <= buf_lim);
962
963 /* move the bytes */
964 if (appetite > 0) {
965 first = 0; /* we know we won't return empty-handed */
966 /* do two uiomoves if data wrap around end of buf */
967 if (buf_cur + appetite > buf_end) {
968 DPRINTFN(8,
969 ("midiread: uiomove cc=%td (prewrap)\n",
970 buf_end - buf_cur));
971 mutex_exit(sc->lock);
972 error = uiomove(buf_cur, buf_end - buf_cur, uio);
973 mutex_enter(sc->lock);
974 if (error)
975 break;
976 if (sc->dying) {
977 error = EIO;
978 break;
979 }
980 appetite -= buf_end - buf_cur;
981 buf_cur = mb->buf;
982 }
983 DPRINTFN(8, ("midiread: uiomove cc=%d\n", appetite));
984 mutex_exit(sc->lock);
985 error = uiomove(buf_cur, appetite, uio);
986 mutex_enter(sc->lock);
987 if (error)
988 break;
989 if (sc->dying) {
990 error = EIO;
991 break;
992 }
993 buf_cur += appetite;
994 }
995
996 MIDI_BUF_WRAP(idx);
997 MIDI_BUF_WRAP(buf);
998 MIDI_BUF_CONSUMER_WBACK(mb,idx);
999 MIDI_BUF_CONSUMER_WBACK(mb,buf);
1000 if (0 == uio->uio_resid) /* if read satisfied, we're done */
1001 break;
1002 MIDI_BUF_CONSUMER_REFRESH(mb,idx);
1003 if (idx_cur == idx_lim) { /* need to wait for data? */
1004 if (!first || sc->rcv_eof) /* never block reader if */
1005 break; /* any data already in hand */
1006 if (ioflag & IO_NDELAY) {
1007 error = EWOULDBLOCK;
1008 break;
1009 }
1010 error = cv_wait_sig(&sc->rchan, sc->lock);
1011 if (error)
1012 break;
1013 MIDI_BUF_CONSUMER_REFRESH(mb,idx); /* what'd we get? */
1014 }
1015 MIDI_BUF_CONSUMER_REFRESH(mb,buf);
1016 if (sc->dying) {
1017 error = EIO;
1018 break;
1019 }
1020 }
1021 mutex_exit(sc->lock);
1022
1023 return error;
1024 }
1025
1026 static void
midi_rcv_asense(void * arg)1027 midi_rcv_asense(void *arg)
1028 {
1029 struct midi_softc *sc;
1030
1031 sc = arg;
1032
1033 mutex_enter(sc->lock);
1034 if (sc->dying || !sc->isopen) {
1035 mutex_exit(sc->lock);
1036 return;
1037 }
1038 if (sc->rcv_quiescent) {
1039 sc->rcv_eof = 1;
1040 sc->rcv_quiescent = 0;
1041 sc->rcv_expect_asense = 0;
1042 cv_broadcast(&sc->rchan);
1043 selnotify(&sc->rsel, 0, NOTE_SUBMIT);
1044 if (sc->async)
1045 softint_schedule(sc->sih);
1046 mutex_exit(sc->lock);
1047 return;
1048 }
1049 sc->rcv_quiescent = 1;
1050 callout_schedule(&sc->rcv_asense_co, MIDI_RCV_ASENSE_PERIOD);
1051 mutex_exit(sc->lock);
1052 }
1053
1054 static void
midi_xmt_asense(void * arg)1055 midi_xmt_asense(void *arg)
1056 {
1057 struct midi_softc *sc;
1058 int error, armed;
1059
1060 sc = arg;
1061
1062 mutex_enter(sc->lock);
1063 if (sc->pbus || sc->dying || !sc->isopen) {
1064 mutex_exit(sc->lock);
1065 return;
1066 }
1067 sc->pbus = 1;
1068 if (sc->props & MIDI_PROP_OUT_INTR) {
1069 error = sc->hw_if->output(sc->hw_hdl, MIDI_ACK);
1070 armed = (error == 0);
1071 } else {
1072 error = sc->hw_if->output(sc->hw_hdl, MIDI_ACK);
1073 armed = 0;
1074 }
1075 if (!armed) {
1076 sc->pbus = 0;
1077 callout_schedule(&sc->xmt_asense_co, MIDI_XMT_ASENSE_PERIOD);
1078 }
1079 mutex_exit(sc->lock);
1080 }
1081
1082 /*
1083 * The way this function was hacked up to plug into poll_out and intr_out
1084 * after they were written won't win it any beauty contests, but it'll work
1085 * (code in haste, refactor at leisure).
1086 */
1087 static int
midi_msg_out(struct midi_softc * sc,u_char ** idx,u_char ** idxl,u_char ** buf,u_char ** bufl)1088 midi_msg_out(struct midi_softc *sc, u_char **idx, u_char **idxl, u_char **buf,
1089 u_char **bufl)
1090 {
1091 MIDI_BUF_DECLARE(idx);
1092 MIDI_BUF_DECLARE(buf);
1093 MIDI_BUF_EXTENT_INIT(&sc->outbuf,idx);
1094 MIDI_BUF_EXTENT_INIT(&sc->outbuf,buf);
1095 int length;
1096 int error;
1097 u_char contig[3];
1098 u_char *cp;
1099 u_char *ep;
1100
1101 KASSERT(mutex_owned(sc->lock));
1102
1103 idx_cur = *idx;
1104 idx_lim = *idxl;
1105 buf_cur = *buf;
1106 buf_lim = *bufl;
1107
1108 length = MB_IDX_LEN(*idx_cur);
1109
1110 for ( cp = contig, ep = cp + length; cp < ep;) {
1111 *cp++ = *buf_cur++;
1112 MIDI_BUF_WRAP(buf);
1113 }
1114 cp = contig;
1115
1116 switch ( MB_IDX_CAT(*idx_cur)) {
1117 case FST_CHV: /* chnmsg to be compressed (for device that wants it) */
1118 ++ cp;
1119 -- length;
1120 /* FALLTHROUGH */
1121 case FST_CHN:
1122 error = sc->hw_if_ext->channel(sc->hw_hdl,
1123 MIDI_GET_STATUS(contig[0]), MIDI_GET_CHAN(contig[0]),
1124 cp, length);
1125 break;
1126 case FST_COM:
1127 error = sc->hw_if_ext->common(sc->hw_hdl,
1128 MIDI_GET_STATUS(contig[0]), cp, length);
1129 break;
1130 case FST_SYX:
1131 case FST_SXP:
1132 error = sc->hw_if_ext->sysex(sc->hw_hdl, cp, length);
1133 break;
1134 case FST_RT:
1135 error = sc->hw_if->output(sc->hw_hdl, *cp);
1136 break;
1137 default:
1138 error = EIO;
1139 }
1140
1141 if (!error) {
1142 ++ idx_cur;
1143 MIDI_BUF_WRAP(idx);
1144 *idx = idx_cur;
1145 *idxl = idx_lim;
1146 *buf = buf_cur;
1147 *bufl = buf_lim;
1148 }
1149
1150 return error;
1151 }
1152
1153 /*
1154 * midi_poll_out is intended for the midi hw (the vast majority of MIDI UARTs
1155 * on sound cards, apparently) that _do not have transmit-ready interrupts_.
1156 * Every call to hw_if->output for one of these may busy-wait to output the
1157 * byte; at the standard midi data rate that'll be 320us per byte. The
1158 * technique of writing only MIDI_MAX_WRITE bytes in a row and then waiting
1159 * for MIDI_WAIT does not reduce the total time spent busy-waiting, and it
1160 * adds arbitrary delays in transmission (and, since MIDI_WAIT is roughly the
1161 * same as the time to send MIDI_MAX_WRITE bytes, it effectively halves the
1162 * data rate). Here, a somewhat bolder approach is taken. Since midi traffic
1163 * is bursty but time-sensitive--most of the time there will be none at all,
1164 * but when there is it should go out ASAP--the strategy is to just get it
1165 * over with, and empty the buffer in one go. The effect this can have on
1166 * the rest of the system will be limited by the size of the buffer and the
1167 * sparseness of the traffic. But some precautions are in order. Interrupts
1168 * should all be unmasked when this is called, and midiwrite should not fill
1169 * the buffer more than once (when MIDI_PROP_CAN_INTR is false) without a
1170 * yield() so some other process can get scheduled. If the write is nonblocking,
1171 * midiwrite should return a short count rather than yield.
1172 *
1173 * Someday when there is fine-grained MP support, this should be reworked to
1174 * run in a callout so the writing process really could proceed concurrently.
1175 * But obviously where performance is a concern, interrupt-driven hardware
1176 * such as USB midi or (apparently) clcs will always be preferable. And it
1177 * seems (kern/32651) that many of the devices currently working in poll mode
1178 * may really have tx interrupt capability and want only implementation; that
1179 * ought to happen.
1180 */
1181 static int
midi_poll_out(struct midi_softc * sc)1182 midi_poll_out(struct midi_softc *sc)
1183 {
1184 struct midi_buffer *mb = &sc->outbuf;
1185 int error;
1186 int msglen;
1187 MIDI_BUF_DECLARE(idx);
1188 MIDI_BUF_DECLARE(buf);
1189
1190 KASSERT(mutex_owned(sc->lock));
1191
1192 error = 0;
1193 MIDI_BUF_CONSUMER_INIT(mb,idx);
1194 MIDI_BUF_CONSUMER_INIT(mb,buf);
1195
1196 for (;;) {
1197 while (idx_cur != idx_lim) {
1198 if (sc->hw_if_ext) {
1199 error = midi_msg_out(sc, &idx_cur, &idx_lim,
1200 &buf_cur, &buf_lim);
1201 if (error != 0) {
1202 break;
1203 }
1204 continue;
1205 }
1206 /* or, lacking hw_if_ext ... */
1207 msglen = MB_IDX_LEN(*idx_cur);
1208 DPRINTFN(7,("midi_poll_out: %p <- %#02x\n",
1209 sc->hw_hdl, *buf_cur));
1210 error = sc->hw_if->output(sc->hw_hdl, *buf_cur);
1211 if (error) {
1212 break;
1213 }
1214 buf_cur++;
1215 MIDI_BUF_WRAP(buf);
1216 msglen--;
1217 if (msglen) {
1218 *idx_cur = PACK_MB_IDX(MB_IDX_CAT(*idx_cur),
1219 msglen);
1220 } else {
1221 idx_cur++;
1222 MIDI_BUF_WRAP(idx);
1223 }
1224 }
1225 if (error != 0) {
1226 break;
1227 }
1228 KASSERT(buf_cur == buf_lim);
1229 MIDI_BUF_CONSUMER_WBACK(mb,idx);
1230 MIDI_BUF_CONSUMER_WBACK(mb,buf);
1231 MIDI_BUF_CONSUMER_REFRESH(mb,idx); /* any more to transmit? */
1232 MIDI_BUF_CONSUMER_REFRESH(mb,buf);
1233 if (idx_lim == idx_cur)
1234 break;
1235 }
1236
1237 if (error != 0) {
1238 DPRINTF(("midi_poll_output error %d\n", error));
1239 MIDI_BUF_CONSUMER_WBACK(mb,idx);
1240 MIDI_BUF_CONSUMER_WBACK(mb,buf);
1241 }
1242 sc->pbus = 0;
1243 callout_schedule(&sc->xmt_asense_co, MIDI_XMT_ASENSE_PERIOD);
1244 return error;
1245 }
1246
1247 /*
1248 * The interrupt flavor acquires spl and lock once and releases at the end,
1249 * as it expects to write only one byte or message. The interface convention
1250 * is that if hw_if->output returns 0, it has initiated transmission and the
1251 * completion interrupt WILL be forthcoming; if it has not returned 0, NO
1252 * interrupt will be forthcoming, and if it returns EINPROGRESS it wants
1253 * another byte right away.
1254 */
1255 static int
midi_intr_out(struct midi_softc * sc)1256 midi_intr_out(struct midi_softc *sc)
1257 {
1258 struct midi_buffer *mb;
1259 int error, msglen;
1260 MIDI_BUF_DECLARE(idx);
1261 MIDI_BUF_DECLARE(buf);
1262 int armed = 0;
1263
1264 KASSERT(mutex_owned(sc->lock));
1265
1266 error = 0;
1267 mb = &sc->outbuf;
1268
1269 MIDI_BUF_CONSUMER_INIT(mb,idx);
1270 MIDI_BUF_CONSUMER_INIT(mb,buf);
1271
1272 while (idx_cur != idx_lim) {
1273 if (sc->hw_if_ext) {
1274 error = midi_msg_out(sc, &idx_cur, &idx_lim,
1275 &buf_cur, &buf_lim);
1276 if (!error ) /* no EINPROGRESS from extended hw_if */
1277 armed = 1;
1278 break;
1279 }
1280 /* or, lacking hw_if_ext ... */
1281 msglen = MB_IDX_LEN(*idx_cur);
1282 error = sc->hw_if->output(sc->hw_hdl, *buf_cur);
1283 if (error && error != EINPROGRESS)
1284 break;
1285 ++buf_cur;
1286 MIDI_BUF_WRAP(buf);
1287 --msglen;
1288 if (msglen)
1289 *idx_cur = PACK_MB_IDX(MB_IDX_CAT(*idx_cur),msglen);
1290 else {
1291 ++idx_cur;
1292 MIDI_BUF_WRAP(idx);
1293 }
1294 if (!error) {
1295 armed = 1;
1296 break;
1297 }
1298 }
1299 MIDI_BUF_CONSUMER_WBACK(mb,idx);
1300 MIDI_BUF_CONSUMER_WBACK(mb,buf);
1301 if (!armed) {
1302 sc->pbus = 0;
1303 callout_schedule(&sc->xmt_asense_co, MIDI_XMT_ASENSE_PERIOD);
1304 }
1305 cv_broadcast(&sc->wchan);
1306 selnotify(&sc->wsel, 0, NOTE_SUBMIT);
1307 if (sc->async) {
1308 softint_schedule(sc->sih);
1309 }
1310 if (error) {
1311 DPRINTF(("midi_intr_output error %d\n", error));
1312 }
1313 return error;
1314 }
1315
1316 static int
midi_start_output(struct midi_softc * sc)1317 midi_start_output(struct midi_softc *sc)
1318 {
1319
1320 KASSERT(mutex_owned(sc->lock));
1321
1322 if (sc->dying)
1323 return EIO;
1324 if (sc->props & MIDI_PROP_OUT_INTR)
1325 return midi_intr_out(sc);
1326 return midi_poll_out(sc);
1327 }
1328
1329 static int
real_writebytes(struct midi_softc * sc,u_char * ibuf,int cc)1330 real_writebytes(struct midi_softc *sc, u_char *ibuf, int cc)
1331 {
1332 u_char *iend;
1333 struct midi_buffer *mb;
1334 int arming, count, got;
1335 enum fst_form form;
1336 MIDI_BUF_DECLARE(idx);
1337 MIDI_BUF_DECLARE(buf);
1338 int error;
1339
1340 KASSERT(mutex_owned(sc->lock));
1341
1342 if (sc->dying || !sc->isopen)
1343 return EIO;
1344
1345 sc->refcnt++;
1346
1347 iend = ibuf + cc;
1348 mb = &sc->outbuf;
1349 arming = 0;
1350
1351 /*
1352 * If the hardware uses the extended hw_if, pass it canonicalized
1353 * messages (or compressed ones if it specifically requests, using
1354 * VCOMP form so the bottom half can still pass the op and chan along);
1355 * if it does not, send it compressed messages (using COMPR form as
1356 * there is no need to preserve the status for the bottom half).
1357 */
1358 if (NULL == sc->hw_if_ext)
1359 form = FST_COMPR;
1360 else if (sc->hw_if_ext->compress)
1361 form = FST_VCOMP;
1362 else
1363 form = FST_CANON;
1364
1365 MIDI_BUF_PRODUCER_INIT(mb,idx);
1366 MIDI_BUF_PRODUCER_INIT(mb,buf);
1367
1368 while (ibuf < iend) {
1369 got = midi_fst(&sc->xmt, *ibuf, form);
1370 ++ibuf;
1371 switch ( got) {
1372 case FST_MORE:
1373 continue;
1374 case FST_ERR:
1375 case FST_HUH:
1376 error = EPROTO;
1377 goto out;
1378 case FST_CHN:
1379 case FST_CHV: /* only occurs in VCOMP form */
1380 case FST_COM:
1381 case FST_RT:
1382 case FST_SYX:
1383 case FST_SXP:
1384 break; /* go add to buffer */
1385 #if defined(AUDIO_DEBUG) || defined(DIAGNOSTIC)
1386 default:
1387 printf("midi_wr: midi_fst returned %d?!\n", got);
1388 #endif
1389 }
1390 count = sc->xmt.end - sc->xmt.pos;
1391 if (0 == count ) /* can happen with stray 0xf7; see midi_fst */
1392 continue;
1393 /*
1394 * return EWOULDBLOCK if the data passed will not fit in
1395 * the buffer; the caller should have taken steps to avoid that.
1396 * If got==FST_SXP we lose the new status byte, but we're losing
1397 * anyway, so c'est la vie.
1398 */
1399 if (idx_cur == idx_lim || count > buf_lim - buf_cur) {
1400 MIDI_BUF_PRODUCER_REFRESH(mb,idx); /* get the most */
1401 MIDI_BUF_PRODUCER_REFRESH(mb,buf); /* current facts */
1402 if (idx_cur == idx_lim || count > buf_lim - buf_cur) {
1403 error = EWOULDBLOCK; /* caller's problem */
1404 goto out;
1405 }
1406 }
1407 *idx_cur++ = PACK_MB_IDX(got,count);
1408 MIDI_BUF_WRAP(idx);
1409 while (count) {
1410 *buf_cur++ = *(sc->xmt.pos)++;
1411 MIDI_BUF_WRAP(buf);
1412 -- count;
1413 }
1414 if (FST_SXP == got)
1415 -- ibuf; /* again with same status byte */
1416 }
1417 MIDI_BUF_PRODUCER_WBACK(mb,buf);
1418 MIDI_BUF_PRODUCER_WBACK(mb,idx);
1419 /*
1420 * If the output transfer is not already busy, and there is a message
1421 * buffered, mark it busy, stop the Active Sense callout (what if we're
1422 * too late and it's expired already? No big deal, an extra Active Sense
1423 * never hurt anybody) and start the output transfer once we're out of
1424 * the critical section (pbus==1 will stop anyone else doing the same).
1425 */
1426 MIDI_BUF_CONSUMER_INIT(mb,idx); /* check what consumer's got to read */
1427 if (!sc->pbus && idx_cur < idx_lim) {
1428 sc->pbus = 1;
1429 callout_stop(&sc->xmt_asense_co);
1430 arming = 1;
1431 }
1432
1433 error = arming ? midi_start_output(sc) : 0;
1434
1435 out:
1436 if (--sc->refcnt < 0)
1437 cv_broadcast(&sc->detach_cv);
1438
1439 return error;
1440 }
1441
1442 static int
midiwrite(dev_t dev,struct uio * uio,int ioflag)1443 midiwrite(dev_t dev, struct uio *uio, int ioflag)
1444 {
1445 struct midi_softc *sc;
1446 struct midi_buffer *mb;
1447 int error;
1448 u_char inp[256];
1449 MIDI_BUF_DECLARE(idx);
1450 MIDI_BUF_DECLARE(buf);
1451 size_t idxspace;
1452 size_t bufspace;
1453 size_t xfrcount;
1454 int pollout = 0;
1455
1456 (void)buf_end; (void)idx_end;
1457 sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
1458
1459 DPRINTFN(6,("midiwrite: %p, unit=%d, count=%lu\n", sc, (int)minor(dev),
1460 (unsigned long)uio->uio_resid));
1461
1462 mutex_enter(sc->lock);
1463 if (sc->dying) {
1464 mutex_exit(sc->lock);
1465 return EIO;
1466 }
1467
1468 sc->refcnt++;
1469
1470 mb = &sc->outbuf;
1471 error = 0;
1472 while (uio->uio_resid > 0 && !error) {
1473 /*
1474 * block if necessary for the minimum buffer space to guarantee
1475 * we can write something.
1476 */
1477 MIDI_BUF_PRODUCER_INIT(mb,idx); /* init can't go above loop; */
1478 MIDI_BUF_PRODUCER_INIT(mb,buf); /* real_writebytes moves cur */
1479 for (;;) {
1480 idxspace = MIDI_BUF_PRODUCER_REFRESH(mb,idx) - idx_cur;
1481 bufspace = MIDI_BUF_PRODUCER_REFRESH(mb,buf) - buf_cur;
1482 if (idxspace >= 1 && bufspace >= 3 && !pollout)
1483 break;
1484 DPRINTFN(8,("midi_write: sleep idx=%zd buf=%zd\n",
1485 idxspace, bufspace));
1486 if (ioflag & IO_NDELAY) {
1487 /*
1488 * If some amount has already been transferred,
1489 * the common syscall code will automagically
1490 * convert this to success with a short count.
1491 */
1492 error = EWOULDBLOCK;
1493 goto out;
1494 }
1495 if (pollout) {
1496 mutex_exit(sc->lock);
1497 yield(); /* see midi_poll_output */
1498 mutex_enter(sc->lock);
1499 pollout = 0;
1500 } else
1501 error = cv_wait_sig(&sc->wchan, sc->lock);
1502 if (sc->dying)
1503 error = EIO;
1504 if (error) {
1505 /*
1506 * Similarly, the common code will handle
1507 * EINTR and ERESTART properly here, changing to
1508 * a short count if something transferred.
1509 */
1510 goto out;
1511 }
1512 }
1513
1514 /*
1515 * The number of bytes we can safely extract from the uio
1516 * depends on the available idx and buf space. Worst case,
1517 * every byte is a message so 1 idx is required per byte.
1518 * Worst case, the first byte completes a 3-byte msg in prior
1519 * state, and every subsequent byte is a Program Change or
1520 * Channel Pressure msg with running status and expands to 2
1521 * bytes, so the buf space reqd is 3+2(n-1) or 2n+1. So limit
1522 * the transfer to the min of idxspace and (bufspace-1)>>1.
1523 */
1524 xfrcount = (bufspace - 1) >> 1;
1525 if (xfrcount > idxspace)
1526 xfrcount = idxspace;
1527 if (xfrcount > sizeof inp)
1528 xfrcount = sizeof inp;
1529 if (xfrcount > uio->uio_resid)
1530 xfrcount = uio->uio_resid;
1531
1532 mutex_exit(sc->lock);
1533 error = uiomove(inp, xfrcount, uio);
1534 mutex_enter(sc->lock);
1535 #ifdef MIDI_DEBUG
1536 if (error)
1537 printf("midi_write:(1) uiomove failed %d; "
1538 "xfrcount=%zu inp=%p\n",
1539 error, xfrcount, inp);
1540 #endif
1541 if (error)
1542 break;
1543
1544 /*
1545 * The number of bytes we extracted being calculated to
1546 * definitely fit in the buffer even with canonicalization,
1547 * there is no excuse for real_writebytes to return EWOULDBLOCK.
1548 */
1549 error = real_writebytes(sc, inp, xfrcount);
1550 KASSERT(error != EWOULDBLOCK);
1551 if (error)
1552 break;
1553
1554 /*
1555 * If this is a polling device and we just sent a buffer, let's
1556 * not send another without giving some other process a chance.
1557 */
1558 if ((sc->props & MIDI_PROP_OUT_INTR) == 0)
1559 pollout = 1;
1560 DPRINTFN(8,("midiwrite: uio_resid now %zu, props=%d\n",
1561 uio->uio_resid, sc->props));
1562 }
1563
1564 out:
1565 if (--sc->refcnt < 0)
1566 cv_broadcast(&sc->detach_cv);
1567
1568 mutex_exit(sc->lock);
1569 return error;
1570 }
1571
1572 /*
1573 * This write routine is only called from sequencer code and expects
1574 * a write that is smaller than the MIDI buffer.
1575 */
1576 int
midi_writebytes(int unit,u_char * bf,int cc)1577 midi_writebytes(int unit, u_char *bf, int cc)
1578 {
1579 struct midi_softc *sc =
1580 device_lookup_private(&midi_cd, unit);
1581 int error;
1582
1583 if (!sc)
1584 return EIO;
1585
1586 DPRINTFN(7, ("midi_writebytes: %p, unit=%d, cc=%d %#02x %#02x %#02x\n",
1587 sc, unit, cc, bf[0], bf[1], bf[2]));
1588
1589 mutex_enter(sc->lock);
1590 if (sc->dying)
1591 error = EIO;
1592 else
1593 error = real_writebytes(sc, bf, cc);
1594 mutex_exit(sc->lock);
1595
1596 return error;
1597 }
1598
1599 static int
midiioctl(dev_t dev,u_long cmd,void * addr,int flag,struct lwp * l)1600 midiioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
1601 {
1602 struct midi_softc *sc;
1603 const struct midi_hw_if *hw;
1604 int error;
1605 MIDI_BUF_DECLARE(buf);
1606
1607 (void)buf_end;
1608 sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
1609
1610 mutex_enter(sc->lock);
1611 if (sc->dying) {
1612 mutex_exit(sc->lock);
1613 return EIO;
1614 }
1615 hw = sc->hw_if;
1616 error = 0;
1617
1618 sc->refcnt++;
1619
1620 DPRINTFN(5,("midiioctl: %p cmd=0x%08lx\n", sc, cmd));
1621
1622 switch (cmd) {
1623 case FIONBIO:
1624 /* All handled in the upper layer. */
1625 break;
1626
1627 case FIONREAD:
1628 /*
1629 * This code relies on the current implementation of midi_in
1630 * always updating buf and idx together in a critical section,
1631 * so buf always ends at a message boundary. Document this
1632 * ioctl as always returning a value such that the last message
1633 * included is complete (SysEx the only exception), and then
1634 * make sure the implementation doesn't regress. NB that
1635 * means if this ioctl returns n and the proc then issues a
1636 * read of n, n bytes will be read, but if the proc issues a
1637 * read of m < n, fewer than m bytes may be read to ensure the
1638 * read ends at a message boundary.
1639 */
1640 MIDI_BUF_CONSUMER_INIT(&sc->inbuf,buf);
1641 *(int *)addr = buf_lim - buf_cur;
1642 break;
1643
1644 case FIOASYNC:
1645 mutex_exit(sc->lock);
1646 mutex_enter(&proc_lock);
1647 if (*(int *)addr) {
1648 if (sc->async) {
1649 error = EBUSY;
1650 } else {
1651 sc->async = curproc->p_pid;
1652 }
1653 DPRINTFN(5,("midi_ioctl: FIOASYNC %d\n",
1654 curproc->p_pid));
1655 } else {
1656 sc->async = 0;
1657 }
1658 mutex_exit(&proc_lock);
1659 mutex_enter(sc->lock);
1660 break;
1661
1662 #if 0
1663 case MIDI_PRETIME:
1664 /* XXX OSS
1665 * This should set up a read timeout, but that's
1666 * why we have poll(), so there's nothing yet. */
1667 error = EINVAL;
1668 break;
1669 #endif
1670
1671 #ifdef MIDI_SAVE
1672 case MIDI_GETSAVE:
1673 mutex_exit(sc->lock);
1674 error = copyout(&midisave, *(void **)addr, sizeof midisave);
1675 mutex_enter(sc->lock);
1676 break;
1677 #endif
1678
1679 default:
1680 if (hw->ioctl != NULL) {
1681 error = hw->ioctl(sc->hw_hdl, cmd, addr, flag, l);
1682 } else {
1683 error = EINVAL;
1684 }
1685 break;
1686 }
1687
1688 if (--sc->refcnt < 0)
1689 cv_broadcast(&sc->detach_cv);
1690 mutex_exit(sc->lock);
1691 return error;
1692 }
1693
1694 static int
midipoll(dev_t dev,int events,struct lwp * l)1695 midipoll(dev_t dev, int events, struct lwp *l)
1696 {
1697 struct midi_softc *sc;
1698 int revents;
1699 MIDI_BUF_DECLARE(idx);
1700 MIDI_BUF_DECLARE(buf);
1701
1702 (void)buf_end; (void)idx_end;
1703 sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
1704 revents = 0;
1705
1706 DPRINTFN(6,("midipoll: %p events=0x%x\n", sc, events));
1707
1708 mutex_enter(sc->lock);
1709 if (sc->dying) {
1710 mutex_exit(sc->lock);
1711 return POLLHUP;
1712 }
1713
1714 sc->refcnt++;
1715
1716 if ((events & (POLLIN | POLLRDNORM)) != 0) {
1717 MIDI_BUF_CONSUMER_INIT(&sc->inbuf, idx);
1718 if (idx_cur < idx_lim)
1719 revents |= events & (POLLIN | POLLRDNORM);
1720 else
1721 selrecord(l, &sc->rsel);
1722 }
1723 if ((events & (POLLOUT | POLLWRNORM)) != 0) {
1724 MIDI_BUF_PRODUCER_INIT(&sc->outbuf, idx);
1725 MIDI_BUF_PRODUCER_INIT(&sc->outbuf, buf);
1726 if (idx_lim - idx_cur >= 1 && buf_lim - buf_cur >= 3)
1727 revents |= events & (POLLOUT | POLLWRNORM);
1728 else
1729 selrecord(l, &sc->wsel);
1730 }
1731
1732 if (--sc->refcnt < 0)
1733 cv_broadcast(&sc->detach_cv);
1734
1735 mutex_exit(sc->lock);
1736
1737 return revents;
1738 }
1739
1740 static void
filt_midirdetach(struct knote * kn)1741 filt_midirdetach(struct knote *kn)
1742 {
1743 struct midi_softc *sc = kn->kn_hook;
1744
1745 mutex_enter(sc->lock);
1746 selremove_knote(&sc->rsel, kn);
1747 mutex_exit(sc->lock);
1748 }
1749
1750 static int
filt_midiread(struct knote * kn,long hint)1751 filt_midiread(struct knote *kn, long hint)
1752 {
1753 struct midi_softc *sc = kn->kn_hook;
1754 MIDI_BUF_DECLARE(buf);
1755
1756 (void)buf_end;
1757 if (hint != NOTE_SUBMIT)
1758 mutex_enter(sc->lock);
1759 MIDI_BUF_CONSUMER_INIT(&sc->inbuf,buf);
1760 kn->kn_data = buf_lim - buf_cur;
1761 if (hint != NOTE_SUBMIT)
1762 mutex_exit(sc->lock);
1763 return (kn->kn_data > 0);
1764 }
1765
1766 static const struct filterops midiread_filtops = {
1767 .f_flags = FILTEROP_ISFD,
1768 .f_attach = NULL,
1769 .f_detach = filt_midirdetach,
1770 .f_event = filt_midiread,
1771 };
1772
1773 static void
filt_midiwdetach(struct knote * kn)1774 filt_midiwdetach(struct knote *kn)
1775 {
1776 struct midi_softc *sc = kn->kn_hook;
1777
1778 mutex_enter(sc->lock);
1779 selremove_knote(&sc->wsel, kn);
1780 mutex_exit(sc->lock);
1781 }
1782
1783 static int
filt_midiwrite(struct knote * kn,long hint)1784 filt_midiwrite(struct knote *kn, long hint)
1785 {
1786 struct midi_softc *sc = kn->kn_hook;
1787 MIDI_BUF_DECLARE(idx);
1788 MIDI_BUF_DECLARE(buf);
1789
1790 mutex_exit(sc->lock);
1791 sc->refcnt++;
1792 mutex_enter(sc->lock);
1793
1794 (void)idx_end; (void)buf_end;
1795 if (hint != NOTE_SUBMIT)
1796 mutex_enter(sc->lock);
1797 MIDI_BUF_PRODUCER_INIT(&sc->outbuf,idx);
1798 MIDI_BUF_PRODUCER_INIT(&sc->outbuf,buf);
1799 kn->kn_data = ((buf_lim - buf_cur)-1)>>1;
1800 if (kn->kn_data > idx_lim - idx_cur)
1801 kn->kn_data = idx_lim - idx_cur;
1802 if (hint != NOTE_SUBMIT)
1803 mutex_exit(sc->lock);
1804
1805 // XXXMRG -- move this up, avoid the relock?
1806 mutex_enter(sc->lock);
1807 if (--sc->refcnt < 0)
1808 cv_broadcast(&sc->detach_cv);
1809 mutex_exit(sc->lock);
1810
1811 return (kn->kn_data > 0);
1812 }
1813
1814 static const struct filterops midiwrite_filtops = {
1815 .f_flags = FILTEROP_ISFD,
1816 .f_attach = NULL,
1817 .f_detach = filt_midiwdetach,
1818 .f_event = filt_midiwrite,
1819 };
1820
1821 int
midikqfilter(dev_t dev,struct knote * kn)1822 midikqfilter(dev_t dev, struct knote *kn)
1823 {
1824 struct midi_softc *sc =
1825 device_lookup_private(&midi_cd, MIDIUNIT(dev));
1826 struct selinfo *sip;
1827 int error = 0;
1828
1829 mutex_enter(sc->lock);
1830 sc->refcnt++;
1831
1832 switch (kn->kn_filter) {
1833 case EVFILT_READ:
1834 sip = &sc->rsel;
1835 kn->kn_fop = &midiread_filtops;
1836 break;
1837
1838 case EVFILT_WRITE:
1839 sip = &sc->wsel;
1840 kn->kn_fop = &midiwrite_filtops;
1841 break;
1842
1843 default:
1844 error = EINVAL;
1845 goto out;
1846 }
1847
1848 kn->kn_hook = sc;
1849
1850 selrecord_knote(sip, kn);
1851 out:
1852 if (--sc->refcnt < 0)
1853 cv_broadcast(&sc->detach_cv);
1854 mutex_exit(sc->lock);
1855
1856 return (error);
1857 }
1858
1859 void
midi_getinfo(dev_t dev,struct midi_info * mi)1860 midi_getinfo(dev_t dev, struct midi_info *mi)
1861 {
1862 struct midi_softc *sc;
1863
1864 sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
1865 if (sc == NULL)
1866 return;
1867 mutex_enter(sc->lock);
1868 sc->hw_if->getinfo(sc->hw_hdl, mi);
1869 mutex_exit(sc->lock);
1870 }
1871
1872 #elif NMIDIBUS > 0 /* but NMIDI == 0 */
1873
1874 void
midi_register_hw_if_ext(struct midi_hw_if_ext * exthw)1875 midi_register_hw_if_ext(struct midi_hw_if_ext *exthw)
1876 {
1877
1878 /* nothing */
1879 }
1880
1881 #endif /* NMIDI > 0 */
1882
1883 #if NMIDI > 0 || NMIDIBUS > 0
1884
1885 device_t
midi_attach_mi(const struct midi_hw_if * mhwp,void * hdlp,device_t dev)1886 midi_attach_mi(const struct midi_hw_if *mhwp, void *hdlp, device_t dev)
1887 {
1888 struct audio_attach_args arg;
1889
1890 if (mhwp == NULL) {
1891 panic("midi_attach_mi: NULL\n");
1892 return (0);
1893 }
1894
1895 arg.type = AUDIODEV_TYPE_MIDI;
1896 arg.hwif = mhwp;
1897 arg.hdl = hdlp;
1898 return (config_found(dev, &arg, audioprint,
1899 CFARGS(.iattr = "midibus")));
1900 }
1901
1902 #endif /* NMIDI > 0 || NMIDIBUS > 0 */
1903