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