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