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