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