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