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