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