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