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