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