1 /* $NetBSD: umidi.c,v 1.83 2021/01/20 22:46:33 jdolecek 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@eterna.com.au). 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.83 2021/01/20 22:46:33 jdolecek 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 * hierarchie 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 724 alloc_all_endpoints(struct umidi_softc *sc) 725 { 726 usbd_status err; 727 struct umidi_endpoint *ep; 728 int i; 729 730 if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) { 731 err = alloc_all_endpoints_fixed_ep(sc); 732 } else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) { 733 err = alloc_all_endpoints_yamaha(sc); 734 } else { 735 err = alloc_all_endpoints_genuine(sc); 736 } 737 if (err != USBD_NORMAL_COMPLETION) 738 return err; 739 740 ep = sc->sc_endpoints; 741 for (i = sc->sc_out_num_endpoints+sc->sc_in_num_endpoints; i > 0; i--) { 742 err = alloc_pipe(ep++); 743 if (err != USBD_NORMAL_COMPLETION) { 744 for (; ep != sc->sc_endpoints; ep--) 745 free_pipe(ep-1); 746 kmem_free(sc->sc_endpoints, sc->sc_endpoints_len); 747 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 748 break; 749 } 750 } 751 return err; 752 } 753 754 static void 755 free_all_endpoints(struct umidi_softc *sc) 756 { 757 int i; 758 759 if (sc->sc_endpoints == NULL) { 760 /* nothing to free */ 761 return; 762 } 763 764 for (i=0; i<sc->sc_in_num_endpoints+sc->sc_out_num_endpoints; 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 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 sc->sc_out_num_jacks = 0; 782 sc->sc_in_num_jacks = 0; 783 sc->sc_out_num_endpoints = fp->num_out_ep; 784 sc->sc_in_num_endpoints = fp->num_in_ep; 785 sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc); 786 sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP); 787 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 788 sc->sc_in_ep = 789 sc->sc_in_num_endpoints ? 790 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 791 792 ep = &sc->sc_out_ep[0]; 793 for (i = 0; i < sc->sc_out_num_endpoints; i++) { 794 epd = usbd_interface2endpoint_descriptor( 795 sc->sc_iface, 796 fp->out_ep[i].ep); 797 if (!epd) { 798 aprint_error_dev(sc->sc_dev, 799 "cannot get endpoint descriptor(out:%d)\n", 800 fp->out_ep[i].ep); 801 err = USBD_INVAL; 802 goto error; 803 } 804 if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK || 805 UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_OUT) { 806 aprint_error_dev(sc->sc_dev, 807 "illegal endpoint(out:%d)\n", fp->out_ep[i].ep); 808 err = USBD_INVAL; 809 goto error; 810 } 811 ep->sc = sc; 812 ep->addr = epd->bEndpointAddress; 813 ep->num_jacks = fp->out_ep[i].num_jacks; 814 sc->sc_out_num_jacks += fp->out_ep[i].num_jacks; 815 ep->num_open = 0; 816 ep++; 817 } 818 ep = &sc->sc_in_ep[0]; 819 for (i = 0; i < sc->sc_in_num_endpoints; i++) { 820 epd = usbd_interface2endpoint_descriptor( 821 sc->sc_iface, 822 fp->in_ep[i].ep); 823 if (!epd) { 824 aprint_error_dev(sc->sc_dev, 825 "cannot get endpoint descriptor(in:%d)\n", 826 fp->in_ep[i].ep); 827 err = USBD_INVAL; 828 goto error; 829 } 830 /* 831 * MIDISPORT_2X4 inputs on an interrupt rather than a bulk 832 * endpoint. The existing input logic in this driver seems 833 * to work successfully if we just stop treating an interrupt 834 * endpoint as illegal (or the in_progress status we get on 835 * the initial transfer). It does not seem necessary to 836 * actually use the interrupt flavor of alloc_pipe or make 837 * other serious rearrangements of logic. I like that. 838 */ 839 switch ( UE_GET_XFERTYPE(epd->bmAttributes) ) { 840 case UE_BULK: 841 case UE_INTERRUPT: 842 if (UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress)) 843 break; 844 /*FALLTHROUGH*/ 845 default: 846 aprint_error_dev(sc->sc_dev, 847 "illegal endpoint(in:%d)\n", fp->in_ep[i].ep); 848 err = USBD_INVAL; 849 goto error; 850 } 851 852 ep->sc = sc; 853 ep->addr = epd->bEndpointAddress; 854 ep->num_jacks = fp->in_ep[i].num_jacks; 855 sc->sc_in_num_jacks += fp->in_ep[i].num_jacks; 856 ep->num_open = 0; 857 ep++; 858 } 859 860 return USBD_NORMAL_COMPLETION; 861 error: 862 kmem_free(sc->sc_endpoints, UMIDI_ENDPOINT_SIZE(sc)); 863 sc->sc_endpoints = NULL; 864 return err; 865 } 866 867 static usbd_status 868 alloc_all_endpoints_yamaha(struct umidi_softc *sc) 869 { 870 /* This driver currently supports max 1in/1out bulk endpoints */ 871 usb_descriptor_t *desc; 872 umidi_cs_descriptor_t *udesc; 873 usb_endpoint_descriptor_t *epd; 874 int out_addr, in_addr, i; 875 int dir; 876 size_t remain, descsize; 877 878 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 879 out_addr = in_addr = 0; 880 881 /* detect endpoints */ 882 desc = TO_D(usbd_get_interface_descriptor(sc->sc_iface)); 883 for (i=(int)TO_IFD(desc)->bNumEndpoints-1; i>=0; i--) { 884 epd = usbd_interface2endpoint_descriptor(sc->sc_iface, i); 885 KASSERT(epd != NULL); 886 if (UE_GET_XFERTYPE(epd->bmAttributes) == UE_BULK) { 887 dir = UE_GET_DIR(epd->bEndpointAddress); 888 if (dir==UE_DIR_OUT && !out_addr) 889 out_addr = epd->bEndpointAddress; 890 else if (dir==UE_DIR_IN && !in_addr) 891 in_addr = epd->bEndpointAddress; 892 } 893 } 894 udesc = (umidi_cs_descriptor_t *)NEXT_D(desc); 895 896 /* count jacks */ 897 if (!(udesc->bDescriptorType==UDESC_CS_INTERFACE && 898 udesc->bDescriptorSubtype==UMIDI_MS_HEADER)) 899 return USBD_INVAL; 900 remain = (size_t)UGETW(TO_CSIFD(udesc)->wTotalLength) - 901 (size_t)udesc->bLength; 902 udesc = (umidi_cs_descriptor_t *)NEXT_D(udesc); 903 904 while (remain >= sizeof(usb_descriptor_t)) { 905 descsize = udesc->bLength; 906 if (descsize>remain || descsize==0) 907 break; 908 if (udesc->bDescriptorType == UDESC_CS_INTERFACE && 909 remain >= UMIDI_JACK_DESCRIPTOR_SIZE) { 910 if (udesc->bDescriptorSubtype == UMIDI_OUT_JACK) 911 sc->sc_out_num_jacks++; 912 else if (udesc->bDescriptorSubtype == UMIDI_IN_JACK) 913 sc->sc_in_num_jacks++; 914 } 915 udesc = (umidi_cs_descriptor_t *)NEXT_D(udesc); 916 remain -= descsize; 917 } 918 919 /* validate some parameters */ 920 if (sc->sc_out_num_jacks>UMIDI_MAX_EPJACKS) 921 sc->sc_out_num_jacks = UMIDI_MAX_EPJACKS; 922 if (sc->sc_in_num_jacks>UMIDI_MAX_EPJACKS) 923 sc->sc_in_num_jacks = UMIDI_MAX_EPJACKS; 924 if (sc->sc_out_num_jacks && out_addr) { 925 sc->sc_out_num_endpoints = 1; 926 } else { 927 sc->sc_out_num_endpoints = 0; 928 sc->sc_out_num_jacks = 0; 929 } 930 if (sc->sc_in_num_jacks && in_addr) { 931 sc->sc_in_num_endpoints = 1; 932 } else { 933 sc->sc_in_num_endpoints = 0; 934 sc->sc_in_num_jacks = 0; 935 } 936 sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc); 937 sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP); 938 if (sc->sc_out_num_endpoints) { 939 sc->sc_out_ep = sc->sc_endpoints; 940 sc->sc_out_ep->sc = sc; 941 sc->sc_out_ep->addr = out_addr; 942 sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks; 943 sc->sc_out_ep->num_open = 0; 944 } else 945 sc->sc_out_ep = NULL; 946 947 if (sc->sc_in_num_endpoints) { 948 sc->sc_in_ep = sc->sc_endpoints+sc->sc_out_num_endpoints; 949 sc->sc_in_ep->sc = sc; 950 sc->sc_in_ep->addr = in_addr; 951 sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks; 952 sc->sc_in_ep->num_open = 0; 953 } else 954 sc->sc_in_ep = NULL; 955 956 return USBD_NORMAL_COMPLETION; 957 } 958 959 static usbd_status 960 alloc_all_endpoints_genuine(struct umidi_softc *sc) 961 { 962 usb_interface_descriptor_t *interface_desc; 963 usb_config_descriptor_t *config_desc; 964 usb_descriptor_t *desc; 965 int num_ep; 966 size_t remain, descsize; 967 struct umidi_endpoint *p, *q, *lowest, *endep, tmpep; 968 int epaddr; 969 970 interface_desc = usbd_get_interface_descriptor(sc->sc_iface); 971 num_ep = interface_desc->bNumEndpoints; 972 if (num_ep == 0) 973 return USBD_INVAL; 974 sc->sc_endpoints_len = sizeof(struct umidi_endpoint) * num_ep; 975 sc->sc_endpoints = p = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP); 976 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 977 sc->sc_out_num_endpoints = sc->sc_in_num_endpoints = 0; 978 epaddr = -1; 979 980 /* get the list of endpoints for midi stream */ 981 config_desc = usbd_get_config_descriptor(sc->sc_udev); 982 desc = (usb_descriptor_t *) config_desc; 983 remain = (size_t)UGETW(config_desc->wTotalLength); 984 while (remain>=sizeof(usb_descriptor_t)) { 985 descsize = desc->bLength; 986 if (descsize>remain || descsize==0) 987 break; 988 if (desc->bDescriptorType==UDESC_ENDPOINT && 989 remain>=USB_ENDPOINT_DESCRIPTOR_SIZE && 990 UE_GET_XFERTYPE(TO_EPD(desc)->bmAttributes) == UE_BULK) { 991 epaddr = TO_EPD(desc)->bEndpointAddress; 992 } else if (desc->bDescriptorType==UDESC_CS_ENDPOINT && 993 remain>=UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE && 994 epaddr!=-1) { 995 if (num_ep>0) { 996 num_ep--; 997 p->sc = sc; 998 p->addr = epaddr; 999 p->num_jacks = TO_CSEPD(desc)->bNumEmbMIDIJack; 1000 if (UE_GET_DIR(epaddr)==UE_DIR_OUT) { 1001 sc->sc_out_num_endpoints++; 1002 sc->sc_out_num_jacks += p->num_jacks; 1003 } else { 1004 sc->sc_in_num_endpoints++; 1005 sc->sc_in_num_jacks += p->num_jacks; 1006 } 1007 p++; 1008 } 1009 } else 1010 epaddr = -1; 1011 desc = NEXT_D(desc); 1012 remain-=descsize; 1013 } 1014 1015 /* sort endpoints */ 1016 num_ep = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints; 1017 p = sc->sc_endpoints; 1018 endep = p + num_ep; 1019 while (p<endep) { 1020 lowest = p; 1021 for (q=p+1; q<endep; q++) { 1022 if ((UE_GET_DIR(lowest->addr)==UE_DIR_IN && 1023 UE_GET_DIR(q->addr)==UE_DIR_OUT) || 1024 ((UE_GET_DIR(lowest->addr)== 1025 UE_GET_DIR(q->addr)) && 1026 (UE_GET_ADDR(lowest->addr)> 1027 UE_GET_ADDR(q->addr)))) 1028 lowest = q; 1029 } 1030 if (lowest != p) { 1031 memcpy((void *)&tmpep, (void *)p, sizeof(tmpep)); 1032 memcpy((void *)p, (void *)lowest, sizeof(tmpep)); 1033 memcpy((void *)lowest, (void *)&tmpep, sizeof(tmpep)); 1034 } 1035 p->num_open = 0; 1036 p++; 1037 } 1038 1039 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 1040 sc->sc_in_ep = 1041 sc->sc_in_num_endpoints ? 1042 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 1043 1044 return USBD_NORMAL_COMPLETION; 1045 } 1046 1047 1048 /* 1049 * jack stuffs 1050 */ 1051 1052 static usbd_status 1053 alloc_all_jacks(struct umidi_softc *sc) 1054 { 1055 int i, j; 1056 struct umidi_endpoint *ep; 1057 struct umidi_jack *jack; 1058 const unsigned char *cn_spec; 1059 1060 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_PER_EP)) 1061 sc->cblnums_global = 0; 1062 else if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_GLOBAL)) 1063 sc->cblnums_global = 1; 1064 else { 1065 /* 1066 * I don't think this default is correct, but it preserves 1067 * the prior behavior of the code. That's why I defined two 1068 * complementary quirks. Any device for which the default 1069 * behavior is wrong can be made to work by giving it an 1070 * explicit quirk, and if a pattern ever develops (as I suspect 1071 * it will) that a lot of otherwise standard USB MIDI devices 1072 * need the CN_SEQ_PER_EP "quirk," then this default can be 1073 * changed to 0, and the only devices that will break are those 1074 * listing neither quirk, and they'll easily be fixed by giving 1075 * them the CN_SEQ_GLOBAL quirk. 1076 */ 1077 sc->cblnums_global = 1; 1078 } 1079 1080 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_FIXED)) 1081 cn_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 1082 UMQ_TYPE_CN_FIXED); 1083 else 1084 cn_spec = NULL; 1085 1086 /* allocate/initialize structures */ 1087 if (sc->sc_in_num_jacks == 0 && sc->sc_out_num_jacks == 0) 1088 return USBD_INVAL; 1089 sc->sc_jacks = kmem_zalloc(sizeof(*sc->sc_out_jacks) * 1090 (sc->sc_in_num_jacks + sc->sc_out_num_jacks), KM_SLEEP); 1091 if (!sc->sc_jacks) 1092 return USBD_NOMEM; 1093 sc->sc_out_jacks = 1094 sc->sc_out_num_jacks ? sc->sc_jacks : NULL; 1095 sc->sc_in_jacks = 1096 sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL; 1097 1098 jack = &sc->sc_out_jacks[0]; 1099 for (i = 0; i < sc->sc_out_num_jacks; i++) { 1100 jack->opened = 0; 1101 jack->bound = 0; 1102 jack->arg = NULL; 1103 jack->u.out.intr = NULL; 1104 jack->midiman_ppkt = NULL; 1105 if (sc->cblnums_global) 1106 jack->cable_number = i; 1107 jack++; 1108 } 1109 jack = &sc->sc_in_jacks[0]; 1110 for (i = 0; i < sc->sc_in_num_jacks; i++) { 1111 jack->opened = 0; 1112 jack->bound = 0; 1113 jack->arg = NULL; 1114 jack->u.in.intr = NULL; 1115 if (sc->cblnums_global) 1116 jack->cable_number = i; 1117 jack++; 1118 } 1119 1120 /* assign each jacks to each endpoints */ 1121 jack = &sc->sc_out_jacks[0]; 1122 ep = &sc->sc_out_ep[0]; 1123 for (i = 0; i < sc->sc_out_num_endpoints; i++) { 1124 for (j = 0; j < ep->num_jacks; j++) { 1125 jack->endpoint = ep; 1126 if (cn_spec != NULL) 1127 jack->cable_number = *cn_spec++; 1128 else if (!sc->cblnums_global) 1129 jack->cable_number = j; 1130 ep->jacks[jack->cable_number] = jack; 1131 jack++; 1132 } 1133 ep++; 1134 } 1135 jack = &sc->sc_in_jacks[0]; 1136 ep = &sc->sc_in_ep[0]; 1137 for (i = 0; i < sc->sc_in_num_endpoints; i++) { 1138 for (j = 0; j < ep->num_jacks; j++) { 1139 jack->endpoint = ep; 1140 if (cn_spec != NULL) 1141 jack->cable_number = *cn_spec++; 1142 else if (!sc->cblnums_global) 1143 jack->cable_number = j; 1144 ep->jacks[jack->cable_number] = jack; 1145 jack++; 1146 } 1147 ep++; 1148 } 1149 1150 return USBD_NORMAL_COMPLETION; 1151 } 1152 1153 static void 1154 free_all_jacks(struct umidi_softc *sc) 1155 { 1156 struct umidi_jack *jacks; 1157 size_t len; 1158 1159 mutex_enter(&sc->sc_lock); 1160 jacks = sc->sc_jacks; 1161 len = sizeof(*sc->sc_out_jacks) * 1162 (sc->sc_in_num_jacks + sc->sc_out_num_jacks); 1163 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL; 1164 mutex_exit(&sc->sc_lock); 1165 1166 if (jacks) 1167 kmem_free(jacks, len); 1168 } 1169 1170 static usbd_status 1171 bind_jacks_to_mididev(struct umidi_softc *sc, 1172 struct umidi_jack *out_jack, 1173 struct umidi_jack *in_jack, 1174 struct umidi_mididev *mididev) 1175 { 1176 if ((out_jack && out_jack->bound) || (in_jack && in_jack->bound)) 1177 return USBD_IN_USE; 1178 if (mididev->out_jack || mididev->in_jack) 1179 return USBD_IN_USE; 1180 1181 if (out_jack) 1182 out_jack->bound = 1; 1183 if (in_jack) 1184 in_jack->bound = 1; 1185 mididev->in_jack = in_jack; 1186 mididev->out_jack = out_jack; 1187 1188 mididev->closing = 0; 1189 1190 return USBD_NORMAL_COMPLETION; 1191 } 1192 1193 static void 1194 unbind_jacks_from_mididev(struct umidi_mididev *mididev) 1195 { 1196 KASSERT(mutex_owned(&mididev->sc->sc_lock)); 1197 1198 mididev->closing = 1; 1199 1200 if ((mididev->flags & FWRITE) && mididev->out_jack) 1201 close_out_jack(mididev->out_jack); 1202 if ((mididev->flags & FREAD) && mididev->in_jack) 1203 close_in_jack(mididev->in_jack); 1204 1205 if (mididev->out_jack) { 1206 mididev->out_jack->bound = 0; 1207 mididev->out_jack = NULL; 1208 } 1209 if (mididev->in_jack) { 1210 mididev->in_jack->bound = 0; 1211 mididev->in_jack = NULL; 1212 } 1213 } 1214 1215 static void 1216 unbind_all_jacks(struct umidi_softc *sc) 1217 { 1218 int i; 1219 1220 mutex_enter(&sc->sc_lock); 1221 if (sc->sc_mididevs) 1222 for (i = 0; i < sc->sc_num_mididevs; i++) 1223 unbind_jacks_from_mididev(&sc->sc_mididevs[i]); 1224 mutex_exit(&sc->sc_lock); 1225 } 1226 1227 static usbd_status 1228 assign_all_jacks_automatically(struct umidi_softc *sc) 1229 { 1230 usbd_status err; 1231 int i; 1232 struct umidi_jack *out, *in; 1233 const signed char *asg_spec; 1234 1235 err = 1236 alloc_all_mididevs(sc, 1237 uimax(sc->sc_out_num_jacks, sc->sc_in_num_jacks)); 1238 if (err!=USBD_NORMAL_COMPLETION) 1239 return err; 1240 1241 if (UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED)) 1242 asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 1243 UMQ_TYPE_MD_FIXED); 1244 else 1245 asg_spec = NULL; 1246 1247 for (i = 0; i < sc->sc_num_mididevs; i++) { 1248 if (asg_spec != NULL) { 1249 if (*asg_spec == -1) 1250 out = NULL; 1251 else 1252 out = &sc->sc_out_jacks[*asg_spec]; 1253 ++ asg_spec; 1254 if (*asg_spec == -1) 1255 in = NULL; 1256 else 1257 in = &sc->sc_in_jacks[*asg_spec]; 1258 ++ asg_spec; 1259 } else { 1260 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i] 1261 : NULL; 1262 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i] 1263 : NULL; 1264 } 1265 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]); 1266 if (err != USBD_NORMAL_COMPLETION) { 1267 free_all_mididevs(sc); 1268 return err; 1269 } 1270 } 1271 1272 return USBD_NORMAL_COMPLETION; 1273 } 1274 1275 static usbd_status 1276 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *)) 1277 { 1278 struct umidi_endpoint *ep = jack->endpoint; 1279 struct umidi_softc *sc = ep->sc; 1280 umidi_packet_bufp end; 1281 int err; 1282 1283 KASSERT(mutex_owned(&sc->sc_lock)); 1284 1285 if (jack->opened) 1286 return USBD_IN_USE; 1287 1288 jack->arg = arg; 1289 jack->u.out.intr = intr; 1290 jack->midiman_ppkt = NULL; 1291 end = ep->buffer + ep->buffer_size / sizeof(*ep->buffer); 1292 jack->opened = 1; 1293 ep->num_open++; 1294 /* 1295 * out_solicit maintains an invariant that there will always be 1296 * (num_open - num_scheduled) slots free in the buffer. as we have 1297 * just incremented num_open, the buffer may be too full to satisfy 1298 * the invariant until a transfer completes, for which we must wait. 1299 */ 1300 while (end - ep->next_slot < ep->num_open - ep->num_scheduled) { 1301 err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock, 1302 mstohz(10)); 1303 if (err) { 1304 ep->num_open--; 1305 jack->opened = 0; 1306 return USBD_IOERROR; 1307 } 1308 } 1309 1310 return USBD_NORMAL_COMPLETION; 1311 } 1312 1313 static usbd_status 1314 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int)) 1315 { 1316 usbd_status err = USBD_NORMAL_COMPLETION; 1317 struct umidi_endpoint *ep = jack->endpoint; 1318 1319 KASSERT(mutex_owned(&ep->sc->sc_lock)); 1320 1321 if (jack->opened) 1322 return USBD_IN_USE; 1323 1324 jack->arg = arg; 1325 jack->u.in.intr = intr; 1326 jack->opened = 1; 1327 if (ep->num_open++ == 0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) { 1328 /* 1329 * Can't hold the interrupt lock while calling into USB, 1330 * but we can safely drop it here. 1331 */ 1332 mutex_exit(&ep->sc->sc_lock); 1333 err = start_input_transfer(ep); 1334 if (err != USBD_NORMAL_COMPLETION && 1335 err != USBD_IN_PROGRESS) { 1336 ep->num_open--; 1337 } 1338 mutex_enter(&ep->sc->sc_lock); 1339 } 1340 1341 return err; 1342 } 1343 1344 static void 1345 close_out_jack(struct umidi_jack *jack) 1346 { 1347 struct umidi_endpoint *ep; 1348 struct umidi_softc *sc; 1349 uint16_t mask; 1350 int err; 1351 1352 if (jack->opened) { 1353 ep = jack->endpoint; 1354 sc = ep->sc; 1355 1356 KASSERT(mutex_owned(&sc->sc_lock)); 1357 mask = 1 << (jack->cable_number); 1358 while (mask & (ep->this_schedule | ep->next_schedule)) { 1359 err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock, 1360 mstohz(10)); 1361 if (err) 1362 break; 1363 } 1364 /* 1365 * We can re-enter this function from both close() and 1366 * detach(). Make sure only one of them does this part. 1367 */ 1368 if (jack->opened) { 1369 jack->opened = 0; 1370 jack->endpoint->num_open--; 1371 ep->this_schedule &= ~mask; 1372 ep->next_schedule &= ~mask; 1373 } 1374 } 1375 } 1376 1377 static void 1378 close_in_jack(struct umidi_jack *jack) 1379 { 1380 if (jack->opened) { 1381 struct umidi_softc *sc = jack->endpoint->sc; 1382 1383 KASSERT(mutex_owned(&sc->sc_lock)); 1384 1385 jack->opened = 0; 1386 if (--jack->endpoint->num_open == 0) { 1387 /* 1388 * We have to drop the (interrupt) lock so that 1389 * the USB thread lock can be safely taken by 1390 * the abort operation. This is safe as this 1391 * either closing or dying will be set proerly. 1392 */ 1393 mutex_exit(&sc->sc_lock); 1394 usbd_abort_pipe(jack->endpoint->pipe); 1395 mutex_enter(&sc->sc_lock); 1396 } 1397 } 1398 } 1399 1400 static usbd_status 1401 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev) 1402 { 1403 if (mididev->sc) 1404 return USBD_IN_USE; 1405 1406 mididev->sc = sc; 1407 1408 describe_mididev(mididev); 1409 1410 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, sc->sc_dev); 1411 1412 return USBD_NORMAL_COMPLETION; 1413 } 1414 1415 static usbd_status 1416 detach_mididev(struct umidi_mididev *mididev, int flags) 1417 { 1418 struct umidi_softc *sc = mididev->sc; 1419 1420 if (!sc) 1421 return USBD_NO_ADDR; 1422 1423 mutex_enter(&sc->sc_lock); 1424 if (mididev->opened) { 1425 umidi_close(mididev); 1426 } 1427 unbind_jacks_from_mididev(mididev); 1428 mutex_exit(&sc->sc_lock); 1429 1430 if (mididev->mdev != NULL) 1431 config_detach(mididev->mdev, flags); 1432 1433 if (NULL != mididev->label) { 1434 kmem_free(mididev->label, mididev->label_len); 1435 mididev->label = NULL; 1436 } 1437 1438 mididev->sc = NULL; 1439 1440 return USBD_NORMAL_COMPLETION; 1441 } 1442 1443 static void 1444 deactivate_mididev(struct umidi_mididev *mididev) 1445 { 1446 if (mididev->out_jack) 1447 mididev->out_jack->bound = 0; 1448 if (mididev->in_jack) 1449 mididev->in_jack->bound = 0; 1450 } 1451 1452 static usbd_status 1453 alloc_all_mididevs(struct umidi_softc *sc, int nmidi) 1454 { 1455 sc->sc_num_mididevs = nmidi; 1456 sc->sc_mididevs = kmem_zalloc(sizeof(*sc->sc_mididevs)*nmidi, KM_SLEEP); 1457 return USBD_NORMAL_COMPLETION; 1458 } 1459 1460 static void 1461 free_all_mididevs(struct umidi_softc *sc) 1462 { 1463 struct umidi_mididev *mididevs; 1464 size_t len; 1465 1466 mutex_enter(&sc->sc_lock); 1467 mididevs = sc->sc_mididevs; 1468 if (mididevs) 1469 len = sizeof(*sc->sc_mididevs )* sc->sc_num_mididevs; 1470 sc->sc_mididevs = NULL; 1471 sc->sc_num_mididevs = 0; 1472 mutex_exit(&sc->sc_lock); 1473 1474 if (mididevs) 1475 kmem_free(mididevs, len); 1476 } 1477 1478 static usbd_status 1479 attach_all_mididevs(struct umidi_softc *sc) 1480 { 1481 usbd_status err; 1482 int i; 1483 1484 if (sc->sc_mididevs) 1485 for (i = 0; i < sc->sc_num_mididevs; i++) { 1486 err = attach_mididev(sc, &sc->sc_mididevs[i]); 1487 if (err != USBD_NORMAL_COMPLETION) 1488 return err; 1489 } 1490 1491 return USBD_NORMAL_COMPLETION; 1492 } 1493 1494 static usbd_status 1495 detach_all_mididevs(struct umidi_softc *sc, int flags) 1496 { 1497 usbd_status err; 1498 int i; 1499 1500 if (sc->sc_mididevs) 1501 for (i = 0; i < sc->sc_num_mididevs; i++) { 1502 err = detach_mididev(&sc->sc_mididevs[i], flags); 1503 if (err != USBD_NORMAL_COMPLETION) 1504 return err; 1505 } 1506 1507 return USBD_NORMAL_COMPLETION; 1508 } 1509 1510 static void 1511 deactivate_all_mididevs(struct umidi_softc *sc) 1512 { 1513 int i; 1514 1515 if (sc->sc_mididevs) { 1516 for (i = 0; i < sc->sc_num_mididevs; i++) 1517 deactivate_mididev(&sc->sc_mididevs[i]); 1518 } 1519 } 1520 1521 /* 1522 * TODO: the 0-based cable numbers will often not match the labeling of the 1523 * equipment. Ideally: 1524 * For class-compliant devices: get the iJack string from the jack descriptor. 1525 * Otherwise: 1526 * - support a DISPLAY_BASE_CN quirk (add the value to each internal cable 1527 * number for display) 1528 * - support an array quirk explictly giving a char * for each jack. 1529 * For now, you get 0-based cable numbers. If there are multiple endpoints and 1530 * the CNs are not globally unique, each is shown with its associated endpoint 1531 * address in hex also. That should not be necessary when using iJack values 1532 * or a quirk array. 1533 */ 1534 void 1535 describe_mididev(struct umidi_mididev *md) 1536 { 1537 char in_label[16]; 1538 char out_label[16]; 1539 const char *unit_label; 1540 char *final_label; 1541 struct umidi_softc *sc; 1542 int show_ep_in; 1543 int show_ep_out; 1544 size_t len; 1545 1546 sc = md->sc; 1547 show_ep_in = sc-> sc_in_num_endpoints > 1 && !sc->cblnums_global; 1548 show_ep_out = sc->sc_out_num_endpoints > 1 && !sc->cblnums_global; 1549 1550 if (NULL == md->in_jack) 1551 in_label[0] = '\0'; 1552 else if (show_ep_in) 1553 snprintf(in_label, sizeof(in_label), "<%d(%x) ", 1554 md->in_jack->cable_number, md->in_jack->endpoint->addr); 1555 else 1556 snprintf(in_label, sizeof(in_label), "<%d ", 1557 md->in_jack->cable_number); 1558 1559 if (NULL == md->out_jack) 1560 out_label[0] = '\0'; 1561 else if (show_ep_out) 1562 snprintf(out_label, sizeof(out_label), ">%d(%x) ", 1563 md->out_jack->cable_number, md->out_jack->endpoint->addr); 1564 else 1565 snprintf(out_label, sizeof(out_label), ">%d ", 1566 md->out_jack->cable_number); 1567 1568 unit_label = device_xname(sc->sc_dev); 1569 1570 len = strlen(in_label) + strlen(out_label) + strlen(unit_label) + 4; 1571 1572 final_label = kmem_alloc(len, KM_SLEEP); 1573 1574 snprintf(final_label, len, "%s%son %s", 1575 in_label, out_label, unit_label); 1576 1577 md->label = final_label; 1578 md->label_len = len; 1579 } 1580 1581 #ifdef UMIDI_DEBUG 1582 static void 1583 dump_sc(struct umidi_softc *sc) 1584 { 1585 int i; 1586 1587 DPRINTFN(10, ("%s: dump_sc\n", device_xname(sc->sc_dev))); 1588 for (i=0; i<sc->sc_out_num_endpoints; i++) { 1589 DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i])); 1590 dump_ep(&sc->sc_out_ep[i]); 1591 } 1592 for (i=0; i<sc->sc_in_num_endpoints; i++) { 1593 DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i])); 1594 dump_ep(&sc->sc_in_ep[i]); 1595 } 1596 } 1597 1598 static void 1599 dump_ep(struct umidi_endpoint *ep) 1600 { 1601 int i; 1602 for (i=0; i<UMIDI_MAX_EPJACKS; i++) { 1603 if (NULL==ep->jacks[i]) 1604 continue; 1605 DPRINTFN(10, ("\t\tjack[%d]:%p:\n", i, ep->jacks[i])); 1606 dump_jack(ep->jacks[i]); 1607 } 1608 } 1609 static void 1610 dump_jack(struct umidi_jack *jack) 1611 { 1612 DPRINTFN(10, ("\t\t\tep=%p\n", 1613 jack->endpoint)); 1614 } 1615 1616 #endif /* UMIDI_DEBUG */ 1617 1618 1619 1620 /* 1621 * MUX MIDI PACKET 1622 */ 1623 1624 static const int packet_length[16] = { 1625 /*0*/ -1, 1626 /*1*/ -1, 1627 /*2*/ 2, 1628 /*3*/ 3, 1629 /*4*/ 3, 1630 /*5*/ 1, 1631 /*6*/ 2, 1632 /*7*/ 3, 1633 /*8*/ 3, 1634 /*9*/ 3, 1635 /*A*/ 3, 1636 /*B*/ 3, 1637 /*C*/ 2, 1638 /*D*/ 2, 1639 /*E*/ 3, 1640 /*F*/ 1, 1641 }; 1642 1643 #define GET_CN(p) (((unsigned char)(p)>>4)&0x0F) 1644 #define GET_CIN(p) ((unsigned char)(p)&0x0F) 1645 #define MIX_CN_CIN(cn, cin) \ 1646 ((unsigned char)((((unsigned char)(cn)&0x0F)<<4)| \ 1647 ((unsigned char)(cin)&0x0F))) 1648 1649 static usbd_status 1650 start_input_transfer(struct umidi_endpoint *ep) 1651 { 1652 usbd_setup_xfer(ep->xfer, ep, ep->buffer, ep->buffer_size, 1653 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, in_intr); 1654 return usbd_transfer(ep->xfer); 1655 } 1656 1657 static usbd_status 1658 start_output_transfer(struct umidi_endpoint *ep) 1659 { 1660 usbd_status rv; 1661 uint32_t length; 1662 int i; 1663 1664 length = (ep->next_slot - ep->buffer) * sizeof(*ep->buffer); 1665 DPRINTFN(200,("umidi out transfer: start %p end %p length %u\n", 1666 ep->buffer, ep->next_slot, length)); 1667 1668 usbd_setup_xfer(ep->xfer, ep, ep->buffer, length, 0, 1669 USBD_NO_TIMEOUT, out_intr); 1670 rv = usbd_transfer(ep->xfer); 1671 1672 /* 1673 * Once the transfer is scheduled, no more adding to partial 1674 * packets within it. 1675 */ 1676 if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1677 for (i=0; i<UMIDI_MAX_EPJACKS; ++i) 1678 if (NULL != ep->jacks[i]) 1679 ep->jacks[i]->midiman_ppkt = NULL; 1680 } 1681 1682 return rv; 1683 } 1684 1685 #ifdef UMIDI_DEBUG 1686 #define DPR_PACKET(dir, sc, p) \ 1687 if ((unsigned char)(p)[1]!=0xFE) \ 1688 DPRINTFN(500, \ 1689 ("%s: umidi packet(" #dir "): %02X %02X %02X %02X\n", \ 1690 device_xname(sc->sc_dev), \ 1691 (unsigned char)(p)[0], \ 1692 (unsigned char)(p)[1], \ 1693 (unsigned char)(p)[2], \ 1694 (unsigned char)(p)[3])); 1695 #else 1696 #define DPR_PACKET(dir, sc, p) 1697 #endif 1698 1699 /* 1700 * A 4-byte Midiman packet superficially resembles a 4-byte USB MIDI packet 1701 * with the cable number and length in the last byte instead of the first, 1702 * but there the resemblance ends. Where a USB MIDI packet is a semantic 1703 * unit, a Midiman packet is just a wrapper for 1 to 3 bytes of raw MIDI 1704 * with a cable nybble and a length nybble (which, unlike the CIN of a 1705 * real USB MIDI packet, has no semantics at all besides the length). 1706 * A packet received from a Midiman may contain part of a MIDI message, 1707 * more than one MIDI message, or parts of more than one MIDI message. A 1708 * three-byte MIDI message may arrive in three packets of data length 1, and 1709 * running status may be used. Happily, the midi(4) driver above us will put 1710 * it all back together, so the only cost is in USB bandwidth. The device 1711 * has an easier time with what it receives from us: we'll pack messages in 1712 * and across packets, but filling the packets whenever possible and, 1713 * as midi(4) hands us a complete message at a time, we'll never send one 1714 * in a dribble of short packets. 1715 */ 1716 1717 static int 1718 out_jack_output(struct umidi_jack *out_jack, u_char *src, int len, int cin) 1719 { 1720 struct umidi_endpoint *ep = out_jack->endpoint; 1721 struct umidi_softc *sc = ep->sc; 1722 unsigned char *packet; 1723 int plen; 1724 int poff; 1725 1726 KASSERT(mutex_owned(&sc->sc_lock)); 1727 1728 if (sc->sc_dying) 1729 return EIO; 1730 1731 if (!out_jack->opened) 1732 return ENODEV; /* XXX as it was, is this the right errno? */ 1733 1734 sc->sc_refcnt++; 1735 1736 #ifdef UMIDI_DEBUG 1737 if (umididebug >= 100) 1738 microtime(&umidi_tv); 1739 #endif 1740 DPRINTFN(100, ("umidi out: %"PRIu64".%06"PRIu64 1741 "s ep=%p cn=%d len=%d cin=%#x\n", umidi_tv.tv_sec%100, 1742 (uint64_t)umidi_tv.tv_usec, ep, out_jack->cable_number, len, cin)); 1743 1744 packet = *ep->next_slot++; 1745 KASSERT(ep->buffer_size >= 1746 (ep->next_slot - ep->buffer) * sizeof(*ep->buffer)); 1747 memset(packet, 0, UMIDI_PACKET_SIZE); 1748 if (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1749 if (NULL != out_jack->midiman_ppkt) { /* fill out a prev pkt */ 1750 poff = 0x0f & (out_jack->midiman_ppkt[3]); 1751 plen = 3 - poff; 1752 if (plen > len) 1753 plen = len; 1754 memcpy(out_jack->midiman_ppkt+poff, src, plen); 1755 src += plen; 1756 len -= plen; 1757 plen += poff; 1758 out_jack->midiman_ppkt[3] = 1759 MIX_CN_CIN(out_jack->cable_number, plen); 1760 DPR_PACKET(out+, sc, out_jack->midiman_ppkt); 1761 if (3 == plen) 1762 out_jack->midiman_ppkt = NULL; /* no more */ 1763 } 1764 if (0 == len) 1765 ep->next_slot--; /* won't be needed, nevermind */ 1766 else { 1767 memcpy(packet, src, len); 1768 packet[3] = MIX_CN_CIN(out_jack->cable_number, len); 1769 DPR_PACKET(out, sc, packet); 1770 if (len < 3) 1771 out_jack->midiman_ppkt = packet; 1772 } 1773 } else { /* the nice simple USB class-compliant case */ 1774 packet[0] = MIX_CN_CIN(out_jack->cable_number, cin); 1775 memcpy(packet+1, src, len); 1776 DPR_PACKET(out, sc, packet); 1777 } 1778 ep->next_schedule |= 1<<(out_jack->cable_number); 1779 ++ ep->num_scheduled; 1780 if (!ep->armed && !ep->soliciting) { 1781 /* 1782 * It would be bad to call out_solicit directly here (the 1783 * caller need not be reentrant) but a soft interrupt allows 1784 * solicit to run immediately the caller exits its critical 1785 * section, and if the caller has more to write we can get it 1786 * before starting the USB transfer, and send a longer one. 1787 */ 1788 ep->soliciting = 1; 1789 kpreempt_disable(); 1790 softint_schedule(ep->solicit_cookie); 1791 kpreempt_enable(); 1792 } 1793 1794 if (--sc->sc_refcnt < 0) 1795 cv_broadcast(&sc->sc_detach_cv); 1796 1797 return 0; 1798 } 1799 1800 static void 1801 in_intr(struct usbd_xfer *xfer, void *priv, 1802 usbd_status status) 1803 { 1804 int cn, len, i; 1805 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1806 struct umidi_softc *sc = ep->sc; 1807 struct umidi_jack *jack; 1808 unsigned char *packet; 1809 umidi_packet_bufp slot; 1810 umidi_packet_bufp end; 1811 unsigned char *data; 1812 uint32_t count; 1813 1814 if (ep->sc->sc_dying || !ep->num_open) 1815 return; 1816 1817 mutex_enter(&sc->sc_lock); 1818 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1819 if (0 == count % UMIDI_PACKET_SIZE) { 1820 DPRINTFN(200,("%s: input endpoint %p transfer length %u\n", 1821 device_xname(ep->sc->sc_dev), ep, count)); 1822 } else { 1823 DPRINTF(("%s: input endpoint %p odd transfer length %u\n", 1824 device_xname(ep->sc->sc_dev), ep, count)); 1825 } 1826 1827 slot = ep->buffer; 1828 end = slot + count / sizeof(*slot); 1829 1830 for (packet = *slot; slot < end; packet = *++slot) { 1831 1832 if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1833 cn = (0xf0&(packet[3]))>>4; 1834 len = 0x0f&(packet[3]); 1835 data = packet; 1836 } else { 1837 cn = GET_CN(packet[0]); 1838 len = packet_length[GET_CIN(packet[0])]; 1839 data = packet + 1; 1840 } 1841 /* 0 <= cn <= 15 by inspection of above code */ 1842 if (!(jack = ep->jacks[cn]) || cn != jack->cable_number) { 1843 DPRINTF(("%s: stray input endpoint %p cable %d len %d: " 1844 "%02X %02X %02X (try CN_SEQ quirk?)\n", 1845 device_xname(ep->sc->sc_dev), ep, cn, len, 1846 (unsigned)data[0], 1847 (unsigned)data[1], 1848 (unsigned)data[2])); 1849 mutex_exit(&sc->sc_lock); 1850 return; 1851 } 1852 1853 if (!jack->bound || !jack->opened) 1854 continue; 1855 1856 DPRINTFN(500,("%s: input endpoint %p cable %d len %d: " 1857 "%02X %02X %02X\n", 1858 device_xname(ep->sc->sc_dev), ep, cn, len, 1859 (unsigned)data[0], 1860 (unsigned)data[1], 1861 (unsigned)data[2])); 1862 1863 if (jack->u.in.intr) { 1864 for (i = 0; i < len; i++) { 1865 (*jack->u.in.intr)(jack->arg, data[i]); 1866 } 1867 } 1868 1869 } 1870 1871 (void)start_input_transfer(ep); 1872 mutex_exit(&sc->sc_lock); 1873 } 1874 1875 static void 1876 out_intr(struct usbd_xfer *xfer, void *priv, 1877 usbd_status status) 1878 { 1879 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1880 struct umidi_softc *sc = ep->sc; 1881 uint32_t count; 1882 1883 if (sc->sc_dying) 1884 return; 1885 1886 mutex_enter(&sc->sc_lock); 1887 #ifdef UMIDI_DEBUG 1888 if (umididebug >= 200) 1889 microtime(&umidi_tv); 1890 #endif 1891 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1892 if (0 == count % UMIDI_PACKET_SIZE) { 1893 DPRINTFN(200, ("%s: %"PRIu64".%06"PRIu64"s out ep %p xfer " 1894 "length %u\n", device_xname(ep->sc->sc_dev), 1895 umidi_tv.tv_sec%100, (uint64_t)umidi_tv.tv_usec, ep, 1896 count)); 1897 } else { 1898 DPRINTF(("%s: output endpoint %p odd transfer length %u\n", 1899 device_xname(ep->sc->sc_dev), ep, count)); 1900 } 1901 count /= UMIDI_PACKET_SIZE; 1902 1903 /* 1904 * If while the transfer was pending we buffered any new messages, 1905 * move them to the start of the buffer. 1906 */ 1907 ep->next_slot -= count; 1908 if (ep->buffer < ep->next_slot) { 1909 memcpy(ep->buffer, ep->buffer + count, 1910 (char *)ep->next_slot - (char *)ep->buffer); 1911 } 1912 cv_broadcast(&sc->sc_cv); 1913 /* 1914 * Do not want anyone else to see armed <- 0 before soliciting <- 1. 1915 * Running at IPL_USB so the following should happen to be safe. 1916 */ 1917 ep->armed = 0; 1918 if (!ep->soliciting) { 1919 ep->soliciting = 1; 1920 out_solicit_locked(ep); 1921 } 1922 mutex_exit(&sc->sc_lock); 1923 } 1924 1925 /* 1926 * A jack on which we have received a packet must be called back on its 1927 * out.intr handler before it will send us another; it is considered 1928 * 'scheduled'. It is nice and predictable - as long as it is scheduled, 1929 * we need no extra buffer space for it. 1930 * 1931 * In contrast, a jack that is open but not scheduled may supply us a packet 1932 * at any time, driven by the top half, and we must be able to accept it, no 1933 * excuses. So we must ensure that at any point in time there are at least 1934 * (num_open - num_scheduled) slots free. 1935 * 1936 * As long as there are more slots free than that minimum, we can loop calling 1937 * scheduled jacks back on their "interrupt" handlers, soliciting more 1938 * packets, starting the USB transfer only when the buffer space is down to 1939 * the minimum or no jack has any more to send. 1940 */ 1941 1942 static void 1943 out_solicit_locked(void *arg) 1944 { 1945 struct umidi_endpoint *ep = arg; 1946 umidi_packet_bufp end; 1947 uint16_t which; 1948 struct umidi_jack *jack; 1949 1950 KASSERT(mutex_owned(&ep->sc->sc_lock)); 1951 1952 end = ep->buffer + ep->buffer_size / sizeof(*ep->buffer); 1953 1954 for ( ;; ) { 1955 if (end - ep->next_slot <= ep->num_open - ep->num_scheduled) 1956 break; /* at IPL_USB */ 1957 if (ep->this_schedule == 0) { 1958 if (ep->next_schedule == 0) 1959 break; /* at IPL_USB */ 1960 ep->this_schedule = ep->next_schedule; 1961 ep->next_schedule = 0; 1962 } 1963 /* 1964 * At least one jack is scheduled. Find and mask off the least 1965 * set bit in this_schedule and decrement num_scheduled. 1966 * Convert mask to bit index to find the corresponding jack, 1967 * and call its intr handler. If it has a message, it will call 1968 * back one of the output methods, which will set its bit in 1969 * next_schedule (not copied into this_schedule until the 1970 * latter is empty). In this way we round-robin the jacks that 1971 * have messages to send, until the buffer is as full as we 1972 * dare, and then start a transfer. 1973 */ 1974 which = ep->this_schedule; 1975 which &= (~which)+1; /* now mask of least set bit */ 1976 ep->this_schedule &= ~which; 1977 --ep->num_scheduled; 1978 1979 --which; /* now 1s below mask - count 1s to get index */ 1980 which -= ((which >> 1) & 0x5555);/* SWAR credit aggregate.org */ 1981 which = (((which >> 2) & 0x3333) + (which & 0x3333)); 1982 which = (((which >> 4) + which) & 0x0f0f); 1983 which += (which >> 8); 1984 which &= 0x1f; /* the bit index a/k/a jack number */ 1985 1986 jack = ep->jacks[which]; 1987 if (jack->u.out.intr) 1988 (*jack->u.out.intr)(jack->arg); 1989 } 1990 /* intr lock held at loop exit */ 1991 if (!ep->armed && ep->next_slot > ep->buffer) { 1992 /* 1993 * Can't hold the interrupt lock while calling into USB, 1994 * but we can safely drop it here. 1995 */ 1996 mutex_exit(&ep->sc->sc_lock); 1997 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep)); 1998 mutex_enter(&ep->sc->sc_lock); 1999 } 2000 ep->soliciting = 0; 2001 } 2002 2003 /* Entry point for the softintr. */ 2004 static void 2005 out_solicit(void *arg) 2006 { 2007 struct umidi_endpoint *ep = arg; 2008 struct umidi_softc *sc = ep->sc; 2009 2010 mutex_enter(&sc->sc_lock); 2011 out_solicit_locked(arg); 2012 mutex_exit(&sc->sc_lock); 2013 } 2014