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