1 /* $NetBSD: umidi.c,v 1.91 2024/02/10 09:21:53 andvar 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 (at) NetBSD.org), (full-size transfers, extended 9 * hw_if) Chapman Flack (chap (at) NetBSD.org), and Matthew R. Green 10 * (mrg (at) eterna23.net). 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.91 2024/02/10 09:21:53 andvar 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 * hierarchy 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 int i, n; 728 729 if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) { 730 err = alloc_all_endpoints_fixed_ep(sc); 731 } else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) { 732 err = alloc_all_endpoints_yamaha(sc); 733 } else { 734 err = alloc_all_endpoints_genuine(sc); 735 } 736 if (err != USBD_NORMAL_COMPLETION) 737 return err; 738 739 n = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints; 740 for (i = 0; i < n; i++) { 741 err = alloc_pipe(&sc->sc_endpoints[i]); 742 if (err != USBD_NORMAL_COMPLETION) { 743 while (i --> 0) 744 free_pipe(&sc->sc_endpoints[i]); 745 kmem_free(sc->sc_endpoints, sc->sc_endpoints_len); 746 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 747 break; 748 } 749 } 750 return err; 751 } 752 753 static void 754 free_all_endpoints(struct umidi_softc *sc) 755 { 756 int i, n; 757 758 if (sc->sc_endpoints == NULL) { 759 /* nothing to free */ 760 return; 761 } 762 763 n = sc->sc_in_num_endpoints + sc->sc_out_num_endpoints; 764 for (i = 0; i < n; i++) 765 free_pipe(&sc->sc_endpoints[i]); 766 kmem_free(sc->sc_endpoints, sc->sc_endpoints_len); 767 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 768 } 769 770 static usbd_status 771 alloc_all_endpoints_fixed_ep(struct umidi_softc *sc) 772 { 773 usbd_status err; 774 const struct umq_fixed_ep_desc *fp; 775 struct umidi_endpoint *ep; 776 usb_endpoint_descriptor_t *epd; 777 int i; 778 779 fp = umidi_get_quirk_data_from_type(sc->sc_quirk, 780 UMQ_TYPE_FIXED_EP); 781 if (fp->num_in_ep == 0 && fp->num_out_ep == 0) 782 return USBD_INVAL; 783 sc->sc_out_num_jacks = 0; 784 sc->sc_in_num_jacks = 0; 785 sc->sc_out_num_endpoints = fp->num_out_ep; 786 sc->sc_in_num_endpoints = fp->num_in_ep; 787 sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc); 788 sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP); 789 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 790 sc->sc_in_ep = 791 sc->sc_in_num_endpoints ? 792 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 793 794 ep = &sc->sc_out_ep[0]; 795 for (i = 0; i < sc->sc_out_num_endpoints; i++) { 796 epd = usbd_interface2endpoint_descriptor( 797 sc->sc_iface, 798 fp->out_ep[i].ep); 799 if (!epd) { 800 aprint_error_dev(sc->sc_dev, 801 "cannot get endpoint descriptor(out:%d)\n", 802 fp->out_ep[i].ep); 803 err = USBD_INVAL; 804 goto error; 805 } 806 if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK || 807 UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_OUT) { 808 aprint_error_dev(sc->sc_dev, 809 "illegal endpoint(out:%d)\n", fp->out_ep[i].ep); 810 err = USBD_INVAL; 811 goto error; 812 } 813 ep->sc = sc; 814 ep->addr = epd->bEndpointAddress; 815 ep->num_jacks = fp->out_ep[i].num_jacks; 816 sc->sc_out_num_jacks += fp->out_ep[i].num_jacks; 817 ep->num_open = 0; 818 ep++; 819 } 820 ep = &sc->sc_in_ep[0]; 821 for (i = 0; i < sc->sc_in_num_endpoints; i++) { 822 epd = usbd_interface2endpoint_descriptor( 823 sc->sc_iface, 824 fp->in_ep[i].ep); 825 if (!epd) { 826 aprint_error_dev(sc->sc_dev, 827 "cannot get endpoint descriptor(in:%d)\n", 828 fp->in_ep[i].ep); 829 err = USBD_INVAL; 830 goto error; 831 } 832 /* 833 * MIDISPORT_2X4 inputs on an interrupt rather than a bulk 834 * endpoint. The existing input logic in this driver seems 835 * to work successfully if we just stop treating an interrupt 836 * endpoint as illegal (or the in_progress status we get on 837 * the initial transfer). It does not seem necessary to 838 * actually use the interrupt flavor of alloc_pipe or make 839 * other serious rearrangements of logic. I like that. 840 */ 841 switch ( UE_GET_XFERTYPE(epd->bmAttributes) ) { 842 case UE_BULK: 843 case UE_INTERRUPT: 844 if (UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress)) 845 break; 846 /*FALLTHROUGH*/ 847 default: 848 aprint_error_dev(sc->sc_dev, 849 "illegal endpoint(in:%d)\n", fp->in_ep[i].ep); 850 err = USBD_INVAL; 851 goto error; 852 } 853 854 ep->sc = sc; 855 ep->addr = epd->bEndpointAddress; 856 ep->num_jacks = fp->in_ep[i].num_jacks; 857 sc->sc_in_num_jacks += fp->in_ep[i].num_jacks; 858 ep->num_open = 0; 859 ep++; 860 } 861 862 return USBD_NORMAL_COMPLETION; 863 error: 864 kmem_free(sc->sc_endpoints, UMIDI_ENDPOINT_SIZE(sc)); 865 sc->sc_endpoints = NULL; 866 return err; 867 } 868 869 static usbd_status 870 alloc_all_endpoints_yamaha(struct umidi_softc *sc) 871 { 872 /* This driver currently supports max 1in/1out bulk endpoints */ 873 char *end; 874 usb_config_descriptor_t *cdesc; 875 usb_descriptor_t *desc; 876 umidi_cs_descriptor_t *csdesc; 877 usb_interface_descriptor_t *idesc; 878 umidi_cs_interface_descriptor_t *udesc; 879 usb_endpoint_descriptor_t *epd; 880 int out_addr, in_addr, i; 881 int dir; 882 883 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 884 out_addr = in_addr = 0; 885 886 /* detect endpoints */ 887 cdesc = usbd_get_config_descriptor(sc->sc_udev); 888 end = (char *)cdesc + UGETW(cdesc->wTotalLength); 889 idesc = usbd_get_interface_descriptor(sc->sc_iface); 890 KASSERT((char *)cdesc <= (char *)idesc); 891 KASSERT((char *)idesc < end); 892 KASSERT(end - (char *)idesc >= sizeof(*idesc)); 893 KASSERT(idesc->bLength >= sizeof(*idesc)); 894 KASSERT(idesc->bLength <= end - (char *)idesc); 895 for (i = idesc->bNumEndpoints; i --> 0;) { 896 epd = usbd_interface2endpoint_descriptor(sc->sc_iface, i); 897 KASSERT(epd != NULL); 898 if (UE_GET_XFERTYPE(epd->bmAttributes) == UE_BULK) { 899 dir = UE_GET_DIR(epd->bEndpointAddress); 900 if (dir == UE_DIR_OUT && !out_addr) 901 out_addr = epd->bEndpointAddress; 902 else if (dir == UE_DIR_IN && !in_addr) 903 in_addr = epd->bEndpointAddress; 904 } 905 } 906 desc = NEXT_D(idesc); 907 if ((char *)desc > end || end - (char *)desc < sizeof(*desc) || 908 desc->bLength < sizeof(*desc) || 909 desc->bLength > end - (char *)desc) 910 return USBD_INVAL; 911 912 /* count jacks */ 913 if (desc->bDescriptorType != UDESC_CS_INTERFACE || 914 desc->bLength < sizeof(*csdesc)) 915 return USBD_INVAL; 916 csdesc = (umidi_cs_descriptor_t *)desc; 917 if (csdesc->bDescriptorSubtype != UMIDI_MS_HEADER) 918 return USBD_INVAL; 919 udesc = TO_CSIFD(csdesc); 920 if (UGETW(udesc->wTotalLength) > end - (char *)udesc) 921 return USBD_INVAL; 922 if (UGETW(udesc->wTotalLength) < udesc->bLength) 923 return USBD_INVAL; 924 end = (char *)udesc + UGETW(udesc->wTotalLength); 925 desc = NEXT_D(udesc); 926 927 for (; end - (char *)desc >= sizeof(*desc); desc = NEXT_D(desc)) { 928 if (desc->bLength < sizeof(*desc) || 929 desc->bLength > end - (char *)desc) 930 break; 931 if (desc->bDescriptorType != UDESC_CS_INTERFACE || 932 desc->bLength < sizeof(*csdesc) || 933 desc->bLength < UMIDI_JACK_DESCRIPTOR_SIZE) 934 continue; 935 csdesc = (umidi_cs_descriptor_t *)desc; 936 if (csdesc->bDescriptorSubtype == UMIDI_OUT_JACK) 937 sc->sc_out_num_jacks++; 938 else if (csdesc->bDescriptorSubtype == UMIDI_IN_JACK) 939 sc->sc_in_num_jacks++; 940 } 941 942 /* validate some parameters */ 943 if (sc->sc_out_num_jacks > UMIDI_MAX_EPJACKS) 944 sc->sc_out_num_jacks = UMIDI_MAX_EPJACKS; 945 if (sc->sc_in_num_jacks > UMIDI_MAX_EPJACKS) 946 sc->sc_in_num_jacks = UMIDI_MAX_EPJACKS; 947 if (sc->sc_out_num_jacks && out_addr) { 948 sc->sc_out_num_endpoints = 1; 949 } else { 950 sc->sc_out_num_endpoints = 0; 951 sc->sc_out_num_jacks = 0; 952 } 953 if (sc->sc_in_num_jacks && in_addr) { 954 sc->sc_in_num_endpoints = 1; 955 } else { 956 sc->sc_in_num_endpoints = 0; 957 sc->sc_in_num_jacks = 0; 958 } 959 sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc); 960 if (sc->sc_endpoints_len == 0) 961 return USBD_INVAL; 962 sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP); 963 if (sc->sc_out_num_endpoints) { 964 sc->sc_out_ep = sc->sc_endpoints; 965 sc->sc_out_ep->sc = sc; 966 sc->sc_out_ep->addr = out_addr; 967 sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks; 968 sc->sc_out_ep->num_open = 0; 969 } else 970 sc->sc_out_ep = NULL; 971 972 if (sc->sc_in_num_endpoints) { 973 sc->sc_in_ep = sc->sc_endpoints + sc->sc_out_num_endpoints; 974 sc->sc_in_ep->sc = sc; 975 sc->sc_in_ep->addr = in_addr; 976 sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks; 977 sc->sc_in_ep->num_open = 0; 978 } else 979 sc->sc_in_ep = NULL; 980 981 return USBD_NORMAL_COMPLETION; 982 } 983 984 static usbd_status 985 alloc_all_endpoints_genuine(struct umidi_softc *sc) 986 { 987 usb_interface_descriptor_t *interface_desc; 988 usb_config_descriptor_t *config_desc; 989 usb_descriptor_t *desc; 990 char *end; 991 int num_ep; 992 struct umidi_endpoint *p, *q, *lowest, *endep, tmpep; 993 int epaddr; 994 995 interface_desc = usbd_get_interface_descriptor(sc->sc_iface); 996 num_ep = interface_desc->bNumEndpoints; 997 if (num_ep == 0) 998 return USBD_INVAL; 999 sc->sc_endpoints_len = sizeof(struct umidi_endpoint) * num_ep; 1000 sc->sc_endpoints = p = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP); 1001 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 1002 sc->sc_out_num_endpoints = sc->sc_in_num_endpoints = 0; 1003 epaddr = -1; 1004 1005 /* get the list of endpoints for midi stream */ 1006 config_desc = usbd_get_config_descriptor(sc->sc_udev); 1007 end = (char *)config_desc + UGETW(config_desc->wTotalLength); 1008 desc = TO_D(config_desc); 1009 for (; end - (char *)desc >= sizeof(*desc); desc = NEXT_D(desc)) { 1010 if (desc->bLength < sizeof(*desc) || 1011 desc->bLength > end - (char *)desc) 1012 break; 1013 if (desc->bDescriptorType == UDESC_ENDPOINT && 1014 desc->bLength >= sizeof(*TO_EPD(desc)) && 1015 UE_GET_XFERTYPE(TO_EPD(desc)->bmAttributes) == UE_BULK) { 1016 epaddr = TO_EPD(desc)->bEndpointAddress; 1017 } else if (desc->bDescriptorType == UDESC_CS_ENDPOINT && 1018 desc->bLength >= sizeof(*TO_CSEPD(desc)) && 1019 epaddr != -1) { 1020 if (num_ep > 0) { 1021 num_ep--; 1022 p->sc = sc; 1023 p->addr = epaddr; 1024 p->num_jacks = TO_CSEPD(desc)->bNumEmbMIDIJack; 1025 if (UE_GET_DIR(epaddr) == UE_DIR_OUT) { 1026 sc->sc_out_num_endpoints++; 1027 sc->sc_out_num_jacks += p->num_jacks; 1028 } else { 1029 sc->sc_in_num_endpoints++; 1030 sc->sc_in_num_jacks += p->num_jacks; 1031 } 1032 p++; 1033 } 1034 } else 1035 epaddr = -1; 1036 } 1037 1038 /* sort endpoints */ 1039 num_ep = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints; 1040 p = sc->sc_endpoints; 1041 endep = p + num_ep; 1042 while (p<endep) { 1043 lowest = p; 1044 for (q=p+1; q<endep; q++) { 1045 if ((UE_GET_DIR(lowest->addr)==UE_DIR_IN && 1046 UE_GET_DIR(q->addr)==UE_DIR_OUT) || 1047 ((UE_GET_DIR(lowest->addr)== 1048 UE_GET_DIR(q->addr)) && 1049 (UE_GET_ADDR(lowest->addr)> 1050 UE_GET_ADDR(q->addr)))) 1051 lowest = q; 1052 } 1053 if (lowest != p) { 1054 memcpy((void *)&tmpep, (void *)p, sizeof(tmpep)); 1055 memcpy((void *)p, (void *)lowest, sizeof(tmpep)); 1056 memcpy((void *)lowest, (void *)&tmpep, sizeof(tmpep)); 1057 } 1058 p->num_open = 0; 1059 p++; 1060 } 1061 1062 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 1063 sc->sc_in_ep = 1064 sc->sc_in_num_endpoints ? 1065 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 1066 1067 return USBD_NORMAL_COMPLETION; 1068 } 1069 1070 1071 /* 1072 * jack stuffs 1073 */ 1074 1075 static usbd_status 1076 alloc_all_jacks(struct umidi_softc *sc) 1077 { 1078 int i, j; 1079 struct umidi_endpoint *ep; 1080 struct umidi_jack *jack; 1081 const unsigned char *cn_spec; 1082 1083 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_PER_EP)) 1084 sc->cblnums_global = 0; 1085 else if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_GLOBAL)) 1086 sc->cblnums_global = 1; 1087 else { 1088 /* 1089 * I don't think this default is correct, but it preserves 1090 * the prior behavior of the code. That's why I defined two 1091 * complementary quirks. Any device for which the default 1092 * behavior is wrong can be made to work by giving it an 1093 * explicit quirk, and if a pattern ever develops (as I suspect 1094 * it will) that a lot of otherwise standard USB MIDI devices 1095 * need the CN_SEQ_PER_EP "quirk," then this default can be 1096 * changed to 0, and the only devices that will break are those 1097 * listing neither quirk, and they'll easily be fixed by giving 1098 * them the CN_SEQ_GLOBAL quirk. 1099 */ 1100 sc->cblnums_global = 1; 1101 } 1102 1103 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_FIXED)) 1104 cn_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 1105 UMQ_TYPE_CN_FIXED); 1106 else 1107 cn_spec = NULL; 1108 1109 /* allocate/initialize structures */ 1110 if (sc->sc_in_num_jacks == 0 && sc->sc_out_num_jacks == 0) 1111 return USBD_INVAL; 1112 sc->sc_jacks = kmem_zalloc(sizeof(*sc->sc_out_jacks) * 1113 (sc->sc_in_num_jacks + sc->sc_out_num_jacks), KM_SLEEP); 1114 if (!sc->sc_jacks) 1115 return USBD_NOMEM; 1116 sc->sc_out_jacks = 1117 sc->sc_out_num_jacks ? sc->sc_jacks : NULL; 1118 sc->sc_in_jacks = 1119 sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL; 1120 1121 jack = &sc->sc_out_jacks[0]; 1122 for (i = 0; i < sc->sc_out_num_jacks; i++) { 1123 jack->opened = 0; 1124 jack->bound = 0; 1125 jack->arg = NULL; 1126 jack->u.out.intr = NULL; 1127 jack->midiman_ppkt = NULL; 1128 if (sc->cblnums_global) 1129 jack->cable_number = i; 1130 jack++; 1131 } 1132 jack = &sc->sc_in_jacks[0]; 1133 for (i = 0; i < sc->sc_in_num_jacks; i++) { 1134 jack->opened = 0; 1135 jack->bound = 0; 1136 jack->arg = NULL; 1137 jack->u.in.intr = NULL; 1138 if (sc->cblnums_global) 1139 jack->cable_number = i; 1140 jack++; 1141 } 1142 1143 /* assign each jacks to each endpoints */ 1144 jack = &sc->sc_out_jacks[0]; 1145 ep = &sc->sc_out_ep[0]; 1146 for (i = 0; i < sc->sc_out_num_endpoints; i++) { 1147 for (j = 0; j < ep->num_jacks; j++) { 1148 jack->endpoint = ep; 1149 if (cn_spec != NULL) 1150 jack->cable_number = *cn_spec++; 1151 else if (!sc->cblnums_global) 1152 jack->cable_number = j; 1153 ep->jacks[jack->cable_number] = jack; 1154 jack++; 1155 } 1156 ep++; 1157 } 1158 jack = &sc->sc_in_jacks[0]; 1159 ep = &sc->sc_in_ep[0]; 1160 for (i = 0; i < sc->sc_in_num_endpoints; i++) { 1161 for (j = 0; j < ep->num_jacks; j++) { 1162 jack->endpoint = ep; 1163 if (cn_spec != NULL) 1164 jack->cable_number = *cn_spec++; 1165 else if (!sc->cblnums_global) 1166 jack->cable_number = j; 1167 ep->jacks[jack->cable_number] = jack; 1168 jack++; 1169 } 1170 ep++; 1171 } 1172 1173 return USBD_NORMAL_COMPLETION; 1174 } 1175 1176 static void 1177 free_all_jacks(struct umidi_softc *sc) 1178 { 1179 struct umidi_jack *jacks; 1180 size_t len; 1181 1182 mutex_enter(&sc->sc_lock); 1183 jacks = sc->sc_jacks; 1184 len = sizeof(*sc->sc_out_jacks) * 1185 (sc->sc_in_num_jacks + sc->sc_out_num_jacks); 1186 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL; 1187 mutex_exit(&sc->sc_lock); 1188 1189 if (jacks) 1190 kmem_free(jacks, len); 1191 } 1192 1193 static usbd_status 1194 bind_jacks_to_mididev(struct umidi_softc *sc, 1195 struct umidi_jack *out_jack, 1196 struct umidi_jack *in_jack, 1197 struct umidi_mididev *mididev) 1198 { 1199 if ((out_jack && out_jack->bound) || (in_jack && in_jack->bound)) 1200 return USBD_IN_USE; 1201 if (mididev->out_jack || mididev->in_jack) 1202 return USBD_IN_USE; 1203 1204 if (out_jack) 1205 out_jack->bound = 1; 1206 if (in_jack) 1207 in_jack->bound = 1; 1208 mididev->in_jack = in_jack; 1209 mididev->out_jack = out_jack; 1210 1211 mididev->closing = 0; 1212 1213 return USBD_NORMAL_COMPLETION; 1214 } 1215 1216 static void 1217 unbind_jacks_from_mididev(struct umidi_mididev *mididev) 1218 { 1219 KASSERT(mutex_owned(&mididev->sc->sc_lock)); 1220 1221 mididev->closing = 1; 1222 1223 if ((mididev->flags & FWRITE) && mididev->out_jack) 1224 close_out_jack(mididev->out_jack); 1225 if ((mididev->flags & FREAD) && mididev->in_jack) 1226 close_in_jack(mididev->in_jack); 1227 1228 if (mididev->out_jack) { 1229 mididev->out_jack->bound = 0; 1230 mididev->out_jack = NULL; 1231 } 1232 if (mididev->in_jack) { 1233 mididev->in_jack->bound = 0; 1234 mididev->in_jack = NULL; 1235 } 1236 } 1237 1238 static void 1239 unbind_all_jacks(struct umidi_softc *sc) 1240 { 1241 int i; 1242 1243 mutex_enter(&sc->sc_lock); 1244 if (sc->sc_mididevs) 1245 for (i = 0; i < sc->sc_num_mididevs; i++) 1246 unbind_jacks_from_mididev(&sc->sc_mididevs[i]); 1247 mutex_exit(&sc->sc_lock); 1248 } 1249 1250 static usbd_status 1251 assign_all_jacks_automatically(struct umidi_softc *sc) 1252 { 1253 usbd_status err; 1254 int i; 1255 struct umidi_jack *out, *in; 1256 const signed char *asg_spec; 1257 1258 err = 1259 alloc_all_mididevs(sc, 1260 uimax(sc->sc_out_num_jacks, sc->sc_in_num_jacks)); 1261 if (err!=USBD_NORMAL_COMPLETION) 1262 return err; 1263 1264 if (UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED)) 1265 asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 1266 UMQ_TYPE_MD_FIXED); 1267 else 1268 asg_spec = NULL; 1269 1270 for (i = 0; i < sc->sc_num_mididevs; i++) { 1271 if (asg_spec != NULL) { 1272 if (*asg_spec == -1) 1273 out = NULL; 1274 else 1275 out = &sc->sc_out_jacks[*asg_spec]; 1276 ++ asg_spec; 1277 if (*asg_spec == -1) 1278 in = NULL; 1279 else 1280 in = &sc->sc_in_jacks[*asg_spec]; 1281 ++ asg_spec; 1282 } else { 1283 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i] 1284 : NULL; 1285 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i] 1286 : NULL; 1287 } 1288 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]); 1289 if (err != USBD_NORMAL_COMPLETION) { 1290 free_all_mididevs(sc); 1291 return err; 1292 } 1293 } 1294 1295 return USBD_NORMAL_COMPLETION; 1296 } 1297 1298 static usbd_status 1299 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *)) 1300 { 1301 struct umidi_endpoint *ep = jack->endpoint; 1302 struct umidi_softc *sc = ep->sc; 1303 umidi_packet_bufp end; 1304 int err; 1305 1306 KASSERT(mutex_owned(&sc->sc_lock)); 1307 1308 if (jack->opened) 1309 return USBD_IN_USE; 1310 1311 jack->arg = arg; 1312 jack->u.out.intr = intr; 1313 jack->midiman_ppkt = NULL; 1314 end = ep->buffer + ep->buffer_size / sizeof(*ep->buffer); 1315 jack->opened = 1; 1316 ep->num_open++; 1317 /* 1318 * out_solicit maintains an invariant that there will always be 1319 * (num_open - num_scheduled) slots free in the buffer. as we have 1320 * just incremented num_open, the buffer may be too full to satisfy 1321 * the invariant until a transfer completes, for which we must wait. 1322 */ 1323 while (end - ep->next_slot < ep->num_open - ep->num_scheduled) { 1324 err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock, 1325 mstohz(10)); 1326 if (err) { 1327 ep->num_open--; 1328 jack->opened = 0; 1329 return USBD_IOERROR; 1330 } 1331 } 1332 1333 return USBD_NORMAL_COMPLETION; 1334 } 1335 1336 static usbd_status 1337 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int)) 1338 { 1339 usbd_status err = USBD_NORMAL_COMPLETION; 1340 struct umidi_endpoint *ep = jack->endpoint; 1341 1342 KASSERT(mutex_owned(&ep->sc->sc_lock)); 1343 1344 if (jack->opened) 1345 return USBD_IN_USE; 1346 1347 jack->arg = arg; 1348 jack->u.in.intr = intr; 1349 jack->opened = 1; 1350 if (ep->num_open++ == 0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) { 1351 /* 1352 * Can't hold the interrupt lock while calling into USB, 1353 * but we can safely drop it here. 1354 */ 1355 mutex_exit(&ep->sc->sc_lock); 1356 err = start_input_transfer(ep); 1357 if (err != USBD_NORMAL_COMPLETION && 1358 err != USBD_IN_PROGRESS) { 1359 ep->num_open--; 1360 } 1361 mutex_enter(&ep->sc->sc_lock); 1362 } 1363 1364 return err; 1365 } 1366 1367 static void 1368 close_out_jack(struct umidi_jack *jack) 1369 { 1370 struct umidi_endpoint *ep; 1371 struct umidi_softc *sc; 1372 uint16_t mask; 1373 int err; 1374 1375 if (jack->opened) { 1376 ep = jack->endpoint; 1377 sc = ep->sc; 1378 1379 KASSERT(mutex_owned(&sc->sc_lock)); 1380 mask = 1 << (jack->cable_number); 1381 while (mask & (ep->this_schedule | ep->next_schedule)) { 1382 err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock, 1383 mstohz(10)); 1384 if (err) 1385 break; 1386 } 1387 /* 1388 * We can re-enter this function from both close() and 1389 * detach(). Make sure only one of them does this part. 1390 */ 1391 if (jack->opened) { 1392 jack->opened = 0; 1393 jack->endpoint->num_open--; 1394 ep->this_schedule &= ~mask; 1395 ep->next_schedule &= ~mask; 1396 } 1397 } 1398 } 1399 1400 static void 1401 close_in_jack(struct umidi_jack *jack) 1402 { 1403 if (jack->opened) { 1404 struct umidi_softc *sc = jack->endpoint->sc; 1405 1406 KASSERT(mutex_owned(&sc->sc_lock)); 1407 1408 jack->opened = 0; 1409 if (--jack->endpoint->num_open == 0) { 1410 /* 1411 * We have to drop the (interrupt) lock so that 1412 * the USB thread lock can be safely taken by 1413 * the abort operation. This is safe as this 1414 * either closing or dying will be set properly. 1415 */ 1416 mutex_exit(&sc->sc_lock); 1417 usbd_abort_pipe(jack->endpoint->pipe); 1418 mutex_enter(&sc->sc_lock); 1419 } 1420 } 1421 } 1422 1423 static usbd_status 1424 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev) 1425 { 1426 if (mididev->sc) 1427 return USBD_IN_USE; 1428 1429 mididev->sc = sc; 1430 1431 describe_mididev(mididev); 1432 1433 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, sc->sc_dev); 1434 1435 return USBD_NORMAL_COMPLETION; 1436 } 1437 1438 static usbd_status 1439 detach_mididev(struct umidi_mididev *mididev, int flags) 1440 { 1441 struct umidi_softc *sc = mididev->sc; 1442 1443 if (!sc) 1444 return USBD_NO_ADDR; 1445 1446 mutex_enter(&sc->sc_lock); 1447 if (mididev->opened) { 1448 umidi_close(mididev); 1449 } 1450 unbind_jacks_from_mididev(mididev); 1451 mutex_exit(&sc->sc_lock); 1452 1453 if (mididev->mdev != NULL) 1454 config_detach(mididev->mdev, flags); 1455 1456 if (NULL != mididev->label) { 1457 kmem_free(mididev->label, mididev->label_len); 1458 mididev->label = NULL; 1459 } 1460 1461 mididev->sc = NULL; 1462 1463 return USBD_NORMAL_COMPLETION; 1464 } 1465 1466 static void 1467 deactivate_mididev(struct umidi_mididev *mididev) 1468 { 1469 if (mididev->out_jack) 1470 mididev->out_jack->bound = 0; 1471 if (mididev->in_jack) 1472 mididev->in_jack->bound = 0; 1473 } 1474 1475 static usbd_status 1476 alloc_all_mididevs(struct umidi_softc *sc, int nmidi) 1477 { 1478 sc->sc_num_mididevs = nmidi; 1479 sc->sc_mididevs = kmem_zalloc(sizeof(*sc->sc_mididevs)*nmidi, KM_SLEEP); 1480 return USBD_NORMAL_COMPLETION; 1481 } 1482 1483 static void 1484 free_all_mididevs(struct umidi_softc *sc) 1485 { 1486 struct umidi_mididev *mididevs; 1487 size_t len; 1488 1489 mutex_enter(&sc->sc_lock); 1490 mididevs = sc->sc_mididevs; 1491 if (mididevs) 1492 len = sizeof(*sc->sc_mididevs )* sc->sc_num_mididevs; 1493 sc->sc_mididevs = NULL; 1494 sc->sc_num_mididevs = 0; 1495 mutex_exit(&sc->sc_lock); 1496 1497 if (mididevs) 1498 kmem_free(mididevs, len); 1499 } 1500 1501 static usbd_status 1502 attach_all_mididevs(struct umidi_softc *sc) 1503 { 1504 usbd_status err; 1505 int i; 1506 1507 if (sc->sc_mididevs) 1508 for (i = 0; i < sc->sc_num_mididevs; i++) { 1509 err = attach_mididev(sc, &sc->sc_mididevs[i]); 1510 if (err != USBD_NORMAL_COMPLETION) 1511 return err; 1512 } 1513 1514 return USBD_NORMAL_COMPLETION; 1515 } 1516 1517 static usbd_status 1518 detach_all_mididevs(struct umidi_softc *sc, int flags) 1519 { 1520 usbd_status err; 1521 int i; 1522 1523 if (sc->sc_mididevs) 1524 for (i = 0; i < sc->sc_num_mididevs; i++) { 1525 err = detach_mididev(&sc->sc_mididevs[i], flags); 1526 if (err != USBD_NORMAL_COMPLETION) 1527 return err; 1528 } 1529 1530 return USBD_NORMAL_COMPLETION; 1531 } 1532 1533 static void 1534 deactivate_all_mididevs(struct umidi_softc *sc) 1535 { 1536 int i; 1537 1538 if (sc->sc_mididevs) { 1539 for (i = 0; i < sc->sc_num_mididevs; i++) 1540 deactivate_mididev(&sc->sc_mididevs[i]); 1541 } 1542 } 1543 1544 /* 1545 * TODO: the 0-based cable numbers will often not match the labeling of the 1546 * equipment. Ideally: 1547 * For class-compliant devices: get the iJack string from the jack descriptor. 1548 * Otherwise: 1549 * - support a DISPLAY_BASE_CN quirk (add the value to each internal cable 1550 * number for display) 1551 * - support an array quirk explicitly giving a char * for each jack. 1552 * For now, you get 0-based cable numbers. If there are multiple endpoints and 1553 * the CNs are not globally unique, each is shown with its associated endpoint 1554 * address in hex also. That should not be necessary when using iJack values 1555 * or a quirk array. 1556 */ 1557 void 1558 describe_mididev(struct umidi_mididev *md) 1559 { 1560 char in_label[16]; 1561 char out_label[16]; 1562 const char *unit_label; 1563 char *final_label; 1564 struct umidi_softc *sc; 1565 int show_ep_in; 1566 int show_ep_out; 1567 size_t len; 1568 1569 sc = md->sc; 1570 show_ep_in = sc-> sc_in_num_endpoints > 1 && !sc->cblnums_global; 1571 show_ep_out = sc->sc_out_num_endpoints > 1 && !sc->cblnums_global; 1572 1573 if (NULL == md->in_jack) 1574 in_label[0] = '\0'; 1575 else if (show_ep_in) 1576 snprintf(in_label, sizeof(in_label), "<%d(%x) ", 1577 md->in_jack->cable_number, md->in_jack->endpoint->addr); 1578 else 1579 snprintf(in_label, sizeof(in_label), "<%d ", 1580 md->in_jack->cable_number); 1581 1582 if (NULL == md->out_jack) 1583 out_label[0] = '\0'; 1584 else if (show_ep_out) 1585 snprintf(out_label, sizeof(out_label), ">%d(%x) ", 1586 md->out_jack->cable_number, md->out_jack->endpoint->addr); 1587 else 1588 snprintf(out_label, sizeof(out_label), ">%d ", 1589 md->out_jack->cable_number); 1590 1591 unit_label = device_xname(sc->sc_dev); 1592 1593 len = strlen(in_label) + strlen(out_label) + strlen(unit_label) + 4; 1594 1595 final_label = kmem_alloc(len, KM_SLEEP); 1596 1597 snprintf(final_label, len, "%s%son %s", 1598 in_label, out_label, unit_label); 1599 1600 md->label = final_label; 1601 md->label_len = len; 1602 } 1603 1604 #ifdef UMIDI_DEBUG 1605 static void 1606 dump_sc(struct umidi_softc *sc) 1607 { 1608 int i; 1609 1610 DPRINTFN(10, ("%s: dump_sc\n", device_xname(sc->sc_dev))); 1611 for (i=0; i<sc->sc_out_num_endpoints; i++) { 1612 DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i])); 1613 dump_ep(&sc->sc_out_ep[i]); 1614 } 1615 for (i=0; i<sc->sc_in_num_endpoints; i++) { 1616 DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i])); 1617 dump_ep(&sc->sc_in_ep[i]); 1618 } 1619 } 1620 1621 static void 1622 dump_ep(struct umidi_endpoint *ep) 1623 { 1624 int i; 1625 for (i=0; i<UMIDI_MAX_EPJACKS; i++) { 1626 if (NULL==ep->jacks[i]) 1627 continue; 1628 DPRINTFN(10, ("\t\tjack[%d]:%p:\n", i, ep->jacks[i])); 1629 dump_jack(ep->jacks[i]); 1630 } 1631 } 1632 static void 1633 dump_jack(struct umidi_jack *jack) 1634 { 1635 DPRINTFN(10, ("\t\t\tep=%p\n", 1636 jack->endpoint)); 1637 } 1638 1639 #endif /* UMIDI_DEBUG */ 1640 1641 1642 1643 /* 1644 * MUX MIDI PACKET 1645 */ 1646 1647 static const int packet_length[16] = { 1648 /*0*/ -1, 1649 /*1*/ -1, 1650 /*2*/ 2, 1651 /*3*/ 3, 1652 /*4*/ 3, 1653 /*5*/ 1, 1654 /*6*/ 2, 1655 /*7*/ 3, 1656 /*8*/ 3, 1657 /*9*/ 3, 1658 /*A*/ 3, 1659 /*B*/ 3, 1660 /*C*/ 2, 1661 /*D*/ 2, 1662 /*E*/ 3, 1663 /*F*/ 1, 1664 }; 1665 1666 #define GET_CN(p) (((unsigned char)(p)>>4)&0x0F) 1667 #define GET_CIN(p) ((unsigned char)(p)&0x0F) 1668 #define MIX_CN_CIN(cn, cin) \ 1669 ((unsigned char)((((unsigned char)(cn)&0x0F)<<4)| \ 1670 ((unsigned char)(cin)&0x0F))) 1671 1672 static usbd_status 1673 start_input_transfer(struct umidi_endpoint *ep) 1674 { 1675 usbd_setup_xfer(ep->xfer, ep, ep->buffer, ep->buffer_size, 1676 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, in_intr); 1677 return usbd_transfer(ep->xfer); 1678 } 1679 1680 static usbd_status 1681 start_output_transfer(struct umidi_endpoint *ep) 1682 { 1683 usbd_status rv; 1684 uint32_t length; 1685 int i; 1686 1687 length = (ep->next_slot - ep->buffer) * sizeof(*ep->buffer); 1688 DPRINTFN(200,("umidi out transfer: start %p end %p length %u\n", 1689 ep->buffer, ep->next_slot, length)); 1690 1691 usbd_setup_xfer(ep->xfer, ep, ep->buffer, length, 0, 1692 USBD_NO_TIMEOUT, out_intr); 1693 rv = usbd_transfer(ep->xfer); 1694 1695 /* 1696 * Once the transfer is scheduled, no more adding to partial 1697 * packets within it. 1698 */ 1699 if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1700 for (i=0; i<UMIDI_MAX_EPJACKS; ++i) 1701 if (NULL != ep->jacks[i]) 1702 ep->jacks[i]->midiman_ppkt = NULL; 1703 } 1704 1705 return rv; 1706 } 1707 1708 #ifdef UMIDI_DEBUG 1709 #define DPR_PACKET(dir, sc, p) \ 1710 if ((unsigned char)(p)[1]!=0xFE) \ 1711 DPRINTFN(500, \ 1712 ("%s: umidi packet(" #dir "): %02X %02X %02X %02X\n", \ 1713 device_xname(sc->sc_dev), \ 1714 (unsigned char)(p)[0], \ 1715 (unsigned char)(p)[1], \ 1716 (unsigned char)(p)[2], \ 1717 (unsigned char)(p)[3])); 1718 #else 1719 #define DPR_PACKET(dir, sc, p) 1720 #endif 1721 1722 /* 1723 * A 4-byte Midiman packet superficially resembles a 4-byte USB MIDI packet 1724 * with the cable number and length in the last byte instead of the first, 1725 * but there the resemblance ends. Where a USB MIDI packet is a semantic 1726 * unit, a Midiman packet is just a wrapper for 1 to 3 bytes of raw MIDI 1727 * with a cable nybble and a length nybble (which, unlike the CIN of a 1728 * real USB MIDI packet, has no semantics at all besides the length). 1729 * A packet received from a Midiman may contain part of a MIDI message, 1730 * more than one MIDI message, or parts of more than one MIDI message. A 1731 * three-byte MIDI message may arrive in three packets of data length 1, and 1732 * running status may be used. Happily, the midi(4) driver above us will put 1733 * it all back together, so the only cost is in USB bandwidth. The device 1734 * has an easier time with what it receives from us: we'll pack messages in 1735 * and across packets, but filling the packets whenever possible and, 1736 * as midi(4) hands us a complete message at a time, we'll never send one 1737 * in a dribble of short packets. 1738 */ 1739 1740 static int 1741 out_jack_output(struct umidi_jack *out_jack, u_char *src, int len, int cin) 1742 { 1743 struct umidi_endpoint *ep = out_jack->endpoint; 1744 struct umidi_softc *sc = ep->sc; 1745 unsigned char *packet; 1746 int plen; 1747 int poff; 1748 1749 KASSERT(mutex_owned(&sc->sc_lock)); 1750 1751 if (sc->sc_dying) 1752 return EIO; 1753 1754 if (!out_jack->opened) 1755 return ENODEV; /* XXX as it was, is this the right errno? */ 1756 1757 sc->sc_refcnt++; 1758 1759 #ifdef UMIDI_DEBUG 1760 if (umididebug >= 100) 1761 microtime(&umidi_tv); 1762 #endif 1763 DPRINTFN(100, ("umidi out: %"PRIu64".%06"PRIu64 1764 "s ep=%p cn=%d len=%d cin=%#x\n", umidi_tv.tv_sec%100, 1765 (uint64_t)umidi_tv.tv_usec, ep, out_jack->cable_number, len, cin)); 1766 1767 packet = *ep->next_slot++; 1768 KASSERT(ep->buffer_size >= 1769 (ep->next_slot - ep->buffer) * sizeof(*ep->buffer)); 1770 memset(packet, 0, UMIDI_PACKET_SIZE); 1771 if (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1772 if (NULL != out_jack->midiman_ppkt) { /* fill out a prev pkt */ 1773 poff = 0x0f & (out_jack->midiman_ppkt[3]); 1774 plen = 3 - poff; 1775 if (plen > len) 1776 plen = len; 1777 memcpy(out_jack->midiman_ppkt+poff, src, plen); 1778 src += plen; 1779 len -= plen; 1780 plen += poff; 1781 out_jack->midiman_ppkt[3] = 1782 MIX_CN_CIN(out_jack->cable_number, plen); 1783 DPR_PACKET(out+, sc, out_jack->midiman_ppkt); 1784 if (3 == plen) 1785 out_jack->midiman_ppkt = NULL; /* no more */ 1786 } 1787 if (0 == len) 1788 ep->next_slot--; /* won't be needed, nevermind */ 1789 else { 1790 memcpy(packet, src, len); 1791 packet[3] = MIX_CN_CIN(out_jack->cable_number, len); 1792 DPR_PACKET(out, sc, packet); 1793 if (len < 3) 1794 out_jack->midiman_ppkt = packet; 1795 } 1796 } else { /* the nice simple USB class-compliant case */ 1797 packet[0] = MIX_CN_CIN(out_jack->cable_number, cin); 1798 memcpy(packet+1, src, len); 1799 DPR_PACKET(out, sc, packet); 1800 } 1801 ep->next_schedule |= 1<<(out_jack->cable_number); 1802 ++ ep->num_scheduled; 1803 if (!ep->armed && !ep->soliciting) { 1804 /* 1805 * It would be bad to call out_solicit directly here (the 1806 * caller need not be reentrant) but a soft interrupt allows 1807 * solicit to run immediately the caller exits its critical 1808 * section, and if the caller has more to write we can get it 1809 * before starting the USB transfer, and send a longer one. 1810 */ 1811 ep->soliciting = 1; 1812 kpreempt_disable(); 1813 softint_schedule(ep->solicit_cookie); 1814 kpreempt_enable(); 1815 } 1816 1817 if (--sc->sc_refcnt < 0) 1818 cv_broadcast(&sc->sc_detach_cv); 1819 1820 return 0; 1821 } 1822 1823 static void 1824 in_intr(struct usbd_xfer *xfer, void *priv, 1825 usbd_status status) 1826 { 1827 int cn, len, i; 1828 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1829 struct umidi_softc *sc = ep->sc; 1830 struct umidi_jack *jack; 1831 unsigned char *packet; 1832 umidi_packet_bufp slot; 1833 umidi_packet_bufp end; 1834 unsigned char *data; 1835 uint32_t count; 1836 1837 if (ep->sc->sc_dying || !ep->num_open) 1838 return; 1839 1840 mutex_enter(&sc->sc_lock); 1841 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1842 if (0 == count % UMIDI_PACKET_SIZE) { 1843 DPRINTFN(200,("%s: input endpoint %p transfer length %u\n", 1844 device_xname(ep->sc->sc_dev), ep, count)); 1845 } else { 1846 DPRINTF(("%s: input endpoint %p odd transfer length %u\n", 1847 device_xname(ep->sc->sc_dev), ep, count)); 1848 } 1849 1850 slot = ep->buffer; 1851 end = slot + count / sizeof(*slot); 1852 1853 for (packet = *slot; slot < end; packet = *++slot) { 1854 1855 if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1856 cn = (0xf0&(packet[3]))>>4; 1857 len = 0x0f&(packet[3]); 1858 data = packet; 1859 } else { 1860 cn = GET_CN(packet[0]); 1861 len = packet_length[GET_CIN(packet[0])]; 1862 data = packet + 1; 1863 } 1864 /* 0 <= cn <= 15 by inspection of above code */ 1865 if (!(jack = ep->jacks[cn]) || cn != jack->cable_number) { 1866 DPRINTF(("%s: stray input endpoint %p cable %d len %d: " 1867 "%02X %02X %02X (try CN_SEQ quirk?)\n", 1868 device_xname(ep->sc->sc_dev), ep, cn, len, 1869 (unsigned)data[0], 1870 (unsigned)data[1], 1871 (unsigned)data[2])); 1872 mutex_exit(&sc->sc_lock); 1873 return; 1874 } 1875 1876 if (!jack->bound || !jack->opened) 1877 continue; 1878 1879 DPRINTFN(500,("%s: input endpoint %p cable %d len %d: " 1880 "%02X %02X %02X\n", 1881 device_xname(ep->sc->sc_dev), ep, cn, len, 1882 (unsigned)data[0], 1883 (unsigned)data[1], 1884 (unsigned)data[2])); 1885 1886 if (jack->u.in.intr) { 1887 for (i = 0; i < len; i++) { 1888 (*jack->u.in.intr)(jack->arg, data[i]); 1889 } 1890 } 1891 1892 } 1893 1894 (void)start_input_transfer(ep); 1895 mutex_exit(&sc->sc_lock); 1896 } 1897 1898 static void 1899 out_intr(struct usbd_xfer *xfer, void *priv, 1900 usbd_status status) 1901 { 1902 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1903 struct umidi_softc *sc = ep->sc; 1904 uint32_t count; 1905 1906 if (sc->sc_dying) 1907 return; 1908 1909 mutex_enter(&sc->sc_lock); 1910 #ifdef UMIDI_DEBUG 1911 if (umididebug >= 200) 1912 microtime(&umidi_tv); 1913 #endif 1914 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1915 if (0 == count % UMIDI_PACKET_SIZE) { 1916 DPRINTFN(200, ("%s: %"PRIu64".%06"PRIu64"s out ep %p xfer " 1917 "length %u\n", device_xname(ep->sc->sc_dev), 1918 umidi_tv.tv_sec%100, (uint64_t)umidi_tv.tv_usec, ep, 1919 count)); 1920 } else { 1921 DPRINTF(("%s: output endpoint %p odd transfer length %u\n", 1922 device_xname(ep->sc->sc_dev), ep, count)); 1923 } 1924 count /= UMIDI_PACKET_SIZE; 1925 1926 /* 1927 * If while the transfer was pending we buffered any new messages, 1928 * move them to the start of the buffer. 1929 */ 1930 ep->next_slot -= count; 1931 if (ep->buffer < ep->next_slot) { 1932 memcpy(ep->buffer, ep->buffer + count, 1933 (char *)ep->next_slot - (char *)ep->buffer); 1934 } 1935 cv_broadcast(&sc->sc_cv); 1936 /* 1937 * Do not want anyone else to see armed <- 0 before soliciting <- 1. 1938 * Running at IPL_USB so the following should happen to be safe. 1939 */ 1940 ep->armed = 0; 1941 if (!ep->soliciting) { 1942 ep->soliciting = 1; 1943 out_solicit_locked(ep); 1944 } 1945 mutex_exit(&sc->sc_lock); 1946 } 1947 1948 /* 1949 * A jack on which we have received a packet must be called back on its 1950 * out.intr handler before it will send us another; it is considered 1951 * 'scheduled'. It is nice and predictable - as long as it is scheduled, 1952 * we need no extra buffer space for it. 1953 * 1954 * In contrast, a jack that is open but not scheduled may supply us a packet 1955 * at any time, driven by the top half, and we must be able to accept it, no 1956 * excuses. So we must ensure that at any point in time there are at least 1957 * (num_open - num_scheduled) slots free. 1958 * 1959 * As long as there are more slots free than that minimum, we can loop calling 1960 * scheduled jacks back on their "interrupt" handlers, soliciting more 1961 * packets, starting the USB transfer only when the buffer space is down to 1962 * the minimum or no jack has any more to send. 1963 */ 1964 1965 static void 1966 out_solicit_locked(void *arg) 1967 { 1968 struct umidi_endpoint *ep = arg; 1969 umidi_packet_bufp end; 1970 uint16_t which; 1971 struct umidi_jack *jack; 1972 1973 KASSERT(mutex_owned(&ep->sc->sc_lock)); 1974 1975 end = ep->buffer + ep->buffer_size / sizeof(*ep->buffer); 1976 1977 for ( ;; ) { 1978 if (end - ep->next_slot <= ep->num_open - ep->num_scheduled) 1979 break; /* at IPL_USB */ 1980 if (ep->this_schedule == 0) { 1981 if (ep->next_schedule == 0) 1982 break; /* at IPL_USB */ 1983 ep->this_schedule = ep->next_schedule; 1984 ep->next_schedule = 0; 1985 } 1986 /* 1987 * At least one jack is scheduled. Find and mask off the least 1988 * set bit in this_schedule and decrement num_scheduled. 1989 * Convert mask to bit index to find the corresponding jack, 1990 * and call its intr handler. If it has a message, it will call 1991 * back one of the output methods, which will set its bit in 1992 * next_schedule (not copied into this_schedule until the 1993 * latter is empty). In this way we round-robin the jacks that 1994 * have messages to send, until the buffer is as full as we 1995 * dare, and then start a transfer. 1996 */ 1997 which = ep->this_schedule; 1998 which &= (~which)+1; /* now mask of least set bit */ 1999 ep->this_schedule &= ~which; 2000 --ep->num_scheduled; 2001 2002 --which; /* now 1s below mask - count 1s to get index */ 2003 which -= ((which >> 1) & 0x5555);/* SWAR credit aggregate.org */ 2004 which = (((which >> 2) & 0x3333) + (which & 0x3333)); 2005 which = (((which >> 4) + which) & 0x0f0f); 2006 which += (which >> 8); 2007 which &= 0x1f; /* the bit index a/k/a jack number */ 2008 2009 jack = ep->jacks[which]; 2010 if (jack->u.out.intr) 2011 (*jack->u.out.intr)(jack->arg); 2012 } 2013 /* intr lock held at loop exit */ 2014 if (!ep->armed && ep->next_slot > ep->buffer) { 2015 /* 2016 * Can't hold the interrupt lock while calling into USB, 2017 * but we can safely drop it here. 2018 */ 2019 mutex_exit(&ep->sc->sc_lock); 2020 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep)); 2021 mutex_enter(&ep->sc->sc_lock); 2022 } 2023 ep->soliciting = 0; 2024 } 2025 2026 /* Entry point for the softintr. */ 2027 static void 2028 out_solicit(void *arg) 2029 { 2030 struct umidi_endpoint *ep = arg; 2031 struct umidi_softc *sc = ep->sc; 2032 2033 mutex_enter(&sc->sc_lock); 2034 out_solicit_locked(arg); 2035 mutex_exit(&sc->sc_lock); 2036 } 2037
Indexes created Wed Sep 24 15:09:51 GMT 2025