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