1 /* $NetBSD: umidi.c,v 1.70 2016/05/07 08:09:43 mrg 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.70 2016/05/07 08:09:43 mrg Exp $"); 36 37 #include <sys/types.h> 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/kernel.h> 41 #include <sys/kmem.h> 42 #include <sys/device.h> 43 #include <sys/ioctl.h> 44 #include <sys/conf.h> 45 #include <sys/file.h> 46 #include <sys/select.h> 47 #include <sys/proc.h> 48 #include <sys/vnode.h> 49 #include <sys/poll.h> 50 #include <sys/intr.h> 51 52 #include <dev/usb/usb.h> 53 #include <dev/usb/usbdi.h> 54 #include <dev/usb/usbdi_util.h> 55 56 #include <dev/auconv.h> 57 #include <dev/usb/usbdevs.h> 58 #include <dev/usb/umidi_quirks.h> 59 #include <dev/midi_if.h> 60 61 /* Jack Descriptor */ 62 #define UMIDI_MS_HEADER 0x01 63 #define UMIDI_IN_JACK 0x02 64 #define UMIDI_OUT_JACK 0x03 65 66 /* Jack Type */ 67 #define UMIDI_EMBEDDED 0x01 68 #define UMIDI_EXTERNAL 0x02 69 70 /* generic, for iteration */ 71 typedef struct { 72 uByte bLength; 73 uByte bDescriptorType; 74 uByte bDescriptorSubtype; 75 } UPACKED umidi_cs_descriptor_t; 76 77 typedef struct { 78 uByte bLength; 79 uByte bDescriptorType; 80 uByte bDescriptorSubtype; 81 uWord bcdMSC; 82 uWord wTotalLength; 83 } UPACKED umidi_cs_interface_descriptor_t; 84 #define UMIDI_CS_INTERFACE_DESCRIPTOR_SIZE 7 85 86 typedef struct { 87 uByte bLength; 88 uByte bDescriptorType; 89 uByte bDescriptorSubtype; 90 uByte bNumEmbMIDIJack; 91 } UPACKED umidi_cs_endpoint_descriptor_t; 92 #define UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE 4 93 94 typedef struct { 95 uByte bLength; 96 uByte bDescriptorType; 97 uByte bDescriptorSubtype; 98 uByte bJackType; 99 uByte bJackID; 100 } UPACKED umidi_jack_descriptor_t; 101 #define UMIDI_JACK_DESCRIPTOR_SIZE 5 102 103 104 #define TO_D(p) ((usb_descriptor_t *)(p)) 105 #define NEXT_D(desc) TO_D((char *)(desc)+(desc)->bLength) 106 #define TO_IFD(desc) ((usb_interface_descriptor_t *)(desc)) 107 #define TO_CSIFD(desc) ((umidi_cs_interface_descriptor_t *)(desc)) 108 #define TO_EPD(desc) ((usb_endpoint_descriptor_t *)(desc)) 109 #define TO_CSEPD(desc) ((umidi_cs_endpoint_descriptor_t *)(desc)) 110 111 112 #define UMIDI_PACKET_SIZE 4 113 114 /* 115 * hierarchie 116 * 117 * <-- parent child --> 118 * 119 * umidi(sc) -> endpoint -> jack <- (dynamically assignable) - mididev 120 * ^ | ^ | 121 * +-----+ +-----+ 122 */ 123 124 /* midi device */ 125 struct umidi_mididev { 126 struct umidi_softc *sc; 127 device_t mdev; 128 /* */ 129 struct umidi_jack *in_jack; 130 struct umidi_jack *out_jack; 131 char *label; 132 size_t label_len; 133 /* */ 134 int opened; 135 int closing; 136 int flags; 137 }; 138 139 /* Jack Information */ 140 struct umidi_jack { 141 struct umidi_endpoint *endpoint; 142 /* */ 143 int cable_number; 144 void *arg; 145 int bound; 146 int opened; 147 unsigned char *midiman_ppkt; 148 union { 149 struct { 150 void (*intr)(void *); 151 } out; 152 struct { 153 void (*intr)(void *, int); 154 } in; 155 } u; 156 }; 157 158 #define UMIDI_MAX_EPJACKS 16 159 typedef unsigned char (*umidi_packet_bufp)[UMIDI_PACKET_SIZE]; 160 /* endpoint data */ 161 struct umidi_endpoint { 162 struct umidi_softc *sc; 163 /* */ 164 int addr; 165 struct usbd_pipe *pipe; 166 struct usbd_xfer *xfer; 167 umidi_packet_bufp buffer; 168 umidi_packet_bufp next_slot; 169 uint32_t buffer_size; 170 int num_scheduled; 171 int num_open; 172 int num_jacks; 173 int soliciting; 174 void *solicit_cookie; 175 int armed; 176 struct umidi_jack *jacks[UMIDI_MAX_EPJACKS]; 177 uint16_t this_schedule; /* see UMIDI_MAX_EPJACKS */ 178 uint16_t next_schedule; 179 }; 180 181 /* software context */ 182 struct umidi_softc { 183 device_t sc_dev; 184 struct usbd_device *sc_udev; 185 struct usbd_interface *sc_iface; 186 const struct umidi_quirk *sc_quirk; 187 188 int sc_dying; 189 190 int sc_out_num_jacks; 191 struct umidi_jack *sc_out_jacks; 192 int sc_in_num_jacks; 193 struct umidi_jack *sc_in_jacks; 194 struct umidi_jack *sc_jacks; 195 196 int sc_num_mididevs; 197 struct umidi_mididev *sc_mididevs; 198 199 int sc_out_num_endpoints; 200 struct umidi_endpoint *sc_out_ep; 201 int sc_in_num_endpoints; 202 struct umidi_endpoint *sc_in_ep; 203 struct umidi_endpoint *sc_endpoints; 204 size_t sc_endpoints_len; 205 int cblnums_global; 206 207 kmutex_t sc_lock; 208 kcondvar_t sc_cv; 209 kcondvar_t sc_detach_cv; 210 211 int sc_refcnt; 212 }; 213 214 #ifdef UMIDI_DEBUG 215 #define DPRINTF(x) if (umididebug) printf x 216 #define DPRINTFN(n,x) if (umididebug >= (n)) printf x 217 #include <sys/time.h> 218 static struct timeval umidi_tv; 219 int umididebug = 0; 220 #else 221 #define DPRINTF(x) 222 #define DPRINTFN(n,x) 223 #endif 224 225 #define UMIDI_ENDPOINT_SIZE(sc) (sizeof(*(sc)->sc_out_ep) * \ 226 (sc->sc_out_num_endpoints + \ 227 sc->sc_in_num_endpoints)) 228 229 230 static int umidi_open(void *, int, 231 void (*)(void *, int), void (*)(void *), void *); 232 static void umidi_close(void *); 233 static int umidi_channelmsg(void *, int, int, u_char *, int); 234 static int umidi_commonmsg(void *, int, u_char *, int); 235 static int umidi_sysex(void *, u_char *, int); 236 static int umidi_rtmsg(void *, int); 237 static void umidi_getinfo(void *, struct midi_info *); 238 static void umidi_get_locks(void *, kmutex_t **, kmutex_t **); 239 240 static usbd_status alloc_pipe(struct umidi_endpoint *); 241 static void free_pipe(struct umidi_endpoint *); 242 243 static usbd_status alloc_all_endpoints(struct umidi_softc *); 244 static void free_all_endpoints(struct umidi_softc *); 245 246 static usbd_status alloc_all_jacks(struct umidi_softc *); 247 static void free_all_jacks(struct umidi_softc *); 248 static usbd_status bind_jacks_to_mididev(struct umidi_softc *, 249 struct umidi_jack *, 250 struct umidi_jack *, 251 struct umidi_mididev *); 252 static void unbind_jacks_from_mididev(struct umidi_mididev *); 253 static void unbind_all_jacks(struct umidi_softc *); 254 static usbd_status assign_all_jacks_automatically(struct umidi_softc *); 255 static usbd_status open_out_jack(struct umidi_jack *, void *, 256 void (*)(void *)); 257 static usbd_status open_in_jack(struct umidi_jack *, void *, 258 void (*)(void *, int)); 259 static void close_out_jack(struct umidi_jack *); 260 static void close_in_jack(struct umidi_jack *); 261 262 static usbd_status attach_mididev(struct umidi_softc *, struct umidi_mididev *); 263 static usbd_status detach_mididev(struct umidi_mididev *, int); 264 static void deactivate_mididev(struct umidi_mididev *); 265 static usbd_status alloc_all_mididevs(struct umidi_softc *, int); 266 static void free_all_mididevs(struct umidi_softc *); 267 static usbd_status attach_all_mididevs(struct umidi_softc *); 268 static usbd_status detach_all_mididevs(struct umidi_softc *, int); 269 static void deactivate_all_mididevs(struct umidi_softc *); 270 static void describe_mididev(struct umidi_mididev *); 271 272 #ifdef UMIDI_DEBUG 273 static void dump_sc(struct umidi_softc *); 274 static void dump_ep(struct umidi_endpoint *); 275 static void dump_jack(struct umidi_jack *); 276 #endif 277 278 static usbd_status start_input_transfer(struct umidi_endpoint *); 279 static usbd_status start_output_transfer(struct umidi_endpoint *); 280 static int out_jack_output(struct umidi_jack *, u_char *, int, int); 281 static void in_intr(struct usbd_xfer *, void *, usbd_status); 282 static void out_intr(struct usbd_xfer *, void *, usbd_status); 283 static void out_solicit(void *); /* struct umidi_endpoint* for softintr */ 284 static void out_solicit_locked(void *); /* pre-locked version */ 285 286 287 const struct midi_hw_if umidi_hw_if = { 288 .open = umidi_open, 289 .close = umidi_close, 290 .output = umidi_rtmsg, 291 .getinfo = umidi_getinfo, 292 .get_locks = umidi_get_locks, 293 }; 294 295 struct midi_hw_if_ext umidi_hw_if_ext = { 296 .channel = umidi_channelmsg, 297 .common = umidi_commonmsg, 298 .sysex = umidi_sysex, 299 }; 300 301 struct midi_hw_if_ext umidi_hw_if_mm = { 302 .channel = umidi_channelmsg, 303 .common = umidi_commonmsg, 304 .sysex = umidi_sysex, 305 .compress = 1, 306 }; 307 308 int umidi_match(device_t, cfdata_t, void *); 309 void umidi_attach(device_t, device_t, void *); 310 void umidi_childdet(device_t, device_t); 311 int umidi_detach(device_t, int); 312 int umidi_activate(device_t, enum devact); 313 extern struct cfdriver umidi_cd; 314 CFATTACH_DECL2_NEW(umidi, sizeof(struct umidi_softc), umidi_match, 315 umidi_attach, umidi_detach, umidi_activate, NULL, umidi_childdet); 316 317 int 318 umidi_match(device_t parent, cfdata_t match, void *aux) 319 { 320 struct usbif_attach_arg *uiaa = aux; 321 322 DPRINTFN(1,("umidi_match\n")); 323 324 if (umidi_search_quirk(uiaa->uiaa_vendor, uiaa->uiaa_product, 325 uiaa->uiaa_ifaceno)) 326 return UMATCH_IFACECLASS_IFACESUBCLASS; 327 328 if (uiaa->uiaa_class == UICLASS_AUDIO && 329 uiaa->uiaa_subclass == UISUBCLASS_MIDISTREAM) 330 return UMATCH_IFACECLASS_IFACESUBCLASS; 331 332 return UMATCH_NONE; 333 } 334 335 void 336 umidi_attach(device_t parent, device_t self, void *aux) 337 { 338 usbd_status err; 339 struct umidi_softc *sc = device_private(self); 340 struct usbif_attach_arg *uiaa = aux; 341 char *devinfop; 342 343 DPRINTFN(1,("umidi_attach\n")); 344 345 sc->sc_dev = self; 346 347 aprint_naive("\n"); 348 aprint_normal("\n"); 349 350 devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0); 351 aprint_normal_dev(self, "%s\n", devinfop); 352 usbd_devinfo_free(devinfop); 353 354 sc->sc_iface = uiaa->uiaa_iface; 355 sc->sc_udev = uiaa->uiaa_device; 356 357 sc->sc_quirk = umidi_search_quirk(uiaa->uiaa_vendor, 358 uiaa->uiaa_product, uiaa->uiaa_ifaceno); 359 360 aprint_normal_dev(self, ""); 361 umidi_print_quirk(sc->sc_quirk); 362 363 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB); 364 cv_init(&sc->sc_cv, "umidopcl"); 365 cv_init(&sc->sc_detach_cv, "umidetcv"); 366 sc->sc_refcnt = 0; 367 368 err = alloc_all_endpoints(sc); 369 if (err != USBD_NORMAL_COMPLETION) { 370 aprint_error_dev(self, 371 "alloc_all_endpoints failed. (err=%d)\n", err); 372 goto out; 373 } 374 err = alloc_all_jacks(sc); 375 if (err != USBD_NORMAL_COMPLETION) { 376 aprint_error_dev(self, "alloc_all_jacks failed. (err=%d)\n", 377 err); 378 goto out_free_endpoints; 379 } 380 aprint_normal_dev(self, "out=%d, in=%d\n", 381 sc->sc_out_num_jacks, sc->sc_in_num_jacks); 382 383 err = assign_all_jacks_automatically(sc); 384 if (err != USBD_NORMAL_COMPLETION) { 385 aprint_error_dev(self, 386 "assign_all_jacks_automatically failed. (err=%d)\n", err); 387 goto out_free_jacks; 388 } 389 err = attach_all_mididevs(sc); 390 if (err != USBD_NORMAL_COMPLETION) { 391 aprint_error_dev(self, 392 "attach_all_mididevs failed. (err=%d)\n", err); 393 goto out_free_jacks; 394 } 395 396 #ifdef UMIDI_DEBUG 397 dump_sc(sc); 398 #endif 399 400 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, 401 sc->sc_udev, sc->sc_dev); 402 403 return; 404 405 out_free_jacks: 406 unbind_all_jacks(sc); 407 free_all_jacks(sc); 408 409 out_free_endpoints: 410 free_all_endpoints(sc); 411 412 out: 413 aprint_error_dev(self, "disabled.\n"); 414 sc->sc_dying = 1; 415 KERNEL_UNLOCK_ONE(curlwp); 416 return; 417 } 418 419 void 420 umidi_childdet(device_t self, device_t child) 421 { 422 int i; 423 struct umidi_softc *sc = device_private(self); 424 425 KASSERT(sc->sc_mididevs != NULL); 426 427 for (i = 0; i < sc->sc_num_mididevs; i++) { 428 if (sc->sc_mididevs[i].mdev == child) 429 break; 430 } 431 KASSERT(i < sc->sc_num_mididevs); 432 sc->sc_mididevs[i].mdev = NULL; 433 } 434 435 int 436 umidi_activate(device_t self, enum devact act) 437 { 438 struct umidi_softc *sc = device_private(self); 439 440 switch (act) { 441 case DVACT_DEACTIVATE: 442 DPRINTFN(1,("umidi_activate (deactivate)\n")); 443 sc->sc_dying = 1; 444 deactivate_all_mididevs(sc); 445 return 0; 446 default: 447 DPRINTFN(1,("umidi_activate (%d)\n", act)); 448 return EOPNOTSUPP; 449 } 450 } 451 452 int 453 umidi_detach(device_t self, int flags) 454 { 455 struct umidi_softc *sc = device_private(self); 456 457 DPRINTFN(1,("umidi_detach\n")); 458 459 mutex_enter(&sc->sc_lock); 460 sc->sc_dying = 1; 461 if (--sc->sc_refcnt >= 0) 462 usb_detach_wait(sc->sc_dev, &sc->sc_detach_cv, &sc->sc_lock); 463 mutex_exit(&sc->sc_lock); 464 465 detach_all_mididevs(sc, flags); 466 free_all_mididevs(sc); 467 free_all_jacks(sc); 468 free_all_endpoints(sc); 469 470 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 471 sc->sc_dev); 472 473 mutex_destroy(&sc->sc_lock); 474 cv_destroy(&sc->sc_detach_cv); 475 cv_destroy(&sc->sc_cv); 476 477 return 0; 478 } 479 480 481 /* 482 * midi_if stuffs 483 */ 484 int 485 umidi_open(void *addr, 486 int flags, 487 void (*iintr)(void *, int), 488 void (*ointr)(void *), 489 void *arg) 490 { 491 struct umidi_mididev *mididev = addr; 492 struct umidi_softc *sc = mididev->sc; 493 usbd_status err; 494 495 KASSERT(mutex_owned(&sc->sc_lock)); 496 DPRINTF(("umidi_open: sc=%p\n", sc)); 497 498 if (mididev->opened) 499 return EBUSY; 500 if (sc->sc_dying) 501 return EIO; 502 503 mididev->opened = 1; 504 mididev->flags = flags; 505 if ((mididev->flags & FWRITE) && mididev->out_jack) { 506 err = open_out_jack(mididev->out_jack, arg, ointr); 507 if (err != USBD_NORMAL_COMPLETION) 508 goto bad; 509 } 510 if ((mididev->flags & FREAD) && mididev->in_jack) { 511 err = open_in_jack(mididev->in_jack, arg, iintr); 512 KASSERT(mididev->opened); 513 if (err != USBD_NORMAL_COMPLETION && 514 err != USBD_IN_PROGRESS) { 515 if (mididev->out_jack) 516 close_out_jack(mididev->out_jack); 517 goto bad; 518 } 519 } 520 521 return 0; 522 bad: 523 mididev->opened = 0; 524 DPRINTF(("umidi_open: usbd_status %d\n", err)); 525 KASSERT(mutex_owned(&sc->sc_lock)); 526 return USBD_IN_USE == err ? EBUSY : EIO; 527 } 528 529 void 530 umidi_close(void *addr) 531 { 532 struct umidi_mididev *mididev = addr; 533 struct umidi_softc *sc = mididev->sc; 534 535 KASSERT(mutex_owned(&sc->sc_lock)); 536 537 if (mididev->closing) 538 return; 539 540 mididev->closing = 1; 541 542 sc->sc_refcnt++; 543 544 if ((mididev->flags & FWRITE) && mididev->out_jack) 545 close_out_jack(mididev->out_jack); 546 if ((mididev->flags & FREAD) && mididev->in_jack) 547 close_in_jack(mididev->in_jack); 548 549 if (--sc->sc_refcnt < 0) 550 usb_detach_broadcast(sc->sc_dev, &sc->sc_detach_cv); 551 552 mididev->opened = 0; 553 mididev->closing = 0; 554 } 555 556 int 557 umidi_channelmsg(void *addr, int status, int channel, u_char *msg, 558 int len) 559 { 560 struct umidi_mididev *mididev = addr; 561 562 KASSERT(mutex_owned(&mididev->sc->sc_lock)); 563 564 if (!mididev->out_jack || !mididev->opened || mididev->closing) 565 return EIO; 566 567 return out_jack_output(mididev->out_jack, msg, len, (status>>4)&0xf); 568 } 569 570 int 571 umidi_commonmsg(void *addr, int status, u_char *msg, int len) 572 { 573 struct umidi_mididev *mididev = addr; 574 int cin; 575 576 KASSERT(mutex_owned(&mididev->sc->sc_lock)); 577 578 if (!mididev->out_jack || !mididev->opened || mididev->closing) 579 return EIO; 580 581 switch ( len ) { 582 case 1: cin = 5; break; 583 case 2: cin = 2; break; 584 case 3: cin = 3; break; 585 default: return EIO; /* or gcc warns of cin uninitialized */ 586 } 587 588 return out_jack_output(mididev->out_jack, msg, len, cin); 589 } 590 591 int 592 umidi_sysex(void *addr, u_char *msg, int len) 593 { 594 struct umidi_mididev *mididev = addr; 595 int cin; 596 597 KASSERT(mutex_owned(&mididev->sc->sc_lock)); 598 599 if (!mididev->out_jack || !mididev->opened || mididev->closing) 600 return EIO; 601 602 switch ( len ) { 603 case 1: cin = 5; break; 604 case 2: cin = 6; break; 605 case 3: cin = (msg[2] == 0xf7) ? 7 : 4; break; 606 default: return EIO; /* or gcc warns of cin uninitialized */ 607 } 608 609 return out_jack_output(mididev->out_jack, msg, len, cin); 610 } 611 612 int 613 umidi_rtmsg(void *addr, int d) 614 { 615 struct umidi_mididev *mididev = addr; 616 u_char msg = d; 617 618 KASSERT(mutex_owned(&mididev->sc->sc_lock)); 619 620 if (!mididev->out_jack || !mididev->opened || mididev->closing) 621 return EIO; 622 623 return out_jack_output(mididev->out_jack, &msg, 1, 0xf); 624 } 625 626 void 627 umidi_getinfo(void *addr, struct midi_info *mi) 628 { 629 struct umidi_mididev *mididev = addr; 630 struct umidi_softc *sc = mididev->sc; 631 int mm = UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE); 632 633 KASSERT(mutex_owned(&sc->sc_lock)); 634 635 mi->name = mididev->label; 636 mi->props = MIDI_PROP_OUT_INTR; 637 if (mididev->in_jack) 638 mi->props |= MIDI_PROP_CAN_INPUT; 639 midi_register_hw_if_ext(mm? &umidi_hw_if_mm : &umidi_hw_if_ext); 640 } 641 642 static void 643 umidi_get_locks(void *addr, kmutex_t **thread, kmutex_t **intr) 644 { 645 struct umidi_mididev *mididev = addr; 646 struct umidi_softc *sc = mididev->sc; 647 648 *intr = NULL; 649 *thread = &sc->sc_lock; 650 } 651 652 /* 653 * each endpoint stuffs 654 */ 655 656 /* alloc/free pipe */ 657 static usbd_status 658 alloc_pipe(struct umidi_endpoint *ep) 659 { 660 struct umidi_softc *sc = ep->sc; 661 usbd_status err; 662 usb_endpoint_descriptor_t *epd; 663 664 epd = usbd_get_endpoint_descriptor(sc->sc_iface, ep->addr); 665 /* 666 * For output, an improvement would be to have a buffer bigger than 667 * wMaxPacketSize by num_jacks-1 additional packet slots; that would 668 * allow out_solicit to fill the buffer to the full packet size in 669 * all cases. But to use usbd_create_xfer to get a slightly larger 670 * buffer would not be a good way to do that, because if the addition 671 * would make the buffer exceed USB_MEM_SMALL then a substantially 672 * larger block may be wastefully allocated. Some flavor of double 673 * buffering could serve the same purpose, but would increase the 674 * code complexity, so for now I will live with the current slight 675 * penalty of reducing max transfer size by (num_open-num_scheduled) 676 * packet slots. 677 */ 678 ep->buffer_size = UGETW(epd->wMaxPacketSize); 679 ep->buffer_size -= ep->buffer_size % UMIDI_PACKET_SIZE; 680 681 DPRINTF(("%s: alloc_pipe %p, buffer size %u\n", 682 device_xname(sc->sc_dev), ep, ep->buffer_size)); 683 ep->num_scheduled = 0; 684 ep->this_schedule = 0; 685 ep->next_schedule = 0; 686 ep->soliciting = 0; 687 ep->armed = 0; 688 err = usbd_open_pipe(sc->sc_iface, ep->addr, USBD_MPSAFE, &ep->pipe); 689 if (err) 690 goto quit; 691 int error = usbd_create_xfer(ep->pipe, ep->buffer_size, 692 USBD_SHORT_XFER_OK, 0, &ep->xfer); 693 if (error) { 694 usbd_close_pipe(ep->pipe); 695 return USBD_NOMEM; 696 } 697 ep->buffer = usbd_get_buffer(ep->xfer); 698 ep->next_slot = ep->buffer; 699 ep->solicit_cookie = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE, out_solicit, ep); 700 quit: 701 return err; 702 } 703 704 static void 705 free_pipe(struct umidi_endpoint *ep) 706 { 707 DPRINTF(("%s: free_pipe %p\n", device_xname(ep->sc->sc_dev), ep)); 708 usbd_abort_pipe(ep->pipe); 709 usbd_destroy_xfer(ep->xfer); 710 usbd_close_pipe(ep->pipe); 711 softint_disestablish(ep->solicit_cookie); 712 } 713 714 715 /* alloc/free the array of endpoint structures */ 716 717 static usbd_status alloc_all_endpoints_fixed_ep(struct umidi_softc *); 718 static usbd_status alloc_all_endpoints_yamaha(struct umidi_softc *); 719 static usbd_status alloc_all_endpoints_genuine(struct umidi_softc *); 720 721 static usbd_status 722 alloc_all_endpoints(struct umidi_softc *sc) 723 { 724 usbd_status err; 725 struct umidi_endpoint *ep; 726 int i; 727 728 if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) { 729 err = alloc_all_endpoints_fixed_ep(sc); 730 } else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) { 731 err = alloc_all_endpoints_yamaha(sc); 732 } else { 733 err = alloc_all_endpoints_genuine(sc); 734 } 735 if (err != USBD_NORMAL_COMPLETION) 736 return err; 737 738 ep = sc->sc_endpoints; 739 for (i = sc->sc_out_num_endpoints+sc->sc_in_num_endpoints; i > 0; i--) { 740 err = alloc_pipe(ep++); 741 if (err != USBD_NORMAL_COMPLETION) { 742 for (; ep != sc->sc_endpoints; ep--) 743 free_pipe(ep-1); 744 kmem_free(sc->sc_endpoints, sc->sc_endpoints_len); 745 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 746 break; 747 } 748 } 749 return err; 750 } 751 752 static void 753 free_all_endpoints(struct umidi_softc *sc) 754 { 755 int i; 756 757 for (i=0; i<sc->sc_in_num_endpoints+sc->sc_out_num_endpoints; i++) 758 free_pipe(&sc->sc_endpoints[i]); 759 if (sc->sc_endpoints != NULL) 760 kmem_free(sc->sc_endpoints, sc->sc_endpoints_len); 761 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 762 } 763 764 static usbd_status 765 alloc_all_endpoints_fixed_ep(struct umidi_softc *sc) 766 { 767 usbd_status err; 768 const struct umq_fixed_ep_desc *fp; 769 struct umidi_endpoint *ep; 770 usb_endpoint_descriptor_t *epd; 771 int i; 772 773 fp = umidi_get_quirk_data_from_type(sc->sc_quirk, 774 UMQ_TYPE_FIXED_EP); 775 sc->sc_out_num_jacks = 0; 776 sc->sc_in_num_jacks = 0; 777 sc->sc_out_num_endpoints = fp->num_out_ep; 778 sc->sc_in_num_endpoints = fp->num_in_ep; 779 sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc); 780 sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP); 781 if (!sc->sc_endpoints) 782 return USBD_NOMEM; 783 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, "illegal endpoint(out:%d)\n", 804 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_endpoints) 936 return USBD_NOMEM; 937 if (sc->sc_out_num_endpoints) { 938 sc->sc_out_ep = sc->sc_endpoints; 939 sc->sc_out_ep->sc = sc; 940 sc->sc_out_ep->addr = out_addr; 941 sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks; 942 sc->sc_out_ep->num_open = 0; 943 } else 944 sc->sc_out_ep = NULL; 945 946 if (sc->sc_in_num_endpoints) { 947 sc->sc_in_ep = sc->sc_endpoints+sc->sc_out_num_endpoints; 948 sc->sc_in_ep->sc = sc; 949 sc->sc_in_ep->addr = in_addr; 950 sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks; 951 sc->sc_in_ep->num_open = 0; 952 } else 953 sc->sc_in_ep = NULL; 954 955 return USBD_NORMAL_COMPLETION; 956 } 957 958 static usbd_status 959 alloc_all_endpoints_genuine(struct umidi_softc *sc) 960 { 961 usb_interface_descriptor_t *interface_desc; 962 usb_config_descriptor_t *config_desc; 963 usb_descriptor_t *desc; 964 int num_ep; 965 size_t remain, descsize; 966 struct umidi_endpoint *p, *q, *lowest, *endep, tmpep; 967 int epaddr; 968 969 interface_desc = usbd_get_interface_descriptor(sc->sc_iface); 970 num_ep = interface_desc->bNumEndpoints; 971 sc->sc_endpoints_len = sizeof(struct umidi_endpoint) * num_ep; 972 sc->sc_endpoints = p = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP); 973 if (!p) 974 return USBD_NOMEM; 975 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 sc->sc_jacks = kmem_zalloc(sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+ 1088 sc->sc_out_num_jacks), KM_SLEEP); 1089 if (!sc->sc_jacks) 1090 return USBD_NOMEM; 1091 sc->sc_out_jacks = 1092 sc->sc_out_num_jacks ? sc->sc_jacks : NULL; 1093 sc->sc_in_jacks = 1094 sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL; 1095 1096 jack = &sc->sc_out_jacks[0]; 1097 for (i = 0; i < sc->sc_out_num_jacks; i++) { 1098 jack->opened = 0; 1099 jack->bound = 0; 1100 jack->arg = NULL; 1101 jack->u.out.intr = NULL; 1102 jack->midiman_ppkt = NULL; 1103 if (sc->cblnums_global) 1104 jack->cable_number = i; 1105 jack++; 1106 } 1107 jack = &sc->sc_in_jacks[0]; 1108 for (i = 0; i < sc->sc_in_num_jacks; i++) { 1109 jack->opened = 0; 1110 jack->bound = 0; 1111 jack->arg = NULL; 1112 jack->u.in.intr = NULL; 1113 if (sc->cblnums_global) 1114 jack->cable_number = i; 1115 jack++; 1116 } 1117 1118 /* assign each jacks to each endpoints */ 1119 jack = &sc->sc_out_jacks[0]; 1120 ep = &sc->sc_out_ep[0]; 1121 for (i = 0; i < sc->sc_out_num_endpoints; i++) { 1122 for (j = 0; j < ep->num_jacks; j++) { 1123 jack->endpoint = ep; 1124 if (cn_spec != NULL) 1125 jack->cable_number = *cn_spec++; 1126 else if (!sc->cblnums_global) 1127 jack->cable_number = j; 1128 ep->jacks[jack->cable_number] = jack; 1129 jack++; 1130 } 1131 ep++; 1132 } 1133 jack = &sc->sc_in_jacks[0]; 1134 ep = &sc->sc_in_ep[0]; 1135 for (i = 0; i < sc->sc_in_num_endpoints; i++) { 1136 for (j = 0; j < ep->num_jacks; j++) { 1137 jack->endpoint = ep; 1138 if (cn_spec != NULL) 1139 jack->cable_number = *cn_spec++; 1140 else if (!sc->cblnums_global) 1141 jack->cable_number = j; 1142 ep->jacks[jack->cable_number] = jack; 1143 jack++; 1144 } 1145 ep++; 1146 } 1147 1148 return USBD_NORMAL_COMPLETION; 1149 } 1150 1151 static void 1152 free_all_jacks(struct umidi_softc *sc) 1153 { 1154 struct umidi_jack *jacks; 1155 size_t len; 1156 1157 mutex_enter(&sc->sc_lock); 1158 jacks = sc->sc_jacks; 1159 len = sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+sc->sc_out_num_jacks); 1160 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL; 1161 mutex_exit(&sc->sc_lock); 1162 1163 if (jacks) 1164 kmem_free(jacks, len); 1165 } 1166 1167 static usbd_status 1168 bind_jacks_to_mididev(struct umidi_softc *sc, 1169 struct umidi_jack *out_jack, 1170 struct umidi_jack *in_jack, 1171 struct umidi_mididev *mididev) 1172 { 1173 if ((out_jack && out_jack->bound) || (in_jack && in_jack->bound)) 1174 return USBD_IN_USE; 1175 if (mididev->out_jack || mididev->in_jack) 1176 return USBD_IN_USE; 1177 1178 if (out_jack) 1179 out_jack->bound = 1; 1180 if (in_jack) 1181 in_jack->bound = 1; 1182 mididev->in_jack = in_jack; 1183 mididev->out_jack = out_jack; 1184 1185 mididev->closing = 0; 1186 1187 return USBD_NORMAL_COMPLETION; 1188 } 1189 1190 static void 1191 unbind_jacks_from_mididev(struct umidi_mididev *mididev) 1192 { 1193 KASSERT(mutex_owned(&mididev->sc->sc_lock)); 1194 1195 mididev->closing = 1; 1196 1197 if ((mididev->flags & FWRITE) && mididev->out_jack) 1198 close_out_jack(mididev->out_jack); 1199 if ((mididev->flags & FREAD) && mididev->in_jack) 1200 close_in_jack(mididev->in_jack); 1201 1202 if (mididev->out_jack) { 1203 mididev->out_jack->bound = 0; 1204 mididev->out_jack = NULL; 1205 } 1206 if (mididev->in_jack) { 1207 mididev->in_jack->bound = 0; 1208 mididev->in_jack = NULL; 1209 } 1210 } 1211 1212 static void 1213 unbind_all_jacks(struct umidi_softc *sc) 1214 { 1215 int i; 1216 1217 mutex_enter(&sc->sc_lock); 1218 if (sc->sc_mididevs) 1219 for (i = 0; i < sc->sc_num_mididevs; i++) 1220 unbind_jacks_from_mididev(&sc->sc_mididevs[i]); 1221 mutex_exit(&sc->sc_lock); 1222 } 1223 1224 static usbd_status 1225 assign_all_jacks_automatically(struct umidi_softc *sc) 1226 { 1227 usbd_status err; 1228 int i; 1229 struct umidi_jack *out, *in; 1230 const signed char *asg_spec; 1231 1232 err = 1233 alloc_all_mididevs(sc, 1234 max(sc->sc_out_num_jacks, sc->sc_in_num_jacks)); 1235 if (err!=USBD_NORMAL_COMPLETION) 1236 return err; 1237 1238 if (UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED)) 1239 asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 1240 UMQ_TYPE_MD_FIXED); 1241 else 1242 asg_spec = NULL; 1243 1244 for (i = 0; i < sc->sc_num_mididevs; i++) { 1245 if (asg_spec != NULL) { 1246 if (*asg_spec == -1) 1247 out = NULL; 1248 else 1249 out = &sc->sc_out_jacks[*asg_spec]; 1250 ++ asg_spec; 1251 if (*asg_spec == -1) 1252 in = NULL; 1253 else 1254 in = &sc->sc_in_jacks[*asg_spec]; 1255 ++ asg_spec; 1256 } else { 1257 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i] 1258 : NULL; 1259 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i] 1260 : NULL; 1261 } 1262 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]); 1263 if (err != USBD_NORMAL_COMPLETION) { 1264 free_all_mididevs(sc); 1265 return err; 1266 } 1267 } 1268 1269 return USBD_NORMAL_COMPLETION; 1270 } 1271 1272 static usbd_status 1273 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *)) 1274 { 1275 struct umidi_endpoint *ep = jack->endpoint; 1276 struct umidi_softc *sc = ep->sc; 1277 umidi_packet_bufp end; 1278 int err; 1279 1280 KASSERT(mutex_owned(&sc->sc_lock)); 1281 1282 if (jack->opened) 1283 return USBD_IN_USE; 1284 1285 jack->arg = arg; 1286 jack->u.out.intr = intr; 1287 jack->midiman_ppkt = NULL; 1288 end = ep->buffer + ep->buffer_size / sizeof(*ep->buffer); 1289 jack->opened = 1; 1290 ep->num_open++; 1291 /* 1292 * out_solicit maintains an invariant that there will always be 1293 * (num_open - num_scheduled) slots free in the buffer. as we have 1294 * just incremented num_open, the buffer may be too full to satisfy 1295 * the invariant until a transfer completes, for which we must wait. 1296 */ 1297 while (end - ep->next_slot < ep->num_open - ep->num_scheduled) { 1298 err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock, 1299 mstohz(10)); 1300 if (err) { 1301 ep->num_open--; 1302 jack->opened = 0; 1303 return USBD_IOERROR; 1304 } 1305 } 1306 1307 return USBD_NORMAL_COMPLETION; 1308 } 1309 1310 static usbd_status 1311 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int)) 1312 { 1313 usbd_status err = USBD_NORMAL_COMPLETION; 1314 struct umidi_endpoint *ep = jack->endpoint; 1315 1316 KASSERT(mutex_owned(&ep->sc->sc_lock)); 1317 1318 if (jack->opened) 1319 return USBD_IN_USE; 1320 1321 jack->arg = arg; 1322 jack->u.in.intr = intr; 1323 jack->opened = 1; 1324 if (ep->num_open++ == 0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) { 1325 /* 1326 * Can't hold the interrupt lock while calling into USB, 1327 * but we can safely drop it here. 1328 */ 1329 mutex_exit(&ep->sc->sc_lock); 1330 err = start_input_transfer(ep); 1331 if (err != USBD_NORMAL_COMPLETION && 1332 err != USBD_IN_PROGRESS) { 1333 ep->num_open--; 1334 } 1335 mutex_enter(&ep->sc->sc_lock); 1336 } 1337 1338 return err; 1339 } 1340 1341 static void 1342 close_out_jack(struct umidi_jack *jack) 1343 { 1344 struct umidi_endpoint *ep; 1345 struct umidi_softc *sc; 1346 uint16_t mask; 1347 int err; 1348 1349 if (jack->opened) { 1350 ep = jack->endpoint; 1351 sc = ep->sc; 1352 1353 KASSERT(mutex_owned(&sc->sc_lock)); 1354 mask = 1 << (jack->cable_number); 1355 while (mask & (ep->this_schedule | ep->next_schedule)) { 1356 err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock, 1357 mstohz(10)); 1358 if (err) 1359 break; 1360 } 1361 /* 1362 * We can re-enter this function from both close() and 1363 * detach(). Make sure only one of them does this part. 1364 */ 1365 if (jack->opened) { 1366 jack->opened = 0; 1367 jack->endpoint->num_open--; 1368 ep->this_schedule &= ~mask; 1369 ep->next_schedule &= ~mask; 1370 } 1371 } 1372 } 1373 1374 static void 1375 close_in_jack(struct umidi_jack *jack) 1376 { 1377 if (jack->opened) { 1378 struct umidi_softc *sc = jack->endpoint->sc; 1379 1380 KASSERT(mutex_owned(&sc->sc_lock)); 1381 1382 jack->opened = 0; 1383 if (--jack->endpoint->num_open == 0) { 1384 /* 1385 * We have to drop the (interrupt) lock so that 1386 * the USB thread lock can be safely taken by 1387 * the abort operation. This is safe as this 1388 * either closing or dying will be set proerly. 1389 */ 1390 mutex_exit(&sc->sc_lock); 1391 usbd_abort_pipe(jack->endpoint->pipe); 1392 mutex_enter(&sc->sc_lock); 1393 } 1394 } 1395 } 1396 1397 static usbd_status 1398 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev) 1399 { 1400 if (mididev->sc) 1401 return USBD_IN_USE; 1402 1403 mididev->sc = sc; 1404 1405 describe_mididev(mididev); 1406 1407 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, sc->sc_dev); 1408 1409 return USBD_NORMAL_COMPLETION; 1410 } 1411 1412 static usbd_status 1413 detach_mididev(struct umidi_mididev *mididev, int flags) 1414 { 1415 struct umidi_softc *sc = mididev->sc; 1416 1417 if (!sc) 1418 return USBD_NO_ADDR; 1419 1420 mutex_enter(&sc->sc_lock); 1421 if (mididev->opened) { 1422 umidi_close(mididev); 1423 } 1424 unbind_jacks_from_mididev(mididev); 1425 mutex_exit(&sc->sc_lock); 1426 1427 if (mididev->mdev != NULL) 1428 config_detach(mididev->mdev, flags); 1429 1430 if (NULL != mididev->label) { 1431 kmem_free(mididev->label, mididev->label_len); 1432 mididev->label = NULL; 1433 } 1434 1435 mididev->sc = NULL; 1436 1437 return USBD_NORMAL_COMPLETION; 1438 } 1439 1440 static void 1441 deactivate_mididev(struct umidi_mididev *mididev) 1442 { 1443 if (mididev->out_jack) 1444 mididev->out_jack->bound = 0; 1445 if (mididev->in_jack) 1446 mididev->in_jack->bound = 0; 1447 } 1448 1449 static usbd_status 1450 alloc_all_mididevs(struct umidi_softc *sc, int nmidi) 1451 { 1452 sc->sc_num_mididevs = nmidi; 1453 sc->sc_mididevs = kmem_zalloc(sizeof(*sc->sc_mididevs)*nmidi, KM_SLEEP); 1454 if (!sc->sc_mididevs) 1455 return USBD_NOMEM; 1456 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"s ep=%p cn=%d len=%d cin=%#x\n", 1741 umidi_tv.tv_sec%100, (uint64_t)umidi_tv.tv_usec, 1742 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 usb_detach_broadcast(sc->sc_dev, &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 length %u\n", 1894 device_xname(ep->sc->sc_dev), 1895 umidi_tv.tv_sec%100, (uint64_t)umidi_tv.tv_usec, ep, count)); 1896 } else { 1897 DPRINTF(("%s: output endpoint %p odd transfer length %u\n", 1898 device_xname(ep->sc->sc_dev), ep, count)); 1899 } 1900 count /= UMIDI_PACKET_SIZE; 1901 1902 /* 1903 * If while the transfer was pending we buffered any new messages, 1904 * move them to the start of the buffer. 1905 */ 1906 ep->next_slot -= count; 1907 if (ep->buffer < ep->next_slot) { 1908 memcpy(ep->buffer, ep->buffer + count, 1909 (char *)ep->next_slot - (char *)ep->buffer); 1910 } 1911 cv_broadcast(&sc->sc_cv); 1912 /* 1913 * Do not want anyone else to see armed <- 0 before soliciting <- 1. 1914 * Running at IPL_USB so the following should happen to be safe. 1915 */ 1916 ep->armed = 0; 1917 if (!ep->soliciting) { 1918 ep->soliciting = 1; 1919 out_solicit_locked(ep); 1920 } 1921 mutex_exit(&sc->sc_lock); 1922 } 1923 1924 /* 1925 * A jack on which we have received a packet must be called back on its 1926 * out.intr handler before it will send us another; it is considered 1927 * 'scheduled'. It is nice and predictable - as long as it is scheduled, 1928 * we need no extra buffer space for it. 1929 * 1930 * In contrast, a jack that is open but not scheduled may supply us a packet 1931 * at any time, driven by the top half, and we must be able to accept it, no 1932 * excuses. So we must ensure that at any point in time there are at least 1933 * (num_open - num_scheduled) slots free. 1934 * 1935 * As long as there are more slots free than that minimum, we can loop calling 1936 * scheduled jacks back on their "interrupt" handlers, soliciting more 1937 * packets, starting the USB transfer only when the buffer space is down to 1938 * the minimum or no jack has any more to send. 1939 */ 1940 1941 static void 1942 out_solicit_locked(void *arg) 1943 { 1944 struct umidi_endpoint *ep = arg; 1945 umidi_packet_bufp end; 1946 uint16_t which; 1947 struct umidi_jack *jack; 1948 1949 KASSERT(mutex_owned(&ep->sc->sc_lock)); 1950 1951 end = ep->buffer + ep->buffer_size / sizeof(*ep->buffer); 1952 1953 for ( ;; ) { 1954 if (end - ep->next_slot <= ep->num_open - ep->num_scheduled) 1955 break; /* at IPL_USB */ 1956 if (ep->this_schedule == 0) { 1957 if (ep->next_schedule == 0) 1958 break; /* at IPL_USB */ 1959 ep->this_schedule = ep->next_schedule; 1960 ep->next_schedule = 0; 1961 } 1962 /* 1963 * At least one jack is scheduled. Find and mask off the least 1964 * set bit in this_schedule and decrement num_scheduled. 1965 * Convert mask to bit index to find the corresponding jack, 1966 * and call its intr handler. If it has a message, it will call 1967 * back one of the output methods, which will set its bit in 1968 * next_schedule (not copied into this_schedule until the 1969 * latter is empty). In this way we round-robin the jacks that 1970 * have messages to send, until the buffer is as full as we 1971 * dare, and then start a transfer. 1972 */ 1973 which = ep->this_schedule; 1974 which &= (~which)+1; /* now mask of least set bit */ 1975 ep->this_schedule &= ~which; 1976 --ep->num_scheduled; 1977 1978 --which; /* now 1s below mask - count 1s to get index */ 1979 which -= ((which >> 1) & 0x5555);/* SWAR credit aggregate.org */ 1980 which = (((which >> 2) & 0x3333) + (which & 0x3333)); 1981 which = (((which >> 4) + which) & 0x0f0f); 1982 which += (which >> 8); 1983 which &= 0x1f; /* the bit index a/k/a jack number */ 1984 1985 jack = ep->jacks[which]; 1986 if (jack->u.out.intr) 1987 (*jack->u.out.intr)(jack->arg); 1988 } 1989 /* intr lock held at loop exit */ 1990 if (!ep->armed && ep->next_slot > ep->buffer) { 1991 /* 1992 * Can't hold the interrupt lock while calling into USB, 1993 * but we can safely drop it here. 1994 */ 1995 mutex_exit(&ep->sc->sc_lock); 1996 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep)); 1997 mutex_enter(&ep->sc->sc_lock); 1998 } 1999 ep->soliciting = 0; 2000 } 2001 2002 /* Entry point for the softintr. */ 2003 static void 2004 out_solicit(void *arg) 2005 { 2006 struct umidi_endpoint *ep = arg; 2007 struct umidi_softc *sc = ep->sc; 2008 2009 mutex_enter(&sc->sc_lock); 2010 out_solicit_locked(arg); 2011 mutex_exit(&sc->sc_lock); 2012 } 2013