1 /* $OpenBSD: umidi.c,v 1.25 2008/06/26 05:42:19 ray Exp $ */ 2 /* $NetBSD: umidi.c,v 1.16 2002/07/11 21:14:32 augustss Exp $ */ 3 /* 4 * Copyright (c) 2001 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Takuya SHIOZAKI (tshiozak@netbsd.org). 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/kernel.h> 35 #include <sys/malloc.h> 36 #include <sys/device.h> 37 #include <sys/ioctl.h> 38 #include <sys/conf.h> 39 #include <sys/file.h> 40 #include <sys/selinfo.h> 41 #include <sys/proc.h> 42 #include <sys/vnode.h> 43 #include <sys/poll.h> 44 45 #include <dev/usb/usb.h> 46 #include <dev/usb/usbdi.h> 47 #include <dev/usb/usbdi_util.h> 48 49 #include <dev/usb/usbdevs.h> 50 #include <dev/usb/uaudioreg.h> 51 #include <dev/usb/umidireg.h> 52 #include <dev/usb/umidivar.h> 53 #include <dev/usb/umidi_quirks.h> 54 55 #include <dev/midi_if.h> 56 57 #ifdef UMIDI_DEBUG 58 #define DPRINTF(x) if (umididebug) printf x 59 #define DPRINTFN(n,x) if (umididebug >= (n)) printf x 60 int umididebug = 0; 61 #else 62 #define DPRINTF(x) 63 #define DPRINTFN(n,x) 64 #endif 65 66 67 static int umidi_open(void *, int, 68 void (*)(void *, int), void (*)(void *), void *); 69 static void umidi_close(void *); 70 static int umidi_output(void *, int); 71 static void umidi_flush(void *); 72 static void umidi_getinfo(void *, struct midi_info *); 73 74 static usbd_status alloc_pipe(struct umidi_endpoint *); 75 static void free_pipe(struct umidi_endpoint *); 76 77 static usbd_status alloc_all_endpoints(struct umidi_softc *); 78 static void free_all_endpoints(struct umidi_softc *); 79 80 static usbd_status alloc_all_jacks(struct umidi_softc *); 81 static void free_all_jacks(struct umidi_softc *); 82 static usbd_status bind_jacks_to_mididev(struct umidi_softc *, 83 struct umidi_jack *, 84 struct umidi_jack *, 85 struct umidi_mididev *); 86 static void unbind_jacks_from_mididev(struct umidi_mididev *); 87 static void unbind_all_jacks(struct umidi_softc *); 88 static usbd_status assign_all_jacks_automatically(struct umidi_softc *); 89 static usbd_status open_out_jack(struct umidi_jack *, void *, 90 void (*)(void *)); 91 static usbd_status open_in_jack(struct umidi_jack *, void *, 92 void (*)(void *, int)); 93 static void close_out_jack(struct umidi_jack *); 94 static void close_in_jack(struct umidi_jack *); 95 96 static usbd_status attach_mididev(struct umidi_softc *, 97 struct umidi_mididev *); 98 static usbd_status detach_mididev(struct umidi_mididev *, int); 99 static usbd_status deactivate_mididev(struct umidi_mididev *); 100 static usbd_status alloc_all_mididevs(struct umidi_softc *, int); 101 static void free_all_mididevs(struct umidi_softc *); 102 static usbd_status attach_all_mididevs(struct umidi_softc *); 103 static usbd_status detach_all_mididevs(struct umidi_softc *, int); 104 static usbd_status deactivate_all_mididevs(struct umidi_softc *); 105 106 #ifdef UMIDI_DEBUG 107 static void dump_sc(struct umidi_softc *); 108 static void dump_ep(struct umidi_endpoint *); 109 static void dump_jack(struct umidi_jack *); 110 #endif 111 112 static void init_packet(struct umidi_packet *); 113 114 static usbd_status start_input_transfer(struct umidi_endpoint *); 115 static usbd_status start_output_transfer(struct umidi_endpoint *); 116 static int out_jack_output(struct umidi_jack *, int); 117 static void out_jack_flush(struct umidi_jack *); 118 static void in_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); 119 static void out_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); 120 static int out_build_packet(int, struct umidi_packet *, uByte, u_char *); 121 122 123 struct midi_hw_if umidi_hw_if = { 124 umidi_open, 125 umidi_close, 126 umidi_output, 127 umidi_flush, /* flush */ 128 umidi_getinfo, 129 0, /* ioctl */ 130 }; 131 132 int umidi_match(struct device *, void *, void *); 133 void umidi_attach(struct device *, struct device *, void *); 134 int umidi_detach(struct device *, int); 135 int umidi_activate(struct device *, enum devact); 136 137 struct cfdriver umidi_cd = { 138 NULL, "umidi", DV_DULL 139 }; 140 141 const struct cfattach umidi_ca = { 142 sizeof(struct umidi_softc), 143 umidi_match, 144 umidi_attach, 145 umidi_detach, 146 umidi_activate, 147 }; 148 149 int 150 umidi_match(struct device *parent, void *match, void *aux) 151 { 152 struct usb_attach_arg *uaa = aux; 153 usb_interface_descriptor_t *id; 154 155 DPRINTFN(1,("umidi_match\n")); 156 157 if (uaa->iface == NULL) 158 return UMATCH_NONE; 159 160 if (umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno)) 161 return UMATCH_IFACECLASS_IFACESUBCLASS; 162 163 id = usbd_get_interface_descriptor(uaa->iface); 164 if (id!=NULL && 165 id->bInterfaceClass==UICLASS_AUDIO && 166 id->bInterfaceSubClass==UISUBCLASS_MIDISTREAM) 167 return UMATCH_IFACECLASS_IFACESUBCLASS; 168 169 return UMATCH_NONE; 170 } 171 172 void 173 umidi_attach(struct device *parent, struct device *self, void *aux) 174 { 175 usbd_status err; 176 struct umidi_softc *sc = (struct umidi_softc *)self; 177 struct usb_attach_arg *uaa = aux; 178 int i; 179 180 DPRINTFN(1,("umidi_attach\n")); 181 182 sc->sc_iface = uaa->iface; 183 sc->sc_udev = uaa->device; 184 185 sc->sc_quirk = 186 umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno); 187 printf("%s: ", sc->sc_dev.dv_xname); 188 umidi_print_quirk(sc->sc_quirk); 189 190 191 err = alloc_all_endpoints(sc); 192 if (err!=USBD_NORMAL_COMPLETION) { 193 goto error; 194 } 195 err = alloc_all_jacks(sc); 196 if (err!=USBD_NORMAL_COMPLETION) { 197 free_all_endpoints(sc); 198 goto error; 199 } 200 printf("%s: out=%d, in=%d\n", 201 sc->sc_dev.dv_xname, 202 sc->sc_out_num_jacks, sc->sc_in_num_jacks); 203 204 err = assign_all_jacks_automatically(sc); 205 if (err!=USBD_NORMAL_COMPLETION) { 206 unbind_all_jacks(sc); 207 free_all_jacks(sc); 208 free_all_endpoints(sc); 209 goto error; 210 } 211 err = attach_all_mididevs(sc); 212 if (err!=USBD_NORMAL_COMPLETION) { 213 free_all_jacks(sc); 214 free_all_endpoints(sc); 215 } 216 217 #ifdef UMIDI_DEBUG 218 dump_sc(sc); 219 #endif 220 221 for (i = 0; i < sc->sc_in_num_endpoints; i++) { 222 (void)start_input_transfer(&sc->sc_in_ep[i]); 223 } 224 225 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, 226 sc->sc_udev, &sc->sc_dev); 227 228 return; 229 error: 230 printf("%s: disabled.\n", sc->sc_dev.dv_xname); 231 sc->sc_dying = 1; 232 } 233 234 int 235 umidi_activate(struct device *self, enum devact act) 236 { 237 struct umidi_softc *sc = (struct umidi_softc *)self; 238 239 switch (act) { 240 case DVACT_ACTIVATE: 241 DPRINTFN(1,("umidi_activate (activate)\n")); 242 break; 243 case DVACT_DEACTIVATE: 244 DPRINTFN(1,("umidi_activate (deactivate)\n")); 245 sc->sc_dying = 1; 246 deactivate_all_mididevs(sc); 247 break; 248 } 249 return 0; 250 } 251 252 int 253 umidi_detach(struct device *self, int flags) 254 { 255 struct umidi_softc *sc = (struct umidi_softc *)self; 256 257 DPRINTFN(1,("umidi_detach\n")); 258 259 sc->sc_dying = 1; 260 detach_all_mididevs(sc, flags); 261 free_all_mididevs(sc); 262 free_all_jacks(sc); 263 free_all_endpoints(sc); 264 265 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 266 &sc->sc_dev); 267 268 return 0; 269 } 270 271 272 /* 273 * midi_if stuffs 274 */ 275 int 276 umidi_open(void *addr, 277 int flags, 278 void (*iintr)(void *, int), 279 void (*ointr)(void *), 280 void *arg) 281 { 282 struct umidi_mididev *mididev = addr; 283 struct umidi_softc *sc = mididev->sc; 284 285 DPRINTF(("umidi_open: sc=%p\n", sc)); 286 287 if (!sc) 288 return ENXIO; 289 if (mididev->opened) 290 return EBUSY; 291 if (sc->sc_dying) 292 return EIO; 293 294 mididev->opened = 1; 295 mididev->flags = flags; 296 if ((mididev->flags & FWRITE) && mididev->out_jack) 297 open_out_jack(mididev->out_jack, arg, ointr); 298 if ((mididev->flags & FREAD) && mididev->in_jack) { 299 open_in_jack(mididev->in_jack, arg, iintr); 300 } 301 302 return 0; 303 } 304 305 void 306 umidi_close(void *addr) 307 { 308 int s; 309 struct umidi_mididev *mididev = addr; 310 311 s = splusb(); 312 if ((mididev->flags & FWRITE) && mididev->out_jack) 313 close_out_jack(mididev->out_jack); 314 if ((mididev->flags & FREAD) && mididev->in_jack) 315 close_in_jack(mididev->in_jack); 316 mididev->opened = 0; 317 splx(s); 318 } 319 320 int 321 umidi_output(void *addr, int d) 322 { 323 struct umidi_mididev *mididev = addr; 324 325 if (!mididev->out_jack || !mididev->opened) 326 return EIO; 327 328 return out_jack_output(mididev->out_jack, d); 329 } 330 331 void 332 umidi_flush(void *addr) 333 { 334 struct umidi_mididev *mididev = addr; 335 336 if (!mididev->out_jack || !mididev->opened) 337 return; 338 339 return out_jack_flush(mididev->out_jack); 340 } 341 342 void 343 umidi_getinfo(void *addr, struct midi_info *mi) 344 { 345 struct umidi_mididev *mididev = addr; 346 347 mi->name = "USB MIDI I/F"; /* XXX: model name */ 348 mi->props = MIDI_PROP_OUT_INTR; 349 if (mididev->in_jack) 350 mi->props |= MIDI_PROP_CAN_INPUT; 351 } 352 353 354 /* 355 * each endpoint stuffs 356 */ 357 358 /* alloc/free pipe */ 359 static usbd_status 360 alloc_pipe(struct umidi_endpoint *ep) 361 { 362 struct umidi_softc *sc = ep->sc; 363 usbd_status err; 364 365 DPRINTF(("%s: alloc_pipe %p\n", sc->sc_dev.dv_xname, ep)); 366 SIMPLEQ_INIT(&ep->intrq); 367 ep->pending = 0; 368 ep->busy = 0; 369 ep->used = 0; 370 ep->xfer = usbd_alloc_xfer(sc->sc_udev); 371 if (ep->xfer == NULL) { 372 return USBD_NOMEM; 373 } 374 ep->buffer = usbd_alloc_buffer(ep->xfer, ep->packetsize); 375 if (ep->buffer == NULL) { 376 usbd_free_xfer(ep->xfer); 377 return USBD_NOMEM; 378 } 379 err = usbd_open_pipe(sc->sc_iface, ep->addr, 0, &ep->pipe); 380 if (err != USBD_NORMAL_COMPLETION) { 381 usbd_free_xfer(ep->xfer); 382 return err; 383 } 384 return USBD_NORMAL_COMPLETION; 385 } 386 387 static void 388 free_pipe(struct umidi_endpoint *ep) 389 { 390 DPRINTF(("%s: free_pipe %p\n", ep->sc->sc_dev.dv_xname, ep)); 391 usbd_abort_pipe(ep->pipe); 392 usbd_close_pipe(ep->pipe); 393 usbd_free_xfer(ep->xfer); 394 } 395 396 397 /* alloc/free the array of endpoint structures */ 398 399 static usbd_status alloc_all_endpoints_fixed_ep(struct umidi_softc *); 400 static usbd_status alloc_all_endpoints_yamaha(struct umidi_softc *); 401 static usbd_status alloc_all_endpoints_genuine(struct umidi_softc *); 402 403 static usbd_status 404 alloc_all_endpoints(struct umidi_softc *sc) 405 { 406 usbd_status err; 407 struct umidi_endpoint *ep; 408 int i; 409 410 if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) { 411 err = alloc_all_endpoints_fixed_ep(sc); 412 } else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) { 413 err = alloc_all_endpoints_yamaha(sc); 414 } else { 415 err = alloc_all_endpoints_genuine(sc); 416 } 417 if (err!=USBD_NORMAL_COMPLETION) 418 return err; 419 420 ep = sc->sc_endpoints; 421 for (i=sc->sc_out_num_endpoints+sc->sc_in_num_endpoints; i>0; i--) { 422 err = alloc_pipe(ep); 423 if (err!=USBD_NORMAL_COMPLETION) { 424 while(ep != sc->sc_endpoints) { 425 ep--; 426 free_pipe(ep); 427 } 428 free(sc->sc_endpoints, M_USBDEV); 429 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 430 break; 431 } 432 ep++; 433 } 434 return err; 435 } 436 437 static void 438 free_all_endpoints(struct umidi_softc *sc) 439 { 440 int i; 441 for (i=0; i<sc->sc_in_num_endpoints+sc->sc_out_num_endpoints; i++) 442 free_pipe(&sc->sc_endpoints[i]); 443 if (sc->sc_endpoints != NULL) 444 free(sc->sc_endpoints, M_USBDEV); 445 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 446 } 447 448 static usbd_status 449 alloc_all_endpoints_fixed_ep(struct umidi_softc *sc) 450 { 451 usbd_status err; 452 struct umq_fixed_ep_desc *fp; 453 struct umidi_endpoint *ep; 454 usb_endpoint_descriptor_t *epd; 455 int i; 456 457 fp = umidi_get_quirk_data_from_type(sc->sc_quirk, 458 UMQ_TYPE_FIXED_EP); 459 sc->sc_out_num_jacks = 0; 460 sc->sc_in_num_jacks = 0; 461 sc->sc_out_num_endpoints = fp->num_out_ep; 462 sc->sc_in_num_endpoints = fp->num_in_ep; 463 sc->sc_endpoints = malloc(sizeof(*sc->sc_out_ep)* 464 (sc->sc_out_num_endpoints+ 465 sc->sc_in_num_endpoints), 466 M_USBDEV, M_WAITOK); 467 if (!sc->sc_endpoints) { 468 return USBD_NOMEM; 469 } 470 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 471 sc->sc_in_ep = 472 sc->sc_in_num_endpoints ? 473 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 474 475 ep = &sc->sc_out_ep[0]; 476 for (i=0; i<sc->sc_out_num_endpoints; i++) { 477 epd = usbd_interface2endpoint_descriptor( 478 sc->sc_iface, 479 fp->out_ep[i].ep); 480 if (!epd) { 481 DPRINTF(("%s: cannot get endpoint descriptor(out:%d)\n", 482 sc->sc_dev.dv_xname, fp->out_ep[i].ep)); 483 err = USBD_INVAL; 484 goto error; 485 } 486 if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK || 487 UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_OUT) { 488 printf("%s: illegal endpoint(out:%d)\n", 489 sc->sc_dev.dv_xname, fp->out_ep[i].ep); 490 err = USBD_INVAL; 491 goto error; 492 } 493 ep->sc = sc; 494 ep->packetsize = UGETW(epd->wMaxPacketSize); 495 ep->addr = epd->bEndpointAddress; 496 ep->num_jacks = fp->out_ep[i].num_jacks; 497 sc->sc_out_num_jacks += fp->out_ep[i].num_jacks; 498 ep->num_open = 0; 499 memset(ep->jacks, 0, sizeof(ep->jacks)); 500 ep++; 501 } 502 ep = &sc->sc_in_ep[0]; 503 for (i=0; i<sc->sc_in_num_endpoints; i++) { 504 epd = usbd_interface2endpoint_descriptor( 505 sc->sc_iface, 506 fp->in_ep[i].ep); 507 if (!epd) { 508 DPRINTF(("%s: cannot get endpoint descriptor(in:%d)\n", 509 sc->sc_dev.dv_xname, fp->in_ep[i].ep)); 510 err = USBD_INVAL; 511 goto error; 512 } 513 if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK || 514 UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_IN) { 515 printf("%s: illegal endpoint(in:%d)\n", 516 sc->sc_dev.dv_xname, fp->in_ep[i].ep); 517 err = USBD_INVAL; 518 goto error; 519 } 520 ep->sc = sc; 521 ep->addr = epd->bEndpointAddress; 522 ep->packetsize = UGETW(epd->wMaxPacketSize); 523 ep->num_jacks = fp->in_ep[i].num_jacks; 524 sc->sc_in_num_jacks += fp->in_ep[i].num_jacks; 525 ep->num_open = 0; 526 memset(ep->jacks, 0, sizeof(ep->jacks)); 527 ep++; 528 } 529 530 return USBD_NORMAL_COMPLETION; 531 error: 532 free(sc->sc_endpoints, M_USBDEV); 533 sc->sc_endpoints = NULL; 534 return err; 535 } 536 537 static usbd_status 538 alloc_all_endpoints_yamaha(struct umidi_softc *sc) 539 { 540 /* This driver currently supports max 1in/1out bulk endpoints */ 541 usb_descriptor_t *desc; 542 usb_endpoint_descriptor_t *epd; 543 int out_addr, in_addr, in_packetsize, i; 544 int dir; 545 size_t remain, descsize; 546 547 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 548 out_addr = in_addr = 0; 549 550 /* detect endpoints */ 551 desc = TO_D(usbd_get_interface_descriptor(sc->sc_iface)); 552 for (i=(int)TO_IFD(desc)->bNumEndpoints-1; i>=0; i--) { 553 epd = usbd_interface2endpoint_descriptor(sc->sc_iface, i); 554 if (UE_GET_XFERTYPE(epd->bmAttributes) == UE_BULK) { 555 dir = UE_GET_DIR(epd->bEndpointAddress); 556 if (dir==UE_DIR_OUT && !out_addr) 557 out_addr = epd->bEndpointAddress; 558 else if (dir==UE_DIR_IN && !in_addr) { 559 in_addr = epd->bEndpointAddress; 560 in_packetsize = UGETW(epd->wMaxPacketSize); 561 } 562 } 563 } 564 desc = NEXT_D(desc); 565 566 /* count jacks */ 567 if (!(desc->bDescriptorType==UDESC_CS_INTERFACE && 568 desc->bDescriptorSubtype==UMIDI_MS_HEADER)) 569 return USBD_INVAL; 570 remain = (size_t)UGETW(TO_CSIFD(desc)->wTotalLength) - 571 (size_t)desc->bLength; 572 desc = NEXT_D(desc); 573 574 while (remain>=sizeof(usb_descriptor_t)) { 575 descsize = desc->bLength; 576 if (descsize>remain || descsize==0) 577 break; 578 if (desc->bDescriptorType==UDESC_CS_INTERFACE && 579 remain>=UMIDI_JACK_DESCRIPTOR_SIZE) { 580 if (desc->bDescriptorSubtype==UMIDI_OUT_JACK) 581 sc->sc_out_num_jacks++; 582 else if (desc->bDescriptorSubtype==UMIDI_IN_JACK) 583 sc->sc_in_num_jacks++; 584 } 585 desc = NEXT_D(desc); 586 remain-=descsize; 587 } 588 589 /* validate some parameters */ 590 if (sc->sc_out_num_jacks>UMIDI_MAX_EPJACKS) 591 sc->sc_out_num_jacks = UMIDI_MAX_EPJACKS; 592 if (sc->sc_in_num_jacks>UMIDI_MAX_EPJACKS) 593 sc->sc_in_num_jacks = UMIDI_MAX_EPJACKS; 594 if (sc->sc_out_num_jacks && out_addr) { 595 sc->sc_out_num_endpoints = 1; 596 } else { 597 sc->sc_out_num_endpoints = 0; 598 sc->sc_out_num_jacks = 0; 599 } 600 if (sc->sc_in_num_jacks && in_addr) { 601 sc->sc_in_num_endpoints = 1; 602 } else { 603 sc->sc_in_num_endpoints = 0; 604 sc->sc_in_num_jacks = 0; 605 } 606 sc->sc_endpoints = malloc(sizeof(struct umidi_endpoint)* 607 (sc->sc_out_num_endpoints+ 608 sc->sc_in_num_endpoints), 609 M_USBDEV, M_WAITOK); 610 if (!sc->sc_endpoints) 611 return USBD_NOMEM; 612 if (sc->sc_out_num_endpoints) { 613 sc->sc_out_ep = sc->sc_endpoints; 614 sc->sc_out_ep->sc = sc; 615 sc->sc_out_ep->addr = out_addr; 616 sc->sc_out_ep->packetsize = UGETW(epd->wMaxPacketSize); 617 sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks; 618 sc->sc_out_ep->num_open = 0; 619 memset(sc->sc_out_ep->jacks, 0, sizeof(sc->sc_out_ep->jacks)); 620 } else 621 sc->sc_out_ep = NULL; 622 623 if (sc->sc_in_num_endpoints) { 624 sc->sc_in_ep = sc->sc_endpoints+sc->sc_out_num_endpoints; 625 sc->sc_in_ep->sc = sc; 626 sc->sc_in_ep->addr = in_addr; 627 sc->sc_in_ep->packetsize = in_packetsize; 628 sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks; 629 sc->sc_in_ep->num_open = 0; 630 memset(sc->sc_in_ep->jacks, 0, sizeof(sc->sc_in_ep->jacks)); 631 } else 632 sc->sc_in_ep = NULL; 633 634 return USBD_NORMAL_COMPLETION; 635 } 636 637 static usbd_status 638 alloc_all_endpoints_genuine(struct umidi_softc *sc) 639 { 640 usb_interface_descriptor_t *interface_desc; 641 usb_config_descriptor_t *config_desc; 642 usb_descriptor_t *desc; 643 int num_ep; 644 size_t remain, descsize; 645 struct umidi_endpoint *p, *q, *lowest, *endep, tmpep; 646 int epaddr, eppacketsize; 647 648 interface_desc = usbd_get_interface_descriptor(sc->sc_iface); 649 num_ep = interface_desc->bNumEndpoints; 650 sc->sc_endpoints = p = malloc(sizeof(struct umidi_endpoint) * num_ep, 651 M_USBDEV, M_WAITOK); 652 if (!p) 653 return USBD_NOMEM; 654 655 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 656 sc->sc_out_num_endpoints = sc->sc_in_num_endpoints = 0; 657 epaddr = -1; 658 659 /* get the list of endpoints for midi stream */ 660 config_desc = usbd_get_config_descriptor(sc->sc_udev); 661 desc = (usb_descriptor_t *) config_desc; 662 remain = (size_t)UGETW(config_desc->wTotalLength); 663 while (remain>=sizeof(usb_descriptor_t)) { 664 descsize = desc->bLength; 665 if (descsize>remain || descsize==0) 666 break; 667 if (desc->bDescriptorType==UDESC_ENDPOINT && 668 remain>=USB_ENDPOINT_DESCRIPTOR_SIZE && 669 UE_GET_XFERTYPE(TO_EPD(desc)->bmAttributes) == UE_BULK) { 670 epaddr = TO_EPD(desc)->bEndpointAddress; 671 eppacketsize = UGETW(TO_EPD(desc)->wMaxPacketSize); 672 } else if (desc->bDescriptorType==UDESC_CS_ENDPOINT && 673 remain>=UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE && 674 epaddr!=-1) { 675 if (num_ep>0) { 676 num_ep--; 677 p->sc = sc; 678 p->addr = epaddr; 679 p->packetsize = eppacketsize; 680 p->num_jacks = TO_CSEPD(desc)->bNumEmbMIDIJack; 681 if (UE_GET_DIR(epaddr)==UE_DIR_OUT) { 682 sc->sc_out_num_endpoints++; 683 sc->sc_out_num_jacks += p->num_jacks; 684 } else { 685 sc->sc_in_num_endpoints++; 686 sc->sc_in_num_jacks += p->num_jacks; 687 } 688 p++; 689 } 690 } else 691 epaddr = -1; 692 desc = NEXT_D(desc); 693 remain-=descsize; 694 } 695 696 /* sort endpoints */ 697 num_ep = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints; 698 p = sc->sc_endpoints; 699 endep = p + num_ep; 700 while (p<endep) { 701 lowest = p; 702 for (q=p+1; q<endep; q++) { 703 if ((UE_GET_DIR(lowest->addr)==UE_DIR_IN && 704 UE_GET_DIR(q->addr)==UE_DIR_OUT) || 705 ((UE_GET_DIR(lowest->addr)== 706 UE_GET_DIR(q->addr)) && 707 (UE_GET_ADDR(lowest->addr)> 708 UE_GET_ADDR(q->addr)))) 709 lowest = q; 710 } 711 if (lowest != p) { 712 memcpy((void *)&tmpep, (void *)p, sizeof(tmpep)); 713 memcpy((void *)p, (void *)lowest, sizeof(tmpep)); 714 memcpy((void *)lowest, (void *)&tmpep, sizeof(tmpep)); 715 } 716 p->num_open = 0; 717 p++; 718 } 719 720 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 721 sc->sc_in_ep = 722 sc->sc_in_num_endpoints ? 723 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 724 725 return USBD_NORMAL_COMPLETION; 726 } 727 728 729 /* 730 * jack stuffs 731 */ 732 733 static usbd_status 734 alloc_all_jacks(struct umidi_softc *sc) 735 { 736 int i, j; 737 struct umidi_endpoint *ep; 738 struct umidi_jack *jack, **rjack; 739 740 /* allocate/initialize structures */ 741 sc->sc_jacks = 742 malloc(sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+ 743 sc->sc_out_num_jacks), 744 M_USBDEV, M_WAITOK); 745 if (!sc->sc_jacks) 746 return USBD_NOMEM; 747 sc->sc_out_jacks = 748 sc->sc_out_num_jacks ? sc->sc_jacks : NULL; 749 sc->sc_in_jacks = 750 sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL; 751 752 jack = &sc->sc_out_jacks[0]; 753 for (i=0; i<sc->sc_out_num_jacks; i++) { 754 jack->opened = 0; 755 jack->binded = 0; 756 jack->arg = NULL; 757 jack->u.out.intr = NULL; 758 #ifdef DIAGNOSTIC 759 jack->wait = 0; 760 #endif 761 jack->cable_number = i; 762 jack++; 763 } 764 jack = &sc->sc_in_jacks[0]; 765 for (i=0; i<sc->sc_in_num_jacks; i++) { 766 jack->opened = 0; 767 jack->binded = 0; 768 jack->arg = NULL; 769 jack->u.in.intr = NULL; 770 jack->cable_number = i; 771 jack++; 772 } 773 774 /* assign each jacks to each endpoints */ 775 jack = &sc->sc_out_jacks[0]; 776 ep = &sc->sc_out_ep[0]; 777 for (i=0; i<sc->sc_out_num_endpoints; i++) { 778 rjack = &ep->jacks[0]; 779 for (j=0; j<ep->num_jacks; j++) { 780 *rjack = jack; 781 jack->endpoint = ep; 782 jack++; 783 rjack++; 784 } 785 ep++; 786 } 787 jack = &sc->sc_in_jacks[0]; 788 ep = &sc->sc_in_ep[0]; 789 for (i=0; i<sc->sc_in_num_endpoints; i++) { 790 rjack = &ep->jacks[0]; 791 for (j=0; j<ep->num_jacks; j++) { 792 *rjack = jack; 793 jack->endpoint = ep; 794 jack++; 795 rjack++; 796 } 797 ep++; 798 } 799 800 return USBD_NORMAL_COMPLETION; 801 } 802 803 static void 804 free_all_jacks(struct umidi_softc *sc) 805 { 806 int s; 807 808 s = splaudio(); 809 if (sc->sc_out_jacks) { 810 free(sc->sc_jacks, M_USBDEV); 811 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL; 812 } 813 splx(s); 814 } 815 816 static usbd_status 817 bind_jacks_to_mididev(struct umidi_softc *sc, 818 struct umidi_jack *out_jack, 819 struct umidi_jack *in_jack, 820 struct umidi_mididev *mididev) 821 { 822 if ((out_jack && out_jack->binded) || (in_jack && in_jack->binded)) 823 return USBD_IN_USE; 824 if (mididev->out_jack || mididev->in_jack) 825 return USBD_IN_USE; 826 827 if (out_jack) 828 out_jack->binded = 1; 829 if (in_jack) 830 in_jack->binded = 1; 831 mididev->in_jack = in_jack; 832 mididev->out_jack = out_jack; 833 834 return USBD_NORMAL_COMPLETION; 835 } 836 837 static void 838 unbind_jacks_from_mididev(struct umidi_mididev *mididev) 839 { 840 if ((mididev->flags & FWRITE) && mididev->out_jack) 841 close_out_jack(mididev->out_jack); 842 if ((mididev->flags & FREAD) && mididev->in_jack) 843 close_in_jack(mididev->in_jack); 844 845 if (mididev->out_jack) 846 mididev->out_jack->binded = 0; 847 if (mididev->in_jack) 848 mididev->in_jack->binded = 0; 849 mididev->out_jack = mididev->in_jack = NULL; 850 } 851 852 static void 853 unbind_all_jacks(struct umidi_softc *sc) 854 { 855 int i; 856 857 if (sc->sc_mididevs) 858 for (i=0; i<sc->sc_num_mididevs; i++) { 859 unbind_jacks_from_mididev(&sc->sc_mididevs[i]); 860 } 861 } 862 863 static usbd_status 864 assign_all_jacks_automatically(struct umidi_softc *sc) 865 { 866 usbd_status err; 867 int i; 868 struct umidi_jack *out, *in; 869 870 err = 871 alloc_all_mididevs(sc, 872 max(sc->sc_out_num_jacks, sc->sc_in_num_jacks)); 873 if (err!=USBD_NORMAL_COMPLETION) 874 return err; 875 876 for (i=0; i<sc->sc_num_mididevs; i++) { 877 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i]:NULL; 878 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i]:NULL; 879 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]); 880 if (err!=USBD_NORMAL_COMPLETION) { 881 free_all_mididevs(sc); 882 return err; 883 } 884 } 885 886 return USBD_NORMAL_COMPLETION; 887 } 888 889 static usbd_status 890 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *)) 891 { 892 if (jack->opened) 893 return USBD_IN_USE; 894 895 jack->arg = arg; 896 jack->u.out.intr = intr; 897 init_packet(&jack->packet); 898 jack->opened = 1; 899 jack->endpoint->num_open++; 900 901 return USBD_NORMAL_COMPLETION; 902 } 903 904 static usbd_status 905 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int)) 906 { 907 if (jack->opened) 908 return USBD_IN_USE; 909 910 jack->arg = arg; 911 jack->u.in.intr = intr; 912 jack->opened = 1; 913 jack->endpoint->num_open++; 914 915 return USBD_NORMAL_COMPLETION; 916 } 917 918 static void 919 close_out_jack(struct umidi_jack *jack) 920 { 921 if (jack->opened) { 922 jack->opened = 0; 923 jack->endpoint->num_open--; 924 } 925 } 926 927 static void 928 close_in_jack(struct umidi_jack *jack) 929 { 930 if (jack->opened) { 931 jack->opened = 0; 932 jack->endpoint->num_open--; 933 } 934 } 935 936 static usbd_status 937 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev) 938 { 939 if (mididev->sc) 940 return USBD_IN_USE; 941 942 mididev->sc = sc; 943 944 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, &sc->sc_dev); 945 946 return USBD_NORMAL_COMPLETION; 947 } 948 949 static usbd_status 950 detach_mididev(struct umidi_mididev *mididev, int flags) 951 { 952 if (!mididev->sc) 953 return USBD_NO_ADDR; 954 955 if (mididev->opened) { 956 umidi_close(mididev); 957 } 958 unbind_jacks_from_mididev(mididev); 959 960 if (mididev->mdev) 961 config_detach(mididev->mdev, flags); 962 963 mididev->sc = NULL; 964 965 return USBD_NORMAL_COMPLETION; 966 } 967 968 static usbd_status 969 deactivate_mididev(struct umidi_mididev *mididev) 970 { 971 if (mididev->out_jack) 972 mididev->out_jack->binded = 0; 973 if (mididev->in_jack) 974 mididev->in_jack->binded = 0; 975 config_deactivate(mididev->mdev); 976 977 return USBD_NORMAL_COMPLETION; 978 } 979 980 static usbd_status 981 alloc_all_mididevs(struct umidi_softc *sc, int nmidi) 982 { 983 sc->sc_num_mididevs = nmidi; 984 sc->sc_mididevs = malloc(sizeof(*sc->sc_mididevs)*nmidi, M_USBDEV, 985 M_WAITOK | M_ZERO); 986 if (!sc->sc_mididevs) 987 return USBD_NOMEM; 988 989 return USBD_NORMAL_COMPLETION; 990 } 991 992 static void 993 free_all_mididevs(struct umidi_softc *sc) 994 { 995 sc->sc_num_mididevs = 0; 996 if (sc->sc_mididevs) 997 free(sc->sc_mididevs, M_USBDEV); 998 } 999 1000 static usbd_status 1001 attach_all_mididevs(struct umidi_softc *sc) 1002 { 1003 usbd_status err; 1004 int i; 1005 1006 if (sc->sc_mididevs) 1007 for (i=0; i<sc->sc_num_mididevs; i++) { 1008 err = attach_mididev(sc, &sc->sc_mididevs[i]); 1009 if (err!=USBD_NORMAL_COMPLETION) 1010 return err; 1011 } 1012 1013 return USBD_NORMAL_COMPLETION; 1014 } 1015 1016 static usbd_status 1017 detach_all_mididevs(struct umidi_softc *sc, int flags) 1018 { 1019 usbd_status err; 1020 int i; 1021 1022 if (sc->sc_mididevs) 1023 for (i=0; i<sc->sc_num_mididevs; i++) { 1024 err = detach_mididev(&sc->sc_mididevs[i], flags); 1025 if (err!=USBD_NORMAL_COMPLETION) 1026 return err; 1027 } 1028 1029 return USBD_NORMAL_COMPLETION; 1030 } 1031 1032 static usbd_status 1033 deactivate_all_mididevs(struct umidi_softc *sc) 1034 { 1035 usbd_status err; 1036 int i; 1037 1038 if (sc->sc_mididevs) 1039 for (i=0; i<sc->sc_num_mididevs; i++) { 1040 err = deactivate_mididev(&sc->sc_mididevs[i]); 1041 if (err!=USBD_NORMAL_COMPLETION) 1042 return err; 1043 } 1044 1045 return USBD_NORMAL_COMPLETION; 1046 } 1047 1048 #ifdef UMIDI_DEBUG 1049 static void 1050 dump_sc(struct umidi_softc *sc) 1051 { 1052 int i; 1053 1054 DPRINTFN(10, ("%s: dump_sc\n", sc->sc_dev.dv_xname)); 1055 for (i=0; i<sc->sc_out_num_endpoints; i++) { 1056 DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i])); 1057 dump_ep(&sc->sc_out_ep[i]); 1058 } 1059 for (i=0; i<sc->sc_in_num_endpoints; i++) { 1060 DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i])); 1061 dump_ep(&sc->sc_in_ep[i]); 1062 } 1063 } 1064 1065 static void 1066 dump_ep(struct umidi_endpoint *ep) 1067 { 1068 int i; 1069 for (i=0; i<ep->num_jacks; i++) { 1070 DPRINTFN(10, ("\t\tjack(%p):\n", ep->jacks[i])); 1071 dump_jack(ep->jacks[i]); 1072 } 1073 } 1074 static void 1075 dump_jack(struct umidi_jack *jack) 1076 { 1077 DPRINTFN(10, ("\t\t\tep=%p\n", 1078 jack->endpoint)); 1079 } 1080 1081 #endif /* UMIDI_DEBUG */ 1082 1083 1084 1085 /* 1086 * MUX MIDI PACKET 1087 */ 1088 1089 static const int packet_length[16] = { 1090 /*0*/ -1, 1091 /*1*/ -1, 1092 /*2*/ 2, 1093 /*3*/ 3, 1094 /*4*/ 3, 1095 /*5*/ 1, 1096 /*6*/ 2, 1097 /*7*/ 3, 1098 /*8*/ 3, 1099 /*9*/ 3, 1100 /*A*/ 3, 1101 /*B*/ 3, 1102 /*C*/ 2, 1103 /*D*/ 2, 1104 /*E*/ 3, 1105 /*F*/ 1, 1106 }; 1107 1108 #define GET_CN(p) (((unsigned char)(p)>>4)&0x0F) 1109 #define GET_CIN(p) ((unsigned char)(p)&0x0F) 1110 #define MIX_CN_CIN(cn, cin) \ 1111 ((unsigned char)((((unsigned char)(cn)&0x0F)<<4)| \ 1112 ((unsigned char)(cin)&0x0F))) 1113 1114 static void 1115 init_packet(struct umidi_packet *packet) 1116 { 1117 packet->status = 0; 1118 packet->index = 0; 1119 } 1120 1121 static usbd_status 1122 start_input_transfer(struct umidi_endpoint *ep) 1123 { 1124 usbd_status err; 1125 usbd_setup_xfer(ep->xfer, ep->pipe, 1126 (usbd_private_handle)ep, 1127 ep->buffer, ep->packetsize, 1128 USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, in_intr); 1129 err = usbd_transfer(ep->xfer); 1130 if (err != USBD_NORMAL_COMPLETION && err != USBD_IN_PROGRESS) { 1131 DPRINTF(("%s: start_input_transfer: usbd_transfer() failed err=%s\n", 1132 ep->sc->sc_dev.dv_xname, usbd_errstr(err))); 1133 return err; 1134 } 1135 return USBD_NORMAL_COMPLETION; 1136 } 1137 1138 static usbd_status 1139 start_output_transfer(struct umidi_endpoint *ep) 1140 { 1141 usbd_status err; 1142 usbd_setup_xfer(ep->xfer, ep->pipe, 1143 (usbd_private_handle)ep, 1144 ep->buffer, ep->used, 1145 USBD_NO_COPY, USBD_NO_TIMEOUT, out_intr); 1146 err = usbd_transfer(ep->xfer); 1147 if (err != USBD_NORMAL_COMPLETION && err != USBD_IN_PROGRESS) { 1148 DPRINTF(("%s: start_output_transfer: usbd_transfer() failed err=%s\n", 1149 ep->sc->sc_dev.dv_xname, usbd_errstr(err))); 1150 return err; 1151 } 1152 ep->used = ep->packetsize; 1153 return USBD_NORMAL_COMPLETION; 1154 } 1155 1156 1157 #ifdef UMIDI_DEBUG 1158 #define DPR_PACKET(dir, sc, p) \ 1159 DPRINTFN(500, \ 1160 ("%s: umidi packet(" #dir "): %02X %02X %02X %02X\n", \ 1161 sc->sc_dev.dv_xname, \ 1162 (unsigned char)(p)->buffer[0], \ 1163 (unsigned char)(p)->buffer[1], \ 1164 (unsigned char)(p)->buffer[2], \ 1165 (unsigned char)(p)->buffer[3])); 1166 #else 1167 #define DPR_PACKET(dir, sc, p) 1168 #endif 1169 1170 static int 1171 out_jack_output(struct umidi_jack *j, int d) 1172 { 1173 struct umidi_endpoint *ep = j->endpoint; 1174 struct umidi_softc *sc = ep->sc; 1175 int s; 1176 1177 if (sc->sc_dying) 1178 return EIO; 1179 if (!j->opened) 1180 return ENODEV; 1181 1182 s = splusb(); 1183 if (ep->used == ep->packetsize) { 1184 #ifdef DIAGNOSTIC 1185 if (j->wait == 0) { 1186 j->wait = 1; 1187 #endif 1188 SIMPLEQ_INSERT_TAIL(&ep->intrq, j, intrq_entry); 1189 ep->pending++; 1190 #ifdef DIAGNOSTIC 1191 } else { 1192 printf("umidi: (again) %d: already on intrq\n", 1193 j->cable_number); 1194 } 1195 #endif 1196 splx(s); 1197 return EAGAIN; 1198 } 1199 1200 if (!out_build_packet(j->cable_number, &j->packet, d, 1201 ep->buffer + ep->used)) { 1202 splx(s); 1203 return EINPROGRESS; 1204 } 1205 ep->used += UMIDI_PACKET_SIZE; 1206 if (ep->used < ep->packetsize) { 1207 splx(s); 1208 return EINPROGRESS; 1209 } 1210 #ifdef DIAGNOSTIC 1211 if (j->wait == 0) { 1212 j->wait = 1; 1213 #endif 1214 SIMPLEQ_INSERT_TAIL(&ep->intrq, j, intrq_entry); 1215 ep->pending++; 1216 #ifdef DIAGNOSTIC 1217 } else { 1218 printf("umidi: (ok) %d: already on intrq\n", 1219 j->cable_number); 1220 } 1221 #endif 1222 if (!ep->busy) { 1223 ep->busy = 1; 1224 start_output_transfer(ep); 1225 } 1226 splx(s); 1227 return 0; 1228 } 1229 1230 static void 1231 out_jack_flush(struct umidi_jack *j) 1232 { 1233 struct umidi_endpoint *ep = j->endpoint; 1234 int s; 1235 1236 if (ep->sc->sc_dying || !j->opened) 1237 return; 1238 1239 s = splusb(); 1240 if (ep->used != 0 && !ep->busy) { 1241 ep->busy = 1; 1242 start_output_transfer(ep); 1243 } 1244 splx(s); 1245 } 1246 1247 1248 static void 1249 in_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1250 { 1251 int cn, evlen, remain, i; 1252 unsigned char *buf; 1253 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1254 struct umidi_jack *jack; 1255 1256 if (ep->sc->sc_dying) 1257 return; 1258 1259 usbd_get_xfer_status(xfer, NULL, NULL, &remain, NULL); 1260 if (status != USBD_NORMAL_COMPLETION) { 1261 DPRINTF(("in_intr: abnormal status: %s\n", usbd_errstr(status))); 1262 return; 1263 } 1264 buf = ep->buffer; 1265 while (remain >= UMIDI_PACKET_SIZE) { 1266 cn = GET_CN(buf[0]); 1267 if (cn < ep->num_jacks && (jack = ep->jacks[cn]) && 1268 jack->binded && jack->opened && jack->u.in.intr) { 1269 evlen = packet_length[GET_CIN(buf[0])]; 1270 for (i=0; i<evlen; i++) 1271 (*jack->u.in.intr)(jack->arg, buf[i+1]); 1272 } 1273 buf += UMIDI_PACKET_SIZE; 1274 remain -= UMIDI_PACKET_SIZE; 1275 } 1276 (void)start_input_transfer(ep); 1277 } 1278 1279 static void 1280 out_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1281 { 1282 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1283 struct umidi_softc *sc = ep->sc; 1284 struct umidi_jack *j; 1285 unsigned pending; 1286 1287 if (sc->sc_dying) 1288 return; 1289 1290 ep->used = 0; 1291 for (pending = ep->pending; pending > 0; pending--) { 1292 j = SIMPLEQ_FIRST(&ep->intrq); 1293 #ifdef DIAGNOSTIC 1294 if (j == NULL) { 1295 printf("umidi: missing intr entry\n"); 1296 break; 1297 } 1298 #endif 1299 SIMPLEQ_REMOVE_HEAD(&ep->intrq, intrq_entry); 1300 ep->pending--; 1301 #ifdef DIAGNOSTIC 1302 j->wait = 0; 1303 #endif 1304 if (j->opened && j->u.out.intr) 1305 (*j->u.out.intr)(j->arg); 1306 } 1307 1308 if (ep->used == 0) { 1309 ep->busy = 0; 1310 } else { 1311 start_output_transfer(ep); 1312 } 1313 } 1314 1315 #define UMIDI_VOICELEN(status) (umidi_evlen[((status) >> 4) & 7]) 1316 unsigned umidi_evlen[] = { 4, 4, 4, 4, 3, 3, 4 }; 1317 1318 #define EV_SYSEX 0xf0 1319 #define EV_MTC 0xf1 1320 #define EV_SPP 0xf2 1321 #define EV_SONGSEL 0xf3 1322 #define EV_TUNE_REQ 0xf6 1323 #define EV_SYSEX_STOP 0xf7 1324 1325 static int 1326 out_build_packet(int cable_number, struct umidi_packet *packet, 1327 uByte data, u_char *obuf) 1328 { 1329 if (data >= 0xf8) { /* is it a realtime message ? */ 1330 obuf[0] = data >> 4 | cable_number << 4; 1331 obuf[1] = data; 1332 obuf[2] = 0; 1333 obuf[3] = 0; 1334 return 1; 1335 } 1336 if (data >= 0xf0) { /* is it a common message ? */ 1337 switch(data) { 1338 case EV_SYSEX: 1339 packet->buf[1] = packet->status = data; 1340 packet->index = 2; 1341 break; 1342 case EV_SYSEX_STOP: 1343 if (packet->status != EV_SYSEX) break; 1344 if (packet->index == 0) 1345 packet->index = 1; 1346 packet->status = data; 1347 packet->buf[packet->index++] = data; 1348 packet->buf[0] = (0x4 - 1 + packet->index) | cable_number << 4; 1349 goto packetready; 1350 case EV_TUNE_REQ: 1351 packet->status = data; 1352 packet->buf[0] = 0x5 | cable_number << 4; 1353 packet->index = 1; 1354 goto packetready; 1355 default: 1356 packet->status = data; 1357 break; 1358 } 1359 return 0; 1360 } 1361 if (data >= 0x80) { /* is it a voice message ? */ 1362 packet->status = data; 1363 packet->index = 0; 1364 return 0; 1365 } 1366 1367 /* else it is a data byte */ 1368 if (packet->status >= 0xf0) { 1369 switch(packet->status) { 1370 case EV_SYSEX: /* sysex starts or continues */ 1371 if (packet->index == 0) 1372 packet->index = 1; 1373 1374 packet->buf[packet->index++] = data; 1375 if (packet->index >= UMIDI_PACKET_SIZE) { 1376 packet->buf[0] = 0x4 | cable_number << 4; 1377 goto packetready; 1378 } 1379 break; 1380 case EV_MTC: /* messages with 1 data byte */ 1381 case EV_SONGSEL: 1382 packet->buf[0] = 0x2 | cable_number << 4; 1383 packet->buf[1] = packet->status; 1384 packet->buf[2] = data; 1385 packet->index = 3; 1386 goto packetready; 1387 case EV_SPP: /* messages with 2 data bytes */ 1388 if (packet->index == 0) { 1389 packet->buf[0] = 0x3 | cable_number << 4; 1390 packet->index = 1; 1391 } 1392 packet->buf[packet->index++] = data; 1393 if (packet->index >= UMIDI_PACKET_SIZE) { 1394 packet->buf[1] = packet->status; 1395 goto packetready; 1396 } 1397 break; 1398 default: /* ignore data with unknown status */ 1399 break; 1400 } 1401 return 0; 1402 } 1403 if (packet->status >= 0x80) { /* is it a voice message ? */ 1404 if (packet->index == 0) { 1405 packet->buf[0] = packet->status >> 4 | cable_number << 4; 1406 packet->buf[1] = packet->status; 1407 packet->index = 2; 1408 } 1409 packet->buf[packet->index++] = data; 1410 if (packet->index >= UMIDI_VOICELEN(packet->status)) 1411 goto packetready; 1412 } 1413 /* ignore data with unknown status */ 1414 return 0; 1415 1416 packetready: 1417 while (packet->index < UMIDI_PACKET_SIZE) 1418 packet->buf[packet->index++] = 0; 1419 packet->index = 0; 1420 memcpy(obuf, packet->buf, UMIDI_PACKET_SIZE); 1421 return 1; 1422 } 1423