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