1 /* $NetBSD: umidi.c,v 1.91 2024/02/10 09:21:53 andvar Exp $ */
2
3 /*
4 * Copyright (c) 2001, 2012, 2014 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Takuya SHIOZAKI (tshiozak@NetBSD.org), (full-size transfers, extended
9 * hw_if) Chapman Flack (chap@NetBSD.org), and Matthew R. Green
10 * (mrg@eterna23.net).
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: umidi.c,v 1.91 2024/02/10 09:21:53 andvar Exp $");
36
37 #ifdef _KERNEL_OPT
38 #include "opt_usb.h"
39 #endif
40
41 #include <sys/types.h>
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/kmem.h>
46 #include <sys/device.h>
47 #include <sys/ioctl.h>
48 #include <sys/conf.h>
49 #include <sys/file.h>
50 #include <sys/select.h>
51 #include <sys/proc.h>
52 #include <sys/vnode.h>
53 #include <sys/poll.h>
54 #include <sys/intr.h>
55
56 #include <dev/usb/usb.h>
57 #include <dev/usb/usbdi.h>
58 #include <dev/usb/usbdi_util.h>
59
60 #include <dev/usb/usbdevs.h>
61 #include <dev/usb/umidi_quirks.h>
62 #include <dev/midi_if.h>
63
64 /* Jack Descriptor */
65 #define UMIDI_MS_HEADER 0x01
66 #define UMIDI_IN_JACK 0x02
67 #define UMIDI_OUT_JACK 0x03
68
69 /* Jack Type */
70 #define UMIDI_EMBEDDED 0x01
71 #define UMIDI_EXTERNAL 0x02
72
73 /* generic, for iteration */
74 typedef struct {
75 uByte bLength;
76 uByte bDescriptorType;
77 uByte bDescriptorSubtype;
78 } UPACKED umidi_cs_descriptor_t;
79
80 typedef struct {
81 uByte bLength;
82 uByte bDescriptorType;
83 uByte bDescriptorSubtype;
84 uWord bcdMSC;
85 uWord wTotalLength;
86 } UPACKED umidi_cs_interface_descriptor_t;
87 #define UMIDI_CS_INTERFACE_DESCRIPTOR_SIZE 7
88
89 typedef struct {
90 uByte bLength;
91 uByte bDescriptorType;
92 uByte bDescriptorSubtype;
93 uByte bNumEmbMIDIJack;
94 } UPACKED umidi_cs_endpoint_descriptor_t;
95 #define UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE 4
96
97 typedef struct {
98 uByte bLength;
99 uByte bDescriptorType;
100 uByte bDescriptorSubtype;
101 uByte bJackType;
102 uByte bJackID;
103 } UPACKED umidi_jack_descriptor_t;
104 #define UMIDI_JACK_DESCRIPTOR_SIZE 5
105
106
107 #define TO_D(p) ((usb_descriptor_t *)(p))
108 #define NEXT_D(desc) TO_D((char *)(desc)+(desc)->bLength)
109 #define TO_IFD(desc) ((usb_interface_descriptor_t *)(desc))
110 #define TO_CSIFD(desc) ((umidi_cs_interface_descriptor_t *)(desc))
111 #define TO_EPD(desc) ((usb_endpoint_descriptor_t *)(desc))
112 #define TO_CSEPD(desc) ((umidi_cs_endpoint_descriptor_t *)(desc))
113
114
115 #define UMIDI_PACKET_SIZE 4
116
117 /*
118 * hierarchy
119 *
120 * <-- parent child -->
121 *
122 * umidi(sc) -> endpoint -> jack <- (dynamically assignable) - mididev
123 * ^ | ^ |
124 * +-----+ +-----+
125 */
126
127 /* midi device */
128 struct umidi_mididev {
129 struct umidi_softc *sc;
130 device_t mdev;
131 /* */
132 struct umidi_jack *in_jack;
133 struct umidi_jack *out_jack;
134 char *label;
135 size_t label_len;
136 /* */
137 int opened;
138 int closing;
139 int flags;
140 };
141
142 /* Jack Information */
143 struct umidi_jack {
144 struct umidi_endpoint *endpoint;
145 /* */
146 int cable_number;
147 void *arg;
148 int bound;
149 int opened;
150 unsigned char *midiman_ppkt;
151 union {
152 struct {
153 void (*intr)(void *);
154 } out;
155 struct {
156 void (*intr)(void *, int);
157 } in;
158 } u;
159 };
160
161 #define UMIDI_MAX_EPJACKS 16
162 typedef unsigned char (*umidi_packet_bufp)[UMIDI_PACKET_SIZE];
163 /* endpoint data */
164 struct umidi_endpoint {
165 struct umidi_softc *sc;
166 /* */
167 int addr;
168 struct usbd_pipe *pipe;
169 struct usbd_xfer *xfer;
170 umidi_packet_bufp buffer;
171 umidi_packet_bufp next_slot;
172 uint32_t buffer_size;
173 int num_scheduled;
174 int num_open;
175 int num_jacks;
176 int soliciting;
177 void *solicit_cookie;
178 int armed;
179 struct umidi_jack *jacks[UMIDI_MAX_EPJACKS];
180 uint16_t this_schedule; /* see UMIDI_MAX_EPJACKS */
181 uint16_t next_schedule;
182 };
183
184 /* software context */
185 struct umidi_softc {
186 device_t sc_dev;
187 struct usbd_device *sc_udev;
188 struct usbd_interface *sc_iface;
189 const struct umidi_quirk *sc_quirk;
190
191 int sc_dying;
192
193 int sc_out_num_jacks;
194 struct umidi_jack *sc_out_jacks;
195 int sc_in_num_jacks;
196 struct umidi_jack *sc_in_jacks;
197 struct umidi_jack *sc_jacks;
198
199 int sc_num_mididevs;
200 struct umidi_mididev *sc_mididevs;
201
202 int sc_out_num_endpoints;
203 struct umidi_endpoint *sc_out_ep;
204 int sc_in_num_endpoints;
205 struct umidi_endpoint *sc_in_ep;
206 struct umidi_endpoint *sc_endpoints;
207 size_t sc_endpoints_len;
208 int cblnums_global;
209
210 kmutex_t sc_lock;
211 kcondvar_t sc_cv;
212 kcondvar_t sc_detach_cv;
213
214 int sc_refcnt;
215 };
216
217 #ifdef UMIDI_DEBUG
218 #define DPRINTF(x) if (umididebug) printf x
219 #define DPRINTFN(n,x) if (umididebug >= (n)) printf x
220 #include <sys/time.h>
221 static struct timeval umidi_tv;
222 int umididebug = 0;
223 #else
224 #define DPRINTF(x)
225 #define DPRINTFN(n,x)
226 #endif
227
228 #define UMIDI_ENDPOINT_SIZE(sc) (sizeof(*(sc)->sc_out_ep) * \
229 (sc->sc_out_num_endpoints + \
230 sc->sc_in_num_endpoints))
231
232
233 static int umidi_open(void *, int,
234 void (*)(void *, int), void (*)(void *), void *);
235 static void umidi_close(void *);
236 static int umidi_channelmsg(void *, int, int, u_char *, int);
237 static int umidi_commonmsg(void *, int, u_char *, int);
238 static int umidi_sysex(void *, u_char *, int);
239 static int umidi_rtmsg(void *, int);
240 static void umidi_getinfo(void *, struct midi_info *);
241 static void umidi_get_locks(void *, kmutex_t **, kmutex_t **);
242
243 static usbd_status alloc_pipe(struct umidi_endpoint *);
244 static void free_pipe(struct umidi_endpoint *);
245
246 static usbd_status alloc_all_endpoints(struct umidi_softc *);
247 static void free_all_endpoints(struct umidi_softc *);
248
249 static usbd_status alloc_all_jacks(struct umidi_softc *);
250 static void free_all_jacks(struct umidi_softc *);
251 static usbd_status bind_jacks_to_mididev(struct umidi_softc *,
252 struct umidi_jack *,
253 struct umidi_jack *,
254 struct umidi_mididev *);
255 static void unbind_jacks_from_mididev(struct umidi_mididev *);
256 static void unbind_all_jacks(struct umidi_softc *);
257 static usbd_status assign_all_jacks_automatically(struct umidi_softc *);
258 static usbd_status open_out_jack(struct umidi_jack *, void *,
259 void (*)(void *));
260 static usbd_status open_in_jack(struct umidi_jack *, void *,
261 void (*)(void *, int));
262 static void close_out_jack(struct umidi_jack *);
263 static void close_in_jack(struct umidi_jack *);
264
265 static usbd_status attach_mididev(struct umidi_softc *, struct umidi_mididev *);
266 static usbd_status detach_mididev(struct umidi_mididev *, int);
267 static void deactivate_mididev(struct umidi_mididev *);
268 static usbd_status alloc_all_mididevs(struct umidi_softc *, int);
269 static void free_all_mididevs(struct umidi_softc *);
270 static usbd_status attach_all_mididevs(struct umidi_softc *);
271 static usbd_status detach_all_mididevs(struct umidi_softc *, int);
272 static void deactivate_all_mididevs(struct umidi_softc *);
273 static void describe_mididev(struct umidi_mididev *);
274
275 #ifdef UMIDI_DEBUG
276 static void dump_sc(struct umidi_softc *);
277 static void dump_ep(struct umidi_endpoint *);
278 static void dump_jack(struct umidi_jack *);
279 #endif
280
281 static usbd_status start_input_transfer(struct umidi_endpoint *);
282 static usbd_status start_output_transfer(struct umidi_endpoint *);
283 static int out_jack_output(struct umidi_jack *, u_char *, int, int);
284 static void in_intr(struct usbd_xfer *, void *, usbd_status);
285 static void out_intr(struct usbd_xfer *, void *, usbd_status);
286 static void out_solicit(void *); /* struct umidi_endpoint* for softintr */
287 static void out_solicit_locked(void *); /* pre-locked version */
288
289
290 const struct midi_hw_if umidi_hw_if = {
291 .open = umidi_open,
292 .close = umidi_close,
293 .output = umidi_rtmsg,
294 .getinfo = umidi_getinfo,
295 .get_locks = umidi_get_locks,
296 };
297
298 struct midi_hw_if_ext umidi_hw_if_ext = {
299 .channel = umidi_channelmsg,
300 .common = umidi_commonmsg,
301 .sysex = umidi_sysex,
302 };
303
304 struct midi_hw_if_ext umidi_hw_if_mm = {
305 .channel = umidi_channelmsg,
306 .common = umidi_commonmsg,
307 .sysex = umidi_sysex,
308 .compress = 1,
309 };
310
311 static int umidi_match(device_t, cfdata_t, void *);
312 static void umidi_attach(device_t, device_t, void *);
313 static void umidi_childdet(device_t, device_t);
314 static int umidi_detach(device_t, int);
315 static int umidi_activate(device_t, enum devact);
316
317 CFATTACH_DECL2_NEW(umidi, sizeof(struct umidi_softc), umidi_match,
318 umidi_attach, umidi_detach, umidi_activate, NULL, umidi_childdet);
319
320 static int
umidi_match(device_t parent,cfdata_t match,void * aux)321 umidi_match(device_t parent, cfdata_t match, void *aux)
322 {
323 struct usbif_attach_arg *uiaa = aux;
324
325 DPRINTFN(1,("umidi_match\n"));
326
327 if (umidi_search_quirk(uiaa->uiaa_vendor, uiaa->uiaa_product,
328 uiaa->uiaa_ifaceno))
329 return UMATCH_IFACECLASS_IFACESUBCLASS;
330
331 if (uiaa->uiaa_class == UICLASS_AUDIO &&
332 uiaa->uiaa_subclass == UISUBCLASS_MIDISTREAM)
333 return UMATCH_IFACECLASS_IFACESUBCLASS;
334
335 return UMATCH_NONE;
336 }
337
338 static void
umidi_attach(device_t parent,device_t self,void * aux)339 umidi_attach(device_t parent, device_t self, void *aux)
340 {
341 usbd_status err;
342 struct umidi_softc *sc = device_private(self);
343 struct usbif_attach_arg *uiaa = aux;
344 char *devinfop;
345
346 DPRINTFN(1,("umidi_attach\n"));
347
348 sc->sc_dev = self;
349
350 aprint_naive("\n");
351 aprint_normal("\n");
352
353 devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0);
354 aprint_normal_dev(self, "%s\n", devinfop);
355 usbd_devinfo_free(devinfop);
356
357 sc->sc_iface = uiaa->uiaa_iface;
358 sc->sc_udev = uiaa->uiaa_device;
359
360 sc->sc_quirk = umidi_search_quirk(uiaa->uiaa_vendor,
361 uiaa->uiaa_product, uiaa->uiaa_ifaceno);
362
363 aprint_normal_dev(self, "");
364 umidi_print_quirk(sc->sc_quirk);
365
366 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
367 cv_init(&sc->sc_cv, "umidopcl");
368 cv_init(&sc->sc_detach_cv, "umidetcv");
369 sc->sc_refcnt = 0;
370
371 err = alloc_all_endpoints(sc);
372 if (err != USBD_NORMAL_COMPLETION) {
373 aprint_error_dev(self,
374 "alloc_all_endpoints failed. (err=%d)\n", err);
375 goto out;
376 }
377 err = alloc_all_jacks(sc);
378 if (err != USBD_NORMAL_COMPLETION) {
379 aprint_error_dev(self, "alloc_all_jacks failed. (err=%d)\n",
380 err);
381 goto out_free_endpoints;
382 }
383 aprint_normal_dev(self, "out=%d, in=%d\n",
384 sc->sc_out_num_jacks, sc->sc_in_num_jacks);
385
386 err = assign_all_jacks_automatically(sc);
387 if (err != USBD_NORMAL_COMPLETION) {
388 aprint_error_dev(self,
389 "assign_all_jacks_automatically failed. (err=%d)\n", err);
390 goto out_free_jacks;
391 }
392 err = attach_all_mididevs(sc);
393 if (err != USBD_NORMAL_COMPLETION) {
394 aprint_error_dev(self,
395 "attach_all_mididevs failed. (err=%d)\n", err);
396 goto out_free_jacks;
397 }
398
399 #ifdef UMIDI_DEBUG
400 dump_sc(sc);
401 #endif
402
403 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
404
405 return;
406
407 out_free_jacks:
408 unbind_all_jacks(sc);
409 free_all_jacks(sc);
410
411 out_free_endpoints:
412 free_all_endpoints(sc);
413
414 out:
415 aprint_error_dev(self, "disabled.\n");
416 sc->sc_dying = 1;
417 return;
418 }
419
420 static void
umidi_childdet(device_t self,device_t child)421 umidi_childdet(device_t self, device_t child)
422 {
423 int i;
424 struct umidi_softc *sc = device_private(self);
425
426 KASSERT(sc->sc_mididevs != NULL);
427
428 for (i = 0; i < sc->sc_num_mididevs; i++) {
429 if (sc->sc_mididevs[i].mdev == child)
430 break;
431 }
432 KASSERT(i < sc->sc_num_mididevs);
433 sc->sc_mididevs[i].mdev = NULL;
434 }
435
436 static int
umidi_activate(device_t self,enum devact act)437 umidi_activate(device_t self, enum devact act)
438 {
439 struct umidi_softc *sc = device_private(self);
440
441 switch (act) {
442 case DVACT_DEACTIVATE:
443 DPRINTFN(1,("umidi_activate (deactivate)\n"));
444 sc->sc_dying = 1;
445 deactivate_all_mididevs(sc);
446 return 0;
447 default:
448 DPRINTFN(1,("umidi_activate (%d)\n", act));
449 return EOPNOTSUPP;
450 }
451 }
452
453 static int
umidi_detach(device_t self,int flags)454 umidi_detach(device_t self, int flags)
455 {
456 struct umidi_softc *sc = device_private(self);
457
458 DPRINTFN(1,("umidi_detach\n"));
459
460 mutex_enter(&sc->sc_lock);
461 sc->sc_dying = 1;
462 if (--sc->sc_refcnt >= 0)
463 if (cv_timedwait(&sc->sc_detach_cv, &sc->sc_lock, hz * 60))
464 aprint_error_dev(self, ": didn't detach\n");
465 mutex_exit(&sc->sc_lock);
466
467 detach_all_mididevs(sc, flags);
468 free_all_mididevs(sc);
469 free_all_jacks(sc);
470 free_all_endpoints(sc);
471
472 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
473
474 mutex_destroy(&sc->sc_lock);
475 cv_destroy(&sc->sc_detach_cv);
476 cv_destroy(&sc->sc_cv);
477
478 return 0;
479 }
480
481
482 /*
483 * midi_if stuffs
484 */
485 int
umidi_open(void * addr,int flags,void (* iintr)(void *,int),void (* ointr)(void *),void * arg)486 umidi_open(void *addr,
487 int flags,
488 void (*iintr)(void *, int),
489 void (*ointr)(void *),
490 void *arg)
491 {
492 struct umidi_mididev *mididev = addr;
493 struct umidi_softc *sc = mididev->sc;
494 usbd_status err;
495
496 KASSERT(mutex_owned(&sc->sc_lock));
497 DPRINTF(("umidi_open: sc=%p\n", sc));
498
499 if (mididev->opened)
500 return EBUSY;
501 if (sc->sc_dying)
502 return EIO;
503
504 mididev->opened = 1;
505 mididev->flags = flags;
506 if ((mididev->flags & FWRITE) && mididev->out_jack) {
507 err = open_out_jack(mididev->out_jack, arg, ointr);
508 if (err != USBD_NORMAL_COMPLETION)
509 goto bad;
510 }
511 if ((mididev->flags & FREAD) && mididev->in_jack) {
512 err = open_in_jack(mididev->in_jack, arg, iintr);
513 KASSERT(mididev->opened);
514 if (err != USBD_NORMAL_COMPLETION &&
515 err != USBD_IN_PROGRESS) {
516 if (mididev->out_jack)
517 close_out_jack(mididev->out_jack);
518 goto bad;
519 }
520 }
521
522 return 0;
523 bad:
524 mididev->opened = 0;
525 DPRINTF(("umidi_open: usbd_status %d\n", err));
526 KASSERT(mutex_owned(&sc->sc_lock));
527 return USBD_IN_USE == err ? EBUSY : EIO;
528 }
529
530 void
umidi_close(void * addr)531 umidi_close(void *addr)
532 {
533 struct umidi_mididev *mididev = addr;
534 struct umidi_softc *sc = mididev->sc;
535
536 KASSERT(mutex_owned(&sc->sc_lock));
537
538 if (mididev->closing)
539 return;
540
541 mididev->closing = 1;
542
543 sc->sc_refcnt++;
544
545 if ((mididev->flags & FWRITE) && mididev->out_jack)
546 close_out_jack(mididev->out_jack);
547 if ((mididev->flags & FREAD) && mididev->in_jack)
548 close_in_jack(mididev->in_jack);
549
550 if (--sc->sc_refcnt < 0)
551 cv_broadcast(&sc->sc_detach_cv);
552
553 mididev->opened = 0;
554 mididev->closing = 0;
555 }
556
557 int
umidi_channelmsg(void * addr,int status,int channel,u_char * msg,int len)558 umidi_channelmsg(void *addr, int status, int channel, u_char *msg,
559 int len)
560 {
561 struct umidi_mididev *mididev = addr;
562
563 KASSERT(mutex_owned(&mididev->sc->sc_lock));
564
565 if (!mididev->out_jack || !mididev->opened || mididev->closing)
566 return EIO;
567
568 return out_jack_output(mididev->out_jack, msg, len, (status>>4)&0xf);
569 }
570
571 int
umidi_commonmsg(void * addr,int status,u_char * msg,int len)572 umidi_commonmsg(void *addr, int status, u_char *msg, int len)
573 {
574 struct umidi_mididev *mididev = addr;
575 int cin;
576
577 KASSERT(mutex_owned(&mididev->sc->sc_lock));
578
579 if (!mididev->out_jack || !mididev->opened || mididev->closing)
580 return EIO;
581
582 switch ( len ) {
583 case 1: cin = 5; break;
584 case 2: cin = 2; break;
585 case 3: cin = 3; break;
586 default: return EIO; /* or gcc warns of cin uninitialized */
587 }
588
589 return out_jack_output(mididev->out_jack, msg, len, cin);
590 }
591
592 int
umidi_sysex(void * addr,u_char * msg,int len)593 umidi_sysex(void *addr, u_char *msg, int len)
594 {
595 struct umidi_mididev *mididev = addr;
596 int cin;
597
598 KASSERT(mutex_owned(&mididev->sc->sc_lock));
599
600 if (!mididev->out_jack || !mididev->opened || mididev->closing)
601 return EIO;
602
603 switch ( len ) {
604 case 1: cin = 5; break;
605 case 2: cin = 6; break;
606 case 3: cin = (msg[2] == 0xf7) ? 7 : 4; break;
607 default: return EIO; /* or gcc warns of cin uninitialized */
608 }
609
610 return out_jack_output(mididev->out_jack, msg, len, cin);
611 }
612
613 int
umidi_rtmsg(void * addr,int d)614 umidi_rtmsg(void *addr, int d)
615 {
616 struct umidi_mididev *mididev = addr;
617 u_char msg = d;
618
619 KASSERT(mutex_owned(&mididev->sc->sc_lock));
620
621 if (!mididev->out_jack || !mididev->opened || mididev->closing)
622 return EIO;
623
624 return out_jack_output(mididev->out_jack, &msg, 1, 0xf);
625 }
626
627 void
umidi_getinfo(void * addr,struct midi_info * mi)628 umidi_getinfo(void *addr, struct midi_info *mi)
629 {
630 struct umidi_mididev *mididev = addr;
631 struct umidi_softc *sc = mididev->sc;
632 int mm = UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE);
633
634 KASSERT(mutex_owned(&sc->sc_lock));
635
636 mi->name = mididev->label;
637 mi->props = MIDI_PROP_OUT_INTR;
638 if (mididev->in_jack)
639 mi->props |= MIDI_PROP_CAN_INPUT;
640 midi_register_hw_if_ext(mm? &umidi_hw_if_mm : &umidi_hw_if_ext);
641 }
642
643 static void
umidi_get_locks(void * addr,kmutex_t ** thread,kmutex_t ** intr)644 umidi_get_locks(void *addr, kmutex_t **thread, kmutex_t **intr)
645 {
646 struct umidi_mididev *mididev = addr;
647 struct umidi_softc *sc = mididev->sc;
648
649 *intr = NULL;
650 *thread = &sc->sc_lock;
651 }
652
653 /*
654 * each endpoint stuffs
655 */
656
657 /* alloc/free pipe */
658 static usbd_status
alloc_pipe(struct umidi_endpoint * ep)659 alloc_pipe(struct umidi_endpoint *ep)
660 {
661 struct umidi_softc *sc = ep->sc;
662 usbd_status err;
663 usb_endpoint_descriptor_t *epd;
664
665 epd = usbd_get_endpoint_descriptor(sc->sc_iface, ep->addr);
666 /*
667 * For output, an improvement would be to have a buffer bigger than
668 * wMaxPacketSize by num_jacks-1 additional packet slots; that would
669 * allow out_solicit to fill the buffer to the full packet size in
670 * all cases. But to use usbd_create_xfer to get a slightly larger
671 * buffer would not be a good way to do that, because if the addition
672 * would make the buffer exceed USB_MEM_SMALL then a substantially
673 * larger block may be wastefully allocated. Some flavor of double
674 * buffering could serve the same purpose, but would increase the
675 * code complexity, so for now I will live with the current slight
676 * penalty of reducing max transfer size by (num_open-num_scheduled)
677 * packet slots.
678 */
679 ep->buffer_size = UGETW(epd->wMaxPacketSize);
680 ep->buffer_size -= ep->buffer_size % UMIDI_PACKET_SIZE;
681
682 DPRINTF(("%s: alloc_pipe %p, buffer size %u\n",
683 device_xname(sc->sc_dev), ep, ep->buffer_size));
684 ep->num_scheduled = 0;
685 ep->this_schedule = 0;
686 ep->next_schedule = 0;
687 ep->soliciting = 0;
688 ep->armed = 0;
689 err = usbd_open_pipe(sc->sc_iface, ep->addr, USBD_MPSAFE, &ep->pipe);
690 if (err)
691 goto quit;
692 int error = usbd_create_xfer(ep->pipe, ep->buffer_size,
693 0, 0, &ep->xfer);
694 if (error) {
695 usbd_close_pipe(ep->pipe);
696 return USBD_NOMEM;
697 }
698 ep->buffer = usbd_get_buffer(ep->xfer);
699 ep->next_slot = ep->buffer;
700 ep->solicit_cookie = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE,
701 out_solicit, ep);
702 quit:
703 return err;
704 }
705
706 static void
free_pipe(struct umidi_endpoint * ep)707 free_pipe(struct umidi_endpoint *ep)
708 {
709 DPRINTF(("%s: free_pipe %p\n", device_xname(ep->sc->sc_dev), ep));
710 usbd_abort_pipe(ep->pipe);
711 usbd_destroy_xfer(ep->xfer);
712 usbd_close_pipe(ep->pipe);
713 softint_disestablish(ep->solicit_cookie);
714 }
715
716
717 /* alloc/free the array of endpoint structures */
718
719 static usbd_status alloc_all_endpoints_fixed_ep(struct umidi_softc *);
720 static usbd_status alloc_all_endpoints_yamaha(struct umidi_softc *);
721 static usbd_status alloc_all_endpoints_genuine(struct umidi_softc *);
722
723 static usbd_status
alloc_all_endpoints(struct umidi_softc * sc)724 alloc_all_endpoints(struct umidi_softc *sc)
725 {
726 usbd_status err;
727 int i, n;
728
729 if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) {
730 err = alloc_all_endpoints_fixed_ep(sc);
731 } else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) {
732 err = alloc_all_endpoints_yamaha(sc);
733 } else {
734 err = alloc_all_endpoints_genuine(sc);
735 }
736 if (err != USBD_NORMAL_COMPLETION)
737 return err;
738
739 n = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints;
740 for (i = 0; i < n; i++) {
741 err = alloc_pipe(&sc->sc_endpoints[i]);
742 if (err != USBD_NORMAL_COMPLETION) {
743 while (i --> 0)
744 free_pipe(&sc->sc_endpoints[i]);
745 kmem_free(sc->sc_endpoints, sc->sc_endpoints_len);
746 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL;
747 break;
748 }
749 }
750 return err;
751 }
752
753 static void
free_all_endpoints(struct umidi_softc * sc)754 free_all_endpoints(struct umidi_softc *sc)
755 {
756 int i, n;
757
758 if (sc->sc_endpoints == NULL) {
759 /* nothing to free */
760 return;
761 }
762
763 n = sc->sc_in_num_endpoints + sc->sc_out_num_endpoints;
764 for (i = 0; i < n; i++)
765 free_pipe(&sc->sc_endpoints[i]);
766 kmem_free(sc->sc_endpoints, sc->sc_endpoints_len);
767 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL;
768 }
769
770 static usbd_status
alloc_all_endpoints_fixed_ep(struct umidi_softc * sc)771 alloc_all_endpoints_fixed_ep(struct umidi_softc *sc)
772 {
773 usbd_status err;
774 const struct umq_fixed_ep_desc *fp;
775 struct umidi_endpoint *ep;
776 usb_endpoint_descriptor_t *epd;
777 int i;
778
779 fp = umidi_get_quirk_data_from_type(sc->sc_quirk,
780 UMQ_TYPE_FIXED_EP);
781 if (fp->num_in_ep == 0 && fp->num_out_ep == 0)
782 return USBD_INVAL;
783 sc->sc_out_num_jacks = 0;
784 sc->sc_in_num_jacks = 0;
785 sc->sc_out_num_endpoints = fp->num_out_ep;
786 sc->sc_in_num_endpoints = fp->num_in_ep;
787 sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc);
788 sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP);
789 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL;
790 sc->sc_in_ep =
791 sc->sc_in_num_endpoints ?
792 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL;
793
794 ep = &sc->sc_out_ep[0];
795 for (i = 0; i < sc->sc_out_num_endpoints; i++) {
796 epd = usbd_interface2endpoint_descriptor(
797 sc->sc_iface,
798 fp->out_ep[i].ep);
799 if (!epd) {
800 aprint_error_dev(sc->sc_dev,
801 "cannot get endpoint descriptor(out:%d)\n",
802 fp->out_ep[i].ep);
803 err = USBD_INVAL;
804 goto error;
805 }
806 if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK ||
807 UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_OUT) {
808 aprint_error_dev(sc->sc_dev,
809 "illegal endpoint(out:%d)\n", fp->out_ep[i].ep);
810 err = USBD_INVAL;
811 goto error;
812 }
813 ep->sc = sc;
814 ep->addr = epd->bEndpointAddress;
815 ep->num_jacks = fp->out_ep[i].num_jacks;
816 sc->sc_out_num_jacks += fp->out_ep[i].num_jacks;
817 ep->num_open = 0;
818 ep++;
819 }
820 ep = &sc->sc_in_ep[0];
821 for (i = 0; i < sc->sc_in_num_endpoints; i++) {
822 epd = usbd_interface2endpoint_descriptor(
823 sc->sc_iface,
824 fp->in_ep[i].ep);
825 if (!epd) {
826 aprint_error_dev(sc->sc_dev,
827 "cannot get endpoint descriptor(in:%d)\n",
828 fp->in_ep[i].ep);
829 err = USBD_INVAL;
830 goto error;
831 }
832 /*
833 * MIDISPORT_2X4 inputs on an interrupt rather than a bulk
834 * endpoint. The existing input logic in this driver seems
835 * to work successfully if we just stop treating an interrupt
836 * endpoint as illegal (or the in_progress status we get on
837 * the initial transfer). It does not seem necessary to
838 * actually use the interrupt flavor of alloc_pipe or make
839 * other serious rearrangements of logic. I like that.
840 */
841 switch ( UE_GET_XFERTYPE(epd->bmAttributes) ) {
842 case UE_BULK:
843 case UE_INTERRUPT:
844 if (UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress))
845 break;
846 /*FALLTHROUGH*/
847 default:
848 aprint_error_dev(sc->sc_dev,
849 "illegal endpoint(in:%d)\n", fp->in_ep[i].ep);
850 err = USBD_INVAL;
851 goto error;
852 }
853
854 ep->sc = sc;
855 ep->addr = epd->bEndpointAddress;
856 ep->num_jacks = fp->in_ep[i].num_jacks;
857 sc->sc_in_num_jacks += fp->in_ep[i].num_jacks;
858 ep->num_open = 0;
859 ep++;
860 }
861
862 return USBD_NORMAL_COMPLETION;
863 error:
864 kmem_free(sc->sc_endpoints, UMIDI_ENDPOINT_SIZE(sc));
865 sc->sc_endpoints = NULL;
866 return err;
867 }
868
869 static usbd_status
alloc_all_endpoints_yamaha(struct umidi_softc * sc)870 alloc_all_endpoints_yamaha(struct umidi_softc *sc)
871 {
872 /* This driver currently supports max 1in/1out bulk endpoints */
873 char *end;
874 usb_config_descriptor_t *cdesc;
875 usb_descriptor_t *desc;
876 umidi_cs_descriptor_t *csdesc;
877 usb_interface_descriptor_t *idesc;
878 umidi_cs_interface_descriptor_t *udesc;
879 usb_endpoint_descriptor_t *epd;
880 int out_addr, in_addr, i;
881 int dir;
882
883 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0;
884 out_addr = in_addr = 0;
885
886 /* detect endpoints */
887 cdesc = usbd_get_config_descriptor(sc->sc_udev);
888 end = (char *)cdesc + UGETW(cdesc->wTotalLength);
889 idesc = usbd_get_interface_descriptor(sc->sc_iface);
890 KASSERT((char *)cdesc <= (char *)idesc);
891 KASSERT((char *)idesc < end);
892 KASSERT(end - (char *)idesc >= sizeof(*idesc));
893 KASSERT(idesc->bLength >= sizeof(*idesc));
894 KASSERT(idesc->bLength <= end - (char *)idesc);
895 for (i = idesc->bNumEndpoints; i --> 0;) {
896 epd = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
897 KASSERT(epd != NULL);
898 if (UE_GET_XFERTYPE(epd->bmAttributes) == UE_BULK) {
899 dir = UE_GET_DIR(epd->bEndpointAddress);
900 if (dir == UE_DIR_OUT && !out_addr)
901 out_addr = epd->bEndpointAddress;
902 else if (dir == UE_DIR_IN && !in_addr)
903 in_addr = epd->bEndpointAddress;
904 }
905 }
906 desc = NEXT_D(idesc);
907 if ((char *)desc > end || end - (char *)desc < sizeof(*desc) ||
908 desc->bLength < sizeof(*desc) ||
909 desc->bLength > end - (char *)desc)
910 return USBD_INVAL;
911
912 /* count jacks */
913 if (desc->bDescriptorType != UDESC_CS_INTERFACE ||
914 desc->bLength < sizeof(*csdesc))
915 return USBD_INVAL;
916 csdesc = (umidi_cs_descriptor_t *)desc;
917 if (csdesc->bDescriptorSubtype != UMIDI_MS_HEADER)
918 return USBD_INVAL;
919 udesc = TO_CSIFD(csdesc);
920 if (UGETW(udesc->wTotalLength) > end - (char *)udesc)
921 return USBD_INVAL;
922 if (UGETW(udesc->wTotalLength) < udesc->bLength)
923 return USBD_INVAL;
924 end = (char *)udesc + UGETW(udesc->wTotalLength);
925 desc = NEXT_D(udesc);
926
927 for (; end - (char *)desc >= sizeof(*desc); desc = NEXT_D(desc)) {
928 if (desc->bLength < sizeof(*desc) ||
929 desc->bLength > end - (char *)desc)
930 break;
931 if (desc->bDescriptorType != UDESC_CS_INTERFACE ||
932 desc->bLength < sizeof(*csdesc) ||
933 desc->bLength < UMIDI_JACK_DESCRIPTOR_SIZE)
934 continue;
935 csdesc = (umidi_cs_descriptor_t *)desc;
936 if (csdesc->bDescriptorSubtype == UMIDI_OUT_JACK)
937 sc->sc_out_num_jacks++;
938 else if (csdesc->bDescriptorSubtype == UMIDI_IN_JACK)
939 sc->sc_in_num_jacks++;
940 }
941
942 /* validate some parameters */
943 if (sc->sc_out_num_jacks > UMIDI_MAX_EPJACKS)
944 sc->sc_out_num_jacks = UMIDI_MAX_EPJACKS;
945 if (sc->sc_in_num_jacks > UMIDI_MAX_EPJACKS)
946 sc->sc_in_num_jacks = UMIDI_MAX_EPJACKS;
947 if (sc->sc_out_num_jacks && out_addr) {
948 sc->sc_out_num_endpoints = 1;
949 } else {
950 sc->sc_out_num_endpoints = 0;
951 sc->sc_out_num_jacks = 0;
952 }
953 if (sc->sc_in_num_jacks && in_addr) {
954 sc->sc_in_num_endpoints = 1;
955 } else {
956 sc->sc_in_num_endpoints = 0;
957 sc->sc_in_num_jacks = 0;
958 }
959 sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc);
960 if (sc->sc_endpoints_len == 0)
961 return USBD_INVAL;
962 sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP);
963 if (sc->sc_out_num_endpoints) {
964 sc->sc_out_ep = sc->sc_endpoints;
965 sc->sc_out_ep->sc = sc;
966 sc->sc_out_ep->addr = out_addr;
967 sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks;
968 sc->sc_out_ep->num_open = 0;
969 } else
970 sc->sc_out_ep = NULL;
971
972 if (sc->sc_in_num_endpoints) {
973 sc->sc_in_ep = sc->sc_endpoints + sc->sc_out_num_endpoints;
974 sc->sc_in_ep->sc = sc;
975 sc->sc_in_ep->addr = in_addr;
976 sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks;
977 sc->sc_in_ep->num_open = 0;
978 } else
979 sc->sc_in_ep = NULL;
980
981 return USBD_NORMAL_COMPLETION;
982 }
983
984 static usbd_status
alloc_all_endpoints_genuine(struct umidi_softc * sc)985 alloc_all_endpoints_genuine(struct umidi_softc *sc)
986 {
987 usb_interface_descriptor_t *interface_desc;
988 usb_config_descriptor_t *config_desc;
989 usb_descriptor_t *desc;
990 char *end;
991 int num_ep;
992 struct umidi_endpoint *p, *q, *lowest, *endep, tmpep;
993 int epaddr;
994
995 interface_desc = usbd_get_interface_descriptor(sc->sc_iface);
996 num_ep = interface_desc->bNumEndpoints;
997 if (num_ep == 0)
998 return USBD_INVAL;
999 sc->sc_endpoints_len = sizeof(struct umidi_endpoint) * num_ep;
1000 sc->sc_endpoints = p = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP);
1001 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0;
1002 sc->sc_out_num_endpoints = sc->sc_in_num_endpoints = 0;
1003 epaddr = -1;
1004
1005 /* get the list of endpoints for midi stream */
1006 config_desc = usbd_get_config_descriptor(sc->sc_udev);
1007 end = (char *)config_desc + UGETW(config_desc->wTotalLength);
1008 desc = TO_D(config_desc);
1009 for (; end - (char *)desc >= sizeof(*desc); desc = NEXT_D(desc)) {
1010 if (desc->bLength < sizeof(*desc) ||
1011 desc->bLength > end - (char *)desc)
1012 break;
1013 if (desc->bDescriptorType == UDESC_ENDPOINT &&
1014 desc->bLength >= sizeof(*TO_EPD(desc)) &&
1015 UE_GET_XFERTYPE(TO_EPD(desc)->bmAttributes) == UE_BULK) {
1016 epaddr = TO_EPD(desc)->bEndpointAddress;
1017 } else if (desc->bDescriptorType == UDESC_CS_ENDPOINT &&
1018 desc->bLength >= sizeof(*TO_CSEPD(desc)) &&
1019 epaddr != -1) {
1020 if (num_ep > 0) {
1021 num_ep--;
1022 p->sc = sc;
1023 p->addr = epaddr;
1024 p->num_jacks = TO_CSEPD(desc)->bNumEmbMIDIJack;
1025 if (UE_GET_DIR(epaddr) == UE_DIR_OUT) {
1026 sc->sc_out_num_endpoints++;
1027 sc->sc_out_num_jacks += p->num_jacks;
1028 } else {
1029 sc->sc_in_num_endpoints++;
1030 sc->sc_in_num_jacks += p->num_jacks;
1031 }
1032 p++;
1033 }
1034 } else
1035 epaddr = -1;
1036 }
1037
1038 /* sort endpoints */
1039 num_ep = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints;
1040 p = sc->sc_endpoints;
1041 endep = p + num_ep;
1042 while (p<endep) {
1043 lowest = p;
1044 for (q=p+1; q<endep; q++) {
1045 if ((UE_GET_DIR(lowest->addr)==UE_DIR_IN &&
1046 UE_GET_DIR(q->addr)==UE_DIR_OUT) ||
1047 ((UE_GET_DIR(lowest->addr)==
1048 UE_GET_DIR(q->addr)) &&
1049 (UE_GET_ADDR(lowest->addr)>
1050 UE_GET_ADDR(q->addr))))
1051 lowest = q;
1052 }
1053 if (lowest != p) {
1054 memcpy((void *)&tmpep, (void *)p, sizeof(tmpep));
1055 memcpy((void *)p, (void *)lowest, sizeof(tmpep));
1056 memcpy((void *)lowest, (void *)&tmpep, sizeof(tmpep));
1057 }
1058 p->num_open = 0;
1059 p++;
1060 }
1061
1062 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL;
1063 sc->sc_in_ep =
1064 sc->sc_in_num_endpoints ?
1065 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL;
1066
1067 return USBD_NORMAL_COMPLETION;
1068 }
1069
1070
1071 /*
1072 * jack stuffs
1073 */
1074
1075 static usbd_status
alloc_all_jacks(struct umidi_softc * sc)1076 alloc_all_jacks(struct umidi_softc *sc)
1077 {
1078 int i, j;
1079 struct umidi_endpoint *ep;
1080 struct umidi_jack *jack;
1081 const unsigned char *cn_spec;
1082
1083 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_PER_EP))
1084 sc->cblnums_global = 0;
1085 else if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_GLOBAL))
1086 sc->cblnums_global = 1;
1087 else {
1088 /*
1089 * I don't think this default is correct, but it preserves
1090 * the prior behavior of the code. That's why I defined two
1091 * complementary quirks. Any device for which the default
1092 * behavior is wrong can be made to work by giving it an
1093 * explicit quirk, and if a pattern ever develops (as I suspect
1094 * it will) that a lot of otherwise standard USB MIDI devices
1095 * need the CN_SEQ_PER_EP "quirk," then this default can be
1096 * changed to 0, and the only devices that will break are those
1097 * listing neither quirk, and they'll easily be fixed by giving
1098 * them the CN_SEQ_GLOBAL quirk.
1099 */
1100 sc->cblnums_global = 1;
1101 }
1102
1103 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_FIXED))
1104 cn_spec = umidi_get_quirk_data_from_type(sc->sc_quirk,
1105 UMQ_TYPE_CN_FIXED);
1106 else
1107 cn_spec = NULL;
1108
1109 /* allocate/initialize structures */
1110 if (sc->sc_in_num_jacks == 0 && sc->sc_out_num_jacks == 0)
1111 return USBD_INVAL;
1112 sc->sc_jacks = kmem_zalloc(sizeof(*sc->sc_out_jacks) *
1113 (sc->sc_in_num_jacks + sc->sc_out_num_jacks), KM_SLEEP);
1114 if (!sc->sc_jacks)
1115 return USBD_NOMEM;
1116 sc->sc_out_jacks =
1117 sc->sc_out_num_jacks ? sc->sc_jacks : NULL;
1118 sc->sc_in_jacks =
1119 sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL;
1120
1121 jack = &sc->sc_out_jacks[0];
1122 for (i = 0; i < sc->sc_out_num_jacks; i++) {
1123 jack->opened = 0;
1124 jack->bound = 0;
1125 jack->arg = NULL;
1126 jack->u.out.intr = NULL;
1127 jack->midiman_ppkt = NULL;
1128 if (sc->cblnums_global)
1129 jack->cable_number = i;
1130 jack++;
1131 }
1132 jack = &sc->sc_in_jacks[0];
1133 for (i = 0; i < sc->sc_in_num_jacks; i++) {
1134 jack->opened = 0;
1135 jack->bound = 0;
1136 jack->arg = NULL;
1137 jack->u.in.intr = NULL;
1138 if (sc->cblnums_global)
1139 jack->cable_number = i;
1140 jack++;
1141 }
1142
1143 /* assign each jacks to each endpoints */
1144 jack = &sc->sc_out_jacks[0];
1145 ep = &sc->sc_out_ep[0];
1146 for (i = 0; i < sc->sc_out_num_endpoints; i++) {
1147 for (j = 0; j < ep->num_jacks; j++) {
1148 jack->endpoint = ep;
1149 if (cn_spec != NULL)
1150 jack->cable_number = *cn_spec++;
1151 else if (!sc->cblnums_global)
1152 jack->cable_number = j;
1153 ep->jacks[jack->cable_number] = jack;
1154 jack++;
1155 }
1156 ep++;
1157 }
1158 jack = &sc->sc_in_jacks[0];
1159 ep = &sc->sc_in_ep[0];
1160 for (i = 0; i < sc->sc_in_num_endpoints; i++) {
1161 for (j = 0; j < ep->num_jacks; j++) {
1162 jack->endpoint = ep;
1163 if (cn_spec != NULL)
1164 jack->cable_number = *cn_spec++;
1165 else if (!sc->cblnums_global)
1166 jack->cable_number = j;
1167 ep->jacks[jack->cable_number] = jack;
1168 jack++;
1169 }
1170 ep++;
1171 }
1172
1173 return USBD_NORMAL_COMPLETION;
1174 }
1175
1176 static void
free_all_jacks(struct umidi_softc * sc)1177 free_all_jacks(struct umidi_softc *sc)
1178 {
1179 struct umidi_jack *jacks;
1180 size_t len;
1181
1182 mutex_enter(&sc->sc_lock);
1183 jacks = sc->sc_jacks;
1184 len = sizeof(*sc->sc_out_jacks) *
1185 (sc->sc_in_num_jacks + sc->sc_out_num_jacks);
1186 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL;
1187 mutex_exit(&sc->sc_lock);
1188
1189 if (jacks)
1190 kmem_free(jacks, len);
1191 }
1192
1193 static usbd_status
bind_jacks_to_mididev(struct umidi_softc * sc,struct umidi_jack * out_jack,struct umidi_jack * in_jack,struct umidi_mididev * mididev)1194 bind_jacks_to_mididev(struct umidi_softc *sc,
1195 struct umidi_jack *out_jack,
1196 struct umidi_jack *in_jack,
1197 struct umidi_mididev *mididev)
1198 {
1199 if ((out_jack && out_jack->bound) || (in_jack && in_jack->bound))
1200 return USBD_IN_USE;
1201 if (mididev->out_jack || mididev->in_jack)
1202 return USBD_IN_USE;
1203
1204 if (out_jack)
1205 out_jack->bound = 1;
1206 if (in_jack)
1207 in_jack->bound = 1;
1208 mididev->in_jack = in_jack;
1209 mididev->out_jack = out_jack;
1210
1211 mididev->closing = 0;
1212
1213 return USBD_NORMAL_COMPLETION;
1214 }
1215
1216 static void
unbind_jacks_from_mididev(struct umidi_mididev * mididev)1217 unbind_jacks_from_mididev(struct umidi_mididev *mididev)
1218 {
1219 KASSERT(mutex_owned(&mididev->sc->sc_lock));
1220
1221 mididev->closing = 1;
1222
1223 if ((mididev->flags & FWRITE) && mididev->out_jack)
1224 close_out_jack(mididev->out_jack);
1225 if ((mididev->flags & FREAD) && mididev->in_jack)
1226 close_in_jack(mididev->in_jack);
1227
1228 if (mididev->out_jack) {
1229 mididev->out_jack->bound = 0;
1230 mididev->out_jack = NULL;
1231 }
1232 if (mididev->in_jack) {
1233 mididev->in_jack->bound = 0;
1234 mididev->in_jack = NULL;
1235 }
1236 }
1237
1238 static void
unbind_all_jacks(struct umidi_softc * sc)1239 unbind_all_jacks(struct umidi_softc *sc)
1240 {
1241 int i;
1242
1243 mutex_enter(&sc->sc_lock);
1244 if (sc->sc_mididevs)
1245 for (i = 0; i < sc->sc_num_mididevs; i++)
1246 unbind_jacks_from_mididev(&sc->sc_mididevs[i]);
1247 mutex_exit(&sc->sc_lock);
1248 }
1249
1250 static usbd_status
assign_all_jacks_automatically(struct umidi_softc * sc)1251 assign_all_jacks_automatically(struct umidi_softc *sc)
1252 {
1253 usbd_status err;
1254 int i;
1255 struct umidi_jack *out, *in;
1256 const signed char *asg_spec;
1257
1258 err =
1259 alloc_all_mididevs(sc,
1260 uimax(sc->sc_out_num_jacks, sc->sc_in_num_jacks));
1261 if (err!=USBD_NORMAL_COMPLETION)
1262 return err;
1263
1264 if (UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED))
1265 asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk,
1266 UMQ_TYPE_MD_FIXED);
1267 else
1268 asg_spec = NULL;
1269
1270 for (i = 0; i < sc->sc_num_mididevs; i++) {
1271 if (asg_spec != NULL) {
1272 if (*asg_spec == -1)
1273 out = NULL;
1274 else
1275 out = &sc->sc_out_jacks[*asg_spec];
1276 ++ asg_spec;
1277 if (*asg_spec == -1)
1278 in = NULL;
1279 else
1280 in = &sc->sc_in_jacks[*asg_spec];
1281 ++ asg_spec;
1282 } else {
1283 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i]
1284 : NULL;
1285 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i]
1286 : NULL;
1287 }
1288 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]);
1289 if (err != USBD_NORMAL_COMPLETION) {
1290 free_all_mididevs(sc);
1291 return err;
1292 }
1293 }
1294
1295 return USBD_NORMAL_COMPLETION;
1296 }
1297
1298 static usbd_status
open_out_jack(struct umidi_jack * jack,void * arg,void (* intr)(void *))1299 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *))
1300 {
1301 struct umidi_endpoint *ep = jack->endpoint;
1302 struct umidi_softc *sc = ep->sc;
1303 umidi_packet_bufp end;
1304 int err;
1305
1306 KASSERT(mutex_owned(&sc->sc_lock));
1307
1308 if (jack->opened)
1309 return USBD_IN_USE;
1310
1311 jack->arg = arg;
1312 jack->u.out.intr = intr;
1313 jack->midiman_ppkt = NULL;
1314 end = ep->buffer + ep->buffer_size / sizeof(*ep->buffer);
1315 jack->opened = 1;
1316 ep->num_open++;
1317 /*
1318 * out_solicit maintains an invariant that there will always be
1319 * (num_open - num_scheduled) slots free in the buffer. as we have
1320 * just incremented num_open, the buffer may be too full to satisfy
1321 * the invariant until a transfer completes, for which we must wait.
1322 */
1323 while (end - ep->next_slot < ep->num_open - ep->num_scheduled) {
1324 err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock,
1325 mstohz(10));
1326 if (err) {
1327 ep->num_open--;
1328 jack->opened = 0;
1329 return USBD_IOERROR;
1330 }
1331 }
1332
1333 return USBD_NORMAL_COMPLETION;
1334 }
1335
1336 static usbd_status
open_in_jack(struct umidi_jack * jack,void * arg,void (* intr)(void *,int))1337 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int))
1338 {
1339 usbd_status err = USBD_NORMAL_COMPLETION;
1340 struct umidi_endpoint *ep = jack->endpoint;
1341
1342 KASSERT(mutex_owned(&ep->sc->sc_lock));
1343
1344 if (jack->opened)
1345 return USBD_IN_USE;
1346
1347 jack->arg = arg;
1348 jack->u.in.intr = intr;
1349 jack->opened = 1;
1350 if (ep->num_open++ == 0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) {
1351 /*
1352 * Can't hold the interrupt lock while calling into USB,
1353 * but we can safely drop it here.
1354 */
1355 mutex_exit(&ep->sc->sc_lock);
1356 err = start_input_transfer(ep);
1357 if (err != USBD_NORMAL_COMPLETION &&
1358 err != USBD_IN_PROGRESS) {
1359 ep->num_open--;
1360 }
1361 mutex_enter(&ep->sc->sc_lock);
1362 }
1363
1364 return err;
1365 }
1366
1367 static void
close_out_jack(struct umidi_jack * jack)1368 close_out_jack(struct umidi_jack *jack)
1369 {
1370 struct umidi_endpoint *ep;
1371 struct umidi_softc *sc;
1372 uint16_t mask;
1373 int err;
1374
1375 if (jack->opened) {
1376 ep = jack->endpoint;
1377 sc = ep->sc;
1378
1379 KASSERT(mutex_owned(&sc->sc_lock));
1380 mask = 1 << (jack->cable_number);
1381 while (mask & (ep->this_schedule | ep->next_schedule)) {
1382 err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock,
1383 mstohz(10));
1384 if (err)
1385 break;
1386 }
1387 /*
1388 * We can re-enter this function from both close() and
1389 * detach(). Make sure only one of them does this part.
1390 */
1391 if (jack->opened) {
1392 jack->opened = 0;
1393 jack->endpoint->num_open--;
1394 ep->this_schedule &= ~mask;
1395 ep->next_schedule &= ~mask;
1396 }
1397 }
1398 }
1399
1400 static void
close_in_jack(struct umidi_jack * jack)1401 close_in_jack(struct umidi_jack *jack)
1402 {
1403 if (jack->opened) {
1404 struct umidi_softc *sc = jack->endpoint->sc;
1405
1406 KASSERT(mutex_owned(&sc->sc_lock));
1407
1408 jack->opened = 0;
1409 if (--jack->endpoint->num_open == 0) {
1410 /*
1411 * We have to drop the (interrupt) lock so that
1412 * the USB thread lock can be safely taken by
1413 * the abort operation. This is safe as this
1414 * either closing or dying will be set properly.
1415 */
1416 mutex_exit(&sc->sc_lock);
1417 usbd_abort_pipe(jack->endpoint->pipe);
1418 mutex_enter(&sc->sc_lock);
1419 }
1420 }
1421 }
1422
1423 static usbd_status
attach_mididev(struct umidi_softc * sc,struct umidi_mididev * mididev)1424 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev)
1425 {
1426 if (mididev->sc)
1427 return USBD_IN_USE;
1428
1429 mididev->sc = sc;
1430
1431 describe_mididev(mididev);
1432
1433 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, sc->sc_dev);
1434
1435 return USBD_NORMAL_COMPLETION;
1436 }
1437
1438 static usbd_status
detach_mididev(struct umidi_mididev * mididev,int flags)1439 detach_mididev(struct umidi_mididev *mididev, int flags)
1440 {
1441 struct umidi_softc *sc = mididev->sc;
1442
1443 if (!sc)
1444 return USBD_NO_ADDR;
1445
1446 mutex_enter(&sc->sc_lock);
1447 if (mididev->opened) {
1448 umidi_close(mididev);
1449 }
1450 unbind_jacks_from_mididev(mididev);
1451 mutex_exit(&sc->sc_lock);
1452
1453 if (mididev->mdev != NULL)
1454 config_detach(mididev->mdev, flags);
1455
1456 if (NULL != mididev->label) {
1457 kmem_free(mididev->label, mididev->label_len);
1458 mididev->label = NULL;
1459 }
1460
1461 mididev->sc = NULL;
1462
1463 return USBD_NORMAL_COMPLETION;
1464 }
1465
1466 static void
deactivate_mididev(struct umidi_mididev * mididev)1467 deactivate_mididev(struct umidi_mididev *mididev)
1468 {
1469 if (mididev->out_jack)
1470 mididev->out_jack->bound = 0;
1471 if (mididev->in_jack)
1472 mididev->in_jack->bound = 0;
1473 }
1474
1475 static usbd_status
alloc_all_mididevs(struct umidi_softc * sc,int nmidi)1476 alloc_all_mididevs(struct umidi_softc *sc, int nmidi)
1477 {
1478 sc->sc_num_mididevs = nmidi;
1479 sc->sc_mididevs = kmem_zalloc(sizeof(*sc->sc_mididevs)*nmidi, KM_SLEEP);
1480 return USBD_NORMAL_COMPLETION;
1481 }
1482
1483 static void
free_all_mididevs(struct umidi_softc * sc)1484 free_all_mididevs(struct umidi_softc *sc)
1485 {
1486 struct umidi_mididev *mididevs;
1487 size_t len;
1488
1489 mutex_enter(&sc->sc_lock);
1490 mididevs = sc->sc_mididevs;
1491 if (mididevs)
1492 len = sizeof(*sc->sc_mididevs )* sc->sc_num_mididevs;
1493 sc->sc_mididevs = NULL;
1494 sc->sc_num_mididevs = 0;
1495 mutex_exit(&sc->sc_lock);
1496
1497 if (mididevs)
1498 kmem_free(mididevs, len);
1499 }
1500
1501 static usbd_status
attach_all_mididevs(struct umidi_softc * sc)1502 attach_all_mididevs(struct umidi_softc *sc)
1503 {
1504 usbd_status err;
1505 int i;
1506
1507 if (sc->sc_mididevs)
1508 for (i = 0; i < sc->sc_num_mididevs; i++) {
1509 err = attach_mididev(sc, &sc->sc_mididevs[i]);
1510 if (err != USBD_NORMAL_COMPLETION)
1511 return err;
1512 }
1513
1514 return USBD_NORMAL_COMPLETION;
1515 }
1516
1517 static usbd_status
detach_all_mididevs(struct umidi_softc * sc,int flags)1518 detach_all_mididevs(struct umidi_softc *sc, int flags)
1519 {
1520 usbd_status err;
1521 int i;
1522
1523 if (sc->sc_mididevs)
1524 for (i = 0; i < sc->sc_num_mididevs; i++) {
1525 err = detach_mididev(&sc->sc_mididevs[i], flags);
1526 if (err != USBD_NORMAL_COMPLETION)
1527 return err;
1528 }
1529
1530 return USBD_NORMAL_COMPLETION;
1531 }
1532
1533 static void
deactivate_all_mididevs(struct umidi_softc * sc)1534 deactivate_all_mididevs(struct umidi_softc *sc)
1535 {
1536 int i;
1537
1538 if (sc->sc_mididevs) {
1539 for (i = 0; i < sc->sc_num_mididevs; i++)
1540 deactivate_mididev(&sc->sc_mididevs[i]);
1541 }
1542 }
1543
1544 /*
1545 * TODO: the 0-based cable numbers will often not match the labeling of the
1546 * equipment. Ideally:
1547 * For class-compliant devices: get the iJack string from the jack descriptor.
1548 * Otherwise:
1549 * - support a DISPLAY_BASE_CN quirk (add the value to each internal cable
1550 * number for display)
1551 * - support an array quirk explicitly giving a char * for each jack.
1552 * For now, you get 0-based cable numbers. If there are multiple endpoints and
1553 * the CNs are not globally unique, each is shown with its associated endpoint
1554 * address in hex also. That should not be necessary when using iJack values
1555 * or a quirk array.
1556 */
1557 void
describe_mididev(struct umidi_mididev * md)1558 describe_mididev(struct umidi_mididev *md)
1559 {
1560 char in_label[16];
1561 char out_label[16];
1562 const char *unit_label;
1563 char *final_label;
1564 struct umidi_softc *sc;
1565 int show_ep_in;
1566 int show_ep_out;
1567 size_t len;
1568
1569 sc = md->sc;
1570 show_ep_in = sc-> sc_in_num_endpoints > 1 && !sc->cblnums_global;
1571 show_ep_out = sc->sc_out_num_endpoints > 1 && !sc->cblnums_global;
1572
1573 if (NULL == md->in_jack)
1574 in_label[0] = '\0';
1575 else if (show_ep_in)
1576 snprintf(in_label, sizeof(in_label), "<%d(%x) ",
1577 md->in_jack->cable_number, md->in_jack->endpoint->addr);
1578 else
1579 snprintf(in_label, sizeof(in_label), "<%d ",
1580 md->in_jack->cable_number);
1581
1582 if (NULL == md->out_jack)
1583 out_label[0] = '\0';
1584 else if (show_ep_out)
1585 snprintf(out_label, sizeof(out_label), ">%d(%x) ",
1586 md->out_jack->cable_number, md->out_jack->endpoint->addr);
1587 else
1588 snprintf(out_label, sizeof(out_label), ">%d ",
1589 md->out_jack->cable_number);
1590
1591 unit_label = device_xname(sc->sc_dev);
1592
1593 len = strlen(in_label) + strlen(out_label) + strlen(unit_label) + 4;
1594
1595 final_label = kmem_alloc(len, KM_SLEEP);
1596
1597 snprintf(final_label, len, "%s%son %s",
1598 in_label, out_label, unit_label);
1599
1600 md->label = final_label;
1601 md->label_len = len;
1602 }
1603
1604 #ifdef UMIDI_DEBUG
1605 static void
dump_sc(struct umidi_softc * sc)1606 dump_sc(struct umidi_softc *sc)
1607 {
1608 int i;
1609
1610 DPRINTFN(10, ("%s: dump_sc\n", device_xname(sc->sc_dev)));
1611 for (i=0; i<sc->sc_out_num_endpoints; i++) {
1612 DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i]));
1613 dump_ep(&sc->sc_out_ep[i]);
1614 }
1615 for (i=0; i<sc->sc_in_num_endpoints; i++) {
1616 DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i]));
1617 dump_ep(&sc->sc_in_ep[i]);
1618 }
1619 }
1620
1621 static void
dump_ep(struct umidi_endpoint * ep)1622 dump_ep(struct umidi_endpoint *ep)
1623 {
1624 int i;
1625 for (i=0; i<UMIDI_MAX_EPJACKS; i++) {
1626 if (NULL==ep->jacks[i])
1627 continue;
1628 DPRINTFN(10, ("\t\tjack[%d]:%p:\n", i, ep->jacks[i]));
1629 dump_jack(ep->jacks[i]);
1630 }
1631 }
1632 static void
dump_jack(struct umidi_jack * jack)1633 dump_jack(struct umidi_jack *jack)
1634 {
1635 DPRINTFN(10, ("\t\t\tep=%p\n",
1636 jack->endpoint));
1637 }
1638
1639 #endif /* UMIDI_DEBUG */
1640
1641
1642
1643 /*
1644 * MUX MIDI PACKET
1645 */
1646
1647 static const int packet_length[16] = {
1648 /*0*/ -1,
1649 /*1*/ -1,
1650 /*2*/ 2,
1651 /*3*/ 3,
1652 /*4*/ 3,
1653 /*5*/ 1,
1654 /*6*/ 2,
1655 /*7*/ 3,
1656 /*8*/ 3,
1657 /*9*/ 3,
1658 /*A*/ 3,
1659 /*B*/ 3,
1660 /*C*/ 2,
1661 /*D*/ 2,
1662 /*E*/ 3,
1663 /*F*/ 1,
1664 };
1665
1666 #define GET_CN(p) (((unsigned char)(p)>>4)&0x0F)
1667 #define GET_CIN(p) ((unsigned char)(p)&0x0F)
1668 #define MIX_CN_CIN(cn, cin) \
1669 ((unsigned char)((((unsigned char)(cn)&0x0F)<<4)| \
1670 ((unsigned char)(cin)&0x0F)))
1671
1672 static usbd_status
start_input_transfer(struct umidi_endpoint * ep)1673 start_input_transfer(struct umidi_endpoint *ep)
1674 {
1675 usbd_setup_xfer(ep->xfer, ep, ep->buffer, ep->buffer_size,
1676 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, in_intr);
1677 return usbd_transfer(ep->xfer);
1678 }
1679
1680 static usbd_status
start_output_transfer(struct umidi_endpoint * ep)1681 start_output_transfer(struct umidi_endpoint *ep)
1682 {
1683 usbd_status rv;
1684 uint32_t length;
1685 int i;
1686
1687 length = (ep->next_slot - ep->buffer) * sizeof(*ep->buffer);
1688 DPRINTFN(200,("umidi out transfer: start %p end %p length %u\n",
1689 ep->buffer, ep->next_slot, length));
1690
1691 usbd_setup_xfer(ep->xfer, ep, ep->buffer, length, 0,
1692 USBD_NO_TIMEOUT, out_intr);
1693 rv = usbd_transfer(ep->xfer);
1694
1695 /*
1696 * Once the transfer is scheduled, no more adding to partial
1697 * packets within it.
1698 */
1699 if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) {
1700 for (i=0; i<UMIDI_MAX_EPJACKS; ++i)
1701 if (NULL != ep->jacks[i])
1702 ep->jacks[i]->midiman_ppkt = NULL;
1703 }
1704
1705 return rv;
1706 }
1707
1708 #ifdef UMIDI_DEBUG
1709 #define DPR_PACKET(dir, sc, p) \
1710 if ((unsigned char)(p)[1]!=0xFE) \
1711 DPRINTFN(500, \
1712 ("%s: umidi packet(" #dir "): %02X %02X %02X %02X\n", \
1713 device_xname(sc->sc_dev), \
1714 (unsigned char)(p)[0], \
1715 (unsigned char)(p)[1], \
1716 (unsigned char)(p)[2], \
1717 (unsigned char)(p)[3]));
1718 #else
1719 #define DPR_PACKET(dir, sc, p)
1720 #endif
1721
1722 /*
1723 * A 4-byte Midiman packet superficially resembles a 4-byte USB MIDI packet
1724 * with the cable number and length in the last byte instead of the first,
1725 * but there the resemblance ends. Where a USB MIDI packet is a semantic
1726 * unit, a Midiman packet is just a wrapper for 1 to 3 bytes of raw MIDI
1727 * with a cable nybble and a length nybble (which, unlike the CIN of a
1728 * real USB MIDI packet, has no semantics at all besides the length).
1729 * A packet received from a Midiman may contain part of a MIDI message,
1730 * more than one MIDI message, or parts of more than one MIDI message. A
1731 * three-byte MIDI message may arrive in three packets of data length 1, and
1732 * running status may be used. Happily, the midi(4) driver above us will put
1733 * it all back together, so the only cost is in USB bandwidth. The device
1734 * has an easier time with what it receives from us: we'll pack messages in
1735 * and across packets, but filling the packets whenever possible and,
1736 * as midi(4) hands us a complete message at a time, we'll never send one
1737 * in a dribble of short packets.
1738 */
1739
1740 static int
out_jack_output(struct umidi_jack * out_jack,u_char * src,int len,int cin)1741 out_jack_output(struct umidi_jack *out_jack, u_char *src, int len, int cin)
1742 {
1743 struct umidi_endpoint *ep = out_jack->endpoint;
1744 struct umidi_softc *sc = ep->sc;
1745 unsigned char *packet;
1746 int plen;
1747 int poff;
1748
1749 KASSERT(mutex_owned(&sc->sc_lock));
1750
1751 if (sc->sc_dying)
1752 return EIO;
1753
1754 if (!out_jack->opened)
1755 return ENODEV; /* XXX as it was, is this the right errno? */
1756
1757 sc->sc_refcnt++;
1758
1759 #ifdef UMIDI_DEBUG
1760 if (umididebug >= 100)
1761 microtime(&umidi_tv);
1762 #endif
1763 DPRINTFN(100, ("umidi out: %"PRIu64".%06"PRIu64
1764 "s ep=%p cn=%d len=%d cin=%#x\n", umidi_tv.tv_sec%100,
1765 (uint64_t)umidi_tv.tv_usec, ep, out_jack->cable_number, len, cin));
1766
1767 packet = *ep->next_slot++;
1768 KASSERT(ep->buffer_size >=
1769 (ep->next_slot - ep->buffer) * sizeof(*ep->buffer));
1770 memset(packet, 0, UMIDI_PACKET_SIZE);
1771 if (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE)) {
1772 if (NULL != out_jack->midiman_ppkt) { /* fill out a prev pkt */
1773 poff = 0x0f & (out_jack->midiman_ppkt[3]);
1774 plen = 3 - poff;
1775 if (plen > len)
1776 plen = len;
1777 memcpy(out_jack->midiman_ppkt+poff, src, plen);
1778 src += plen;
1779 len -= plen;
1780 plen += poff;
1781 out_jack->midiman_ppkt[3] =
1782 MIX_CN_CIN(out_jack->cable_number, plen);
1783 DPR_PACKET(out+, sc, out_jack->midiman_ppkt);
1784 if (3 == plen)
1785 out_jack->midiman_ppkt = NULL; /* no more */
1786 }
1787 if (0 == len)
1788 ep->next_slot--; /* won't be needed, nevermind */
1789 else {
1790 memcpy(packet, src, len);
1791 packet[3] = MIX_CN_CIN(out_jack->cable_number, len);
1792 DPR_PACKET(out, sc, packet);
1793 if (len < 3)
1794 out_jack->midiman_ppkt = packet;
1795 }
1796 } else { /* the nice simple USB class-compliant case */
1797 packet[0] = MIX_CN_CIN(out_jack->cable_number, cin);
1798 memcpy(packet+1, src, len);
1799 DPR_PACKET(out, sc, packet);
1800 }
1801 ep->next_schedule |= 1<<(out_jack->cable_number);
1802 ++ ep->num_scheduled;
1803 if (!ep->armed && !ep->soliciting) {
1804 /*
1805 * It would be bad to call out_solicit directly here (the
1806 * caller need not be reentrant) but a soft interrupt allows
1807 * solicit to run immediately the caller exits its critical
1808 * section, and if the caller has more to write we can get it
1809 * before starting the USB transfer, and send a longer one.
1810 */
1811 ep->soliciting = 1;
1812 kpreempt_disable();
1813 softint_schedule(ep->solicit_cookie);
1814 kpreempt_enable();
1815 }
1816
1817 if (--sc->sc_refcnt < 0)
1818 cv_broadcast(&sc->sc_detach_cv);
1819
1820 return 0;
1821 }
1822
1823 static void
in_intr(struct usbd_xfer * xfer,void * priv,usbd_status status)1824 in_intr(struct usbd_xfer *xfer, void *priv,
1825 usbd_status status)
1826 {
1827 int cn, len, i;
1828 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv;
1829 struct umidi_softc *sc = ep->sc;
1830 struct umidi_jack *jack;
1831 unsigned char *packet;
1832 umidi_packet_bufp slot;
1833 umidi_packet_bufp end;
1834 unsigned char *data;
1835 uint32_t count;
1836
1837 if (ep->sc->sc_dying || !ep->num_open)
1838 return;
1839
1840 mutex_enter(&sc->sc_lock);
1841 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
1842 if (0 == count % UMIDI_PACKET_SIZE) {
1843 DPRINTFN(200,("%s: input endpoint %p transfer length %u\n",
1844 device_xname(ep->sc->sc_dev), ep, count));
1845 } else {
1846 DPRINTF(("%s: input endpoint %p odd transfer length %u\n",
1847 device_xname(ep->sc->sc_dev), ep, count));
1848 }
1849
1850 slot = ep->buffer;
1851 end = slot + count / sizeof(*slot);
1852
1853 for (packet = *slot; slot < end; packet = *++slot) {
1854
1855 if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) {
1856 cn = (0xf0&(packet[3]))>>4;
1857 len = 0x0f&(packet[3]);
1858 data = packet;
1859 } else {
1860 cn = GET_CN(packet[0]);
1861 len = packet_length[GET_CIN(packet[0])];
1862 data = packet + 1;
1863 }
1864 /* 0 <= cn <= 15 by inspection of above code */
1865 if (!(jack = ep->jacks[cn]) || cn != jack->cable_number) {
1866 DPRINTF(("%s: stray input endpoint %p cable %d len %d: "
1867 "%02X %02X %02X (try CN_SEQ quirk?)\n",
1868 device_xname(ep->sc->sc_dev), ep, cn, len,
1869 (unsigned)data[0],
1870 (unsigned)data[1],
1871 (unsigned)data[2]));
1872 mutex_exit(&sc->sc_lock);
1873 return;
1874 }
1875
1876 if (!jack->bound || !jack->opened)
1877 continue;
1878
1879 DPRINTFN(500,("%s: input endpoint %p cable %d len %d: "
1880 "%02X %02X %02X\n",
1881 device_xname(ep->sc->sc_dev), ep, cn, len,
1882 (unsigned)data[0],
1883 (unsigned)data[1],
1884 (unsigned)data[2]));
1885
1886 if (jack->u.in.intr) {
1887 for (i = 0; i < len; i++) {
1888 (*jack->u.in.intr)(jack->arg, data[i]);
1889 }
1890 }
1891
1892 }
1893
1894 (void)start_input_transfer(ep);
1895 mutex_exit(&sc->sc_lock);
1896 }
1897
1898 static void
out_intr(struct usbd_xfer * xfer,void * priv,usbd_status status)1899 out_intr(struct usbd_xfer *xfer, void *priv,
1900 usbd_status status)
1901 {
1902 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv;
1903 struct umidi_softc *sc = ep->sc;
1904 uint32_t count;
1905
1906 if (sc->sc_dying)
1907 return;
1908
1909 mutex_enter(&sc->sc_lock);
1910 #ifdef UMIDI_DEBUG
1911 if (umididebug >= 200)
1912 microtime(&umidi_tv);
1913 #endif
1914 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
1915 if (0 == count % UMIDI_PACKET_SIZE) {
1916 DPRINTFN(200, ("%s: %"PRIu64".%06"PRIu64"s out ep %p xfer "
1917 "length %u\n", device_xname(ep->sc->sc_dev),
1918 umidi_tv.tv_sec%100, (uint64_t)umidi_tv.tv_usec, ep,
1919 count));
1920 } else {
1921 DPRINTF(("%s: output endpoint %p odd transfer length %u\n",
1922 device_xname(ep->sc->sc_dev), ep, count));
1923 }
1924 count /= UMIDI_PACKET_SIZE;
1925
1926 /*
1927 * If while the transfer was pending we buffered any new messages,
1928 * move them to the start of the buffer.
1929 */
1930 ep->next_slot -= count;
1931 if (ep->buffer < ep->next_slot) {
1932 memcpy(ep->buffer, ep->buffer + count,
1933 (char *)ep->next_slot - (char *)ep->buffer);
1934 }
1935 cv_broadcast(&sc->sc_cv);
1936 /*
1937 * Do not want anyone else to see armed <- 0 before soliciting <- 1.
1938 * Running at IPL_USB so the following should happen to be safe.
1939 */
1940 ep->armed = 0;
1941 if (!ep->soliciting) {
1942 ep->soliciting = 1;
1943 out_solicit_locked(ep);
1944 }
1945 mutex_exit(&sc->sc_lock);
1946 }
1947
1948 /*
1949 * A jack on which we have received a packet must be called back on its
1950 * out.intr handler before it will send us another; it is considered
1951 * 'scheduled'. It is nice and predictable - as long as it is scheduled,
1952 * we need no extra buffer space for it.
1953 *
1954 * In contrast, a jack that is open but not scheduled may supply us a packet
1955 * at any time, driven by the top half, and we must be able to accept it, no
1956 * excuses. So we must ensure that at any point in time there are at least
1957 * (num_open - num_scheduled) slots free.
1958 *
1959 * As long as there are more slots free than that minimum, we can loop calling
1960 * scheduled jacks back on their "interrupt" handlers, soliciting more
1961 * packets, starting the USB transfer only when the buffer space is down to
1962 * the minimum or no jack has any more to send.
1963 */
1964
1965 static void
out_solicit_locked(void * arg)1966 out_solicit_locked(void *arg)
1967 {
1968 struct umidi_endpoint *ep = arg;
1969 umidi_packet_bufp end;
1970 uint16_t which;
1971 struct umidi_jack *jack;
1972
1973 KASSERT(mutex_owned(&ep->sc->sc_lock));
1974
1975 end = ep->buffer + ep->buffer_size / sizeof(*ep->buffer);
1976
1977 for ( ;; ) {
1978 if (end - ep->next_slot <= ep->num_open - ep->num_scheduled)
1979 break; /* at IPL_USB */
1980 if (ep->this_schedule == 0) {
1981 if (ep->next_schedule == 0)
1982 break; /* at IPL_USB */
1983 ep->this_schedule = ep->next_schedule;
1984 ep->next_schedule = 0;
1985 }
1986 /*
1987 * At least one jack is scheduled. Find and mask off the least
1988 * set bit in this_schedule and decrement num_scheduled.
1989 * Convert mask to bit index to find the corresponding jack,
1990 * and call its intr handler. If it has a message, it will call
1991 * back one of the output methods, which will set its bit in
1992 * next_schedule (not copied into this_schedule until the
1993 * latter is empty). In this way we round-robin the jacks that
1994 * have messages to send, until the buffer is as full as we
1995 * dare, and then start a transfer.
1996 */
1997 which = ep->this_schedule;
1998 which &= (~which)+1; /* now mask of least set bit */
1999 ep->this_schedule &= ~which;
2000 --ep->num_scheduled;
2001
2002 --which; /* now 1s below mask - count 1s to get index */
2003 which -= ((which >> 1) & 0x5555);/* SWAR credit aggregate.org */
2004 which = (((which >> 2) & 0x3333) + (which & 0x3333));
2005 which = (((which >> 4) + which) & 0x0f0f);
2006 which += (which >> 8);
2007 which &= 0x1f; /* the bit index a/k/a jack number */
2008
2009 jack = ep->jacks[which];
2010 if (jack->u.out.intr)
2011 (*jack->u.out.intr)(jack->arg);
2012 }
2013 /* intr lock held at loop exit */
2014 if (!ep->armed && ep->next_slot > ep->buffer) {
2015 /*
2016 * Can't hold the interrupt lock while calling into USB,
2017 * but we can safely drop it here.
2018 */
2019 mutex_exit(&ep->sc->sc_lock);
2020 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep));
2021 mutex_enter(&ep->sc->sc_lock);
2022 }
2023 ep->soliciting = 0;
2024 }
2025
2026 /* Entry point for the softintr. */
2027 static void
out_solicit(void * arg)2028 out_solicit(void *arg)
2029 {
2030 struct umidi_endpoint *ep = arg;
2031 struct umidi_softc *sc = ep->sc;
2032
2033 mutex_enter(&sc->sc_lock);
2034 out_solicit_locked(arg);
2035 mutex_exit(&sc->sc_lock);
2036 }
2037