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