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