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