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