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