umidi.c revision 1.25.2.4
1 /* $NetBSD: umidi.c,v 1.25.2.4 2006/05/20 03:05:05 chap 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.2.4 2006/05/20 03:05:05 chap 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 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 devinfo[1024]; 168 169 DPRINTFN(1,("umidi_attach\n")); 170 171 usbd_devinfo(uaa->device, 0, devinfo); 172 printf("\n%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo); 173 174 sc->sc_iface = uaa->iface; 175 sc->sc_udev = uaa->device; 176 177 sc->sc_quirk = 178 umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno); 179 printf("%s: ", USBDEVNAME(sc->sc_dev)); 180 umidi_print_quirk(sc->sc_quirk); 181 182 183 err = alloc_all_endpoints(sc); 184 if (err!=USBD_NORMAL_COMPLETION) { 185 printf("%s: alloc_all_endpoints failed. (err=%d)\n", 186 USBDEVNAME(sc->sc_dev), err); 187 goto error; 188 } 189 err = alloc_all_jacks(sc); 190 if (err!=USBD_NORMAL_COMPLETION) { 191 free_all_endpoints(sc); 192 printf("%s: alloc_all_jacks failed. (err=%d)\n", 193 USBDEVNAME(sc->sc_dev), err); 194 goto error; 195 } 196 printf("%s: out=%d, in=%d\n", 197 USBDEVNAME(sc->sc_dev), 198 sc->sc_out_num_jacks, sc->sc_in_num_jacks); 199 200 err = assign_all_jacks_automatically(sc); 201 if (err!=USBD_NORMAL_COMPLETION) { 202 unbind_all_jacks(sc); 203 free_all_jacks(sc); 204 free_all_endpoints(sc); 205 printf("%s: assign_all_jacks_automatically failed. (err=%d)\n", 206 USBDEVNAME(sc->sc_dev), err); 207 goto error; 208 } 209 err = attach_all_mididevs(sc); 210 if (err!=USBD_NORMAL_COMPLETION) { 211 free_all_jacks(sc); 212 free_all_endpoints(sc); 213 printf("%s: attach_all_mididevs failed. (err=%d)\n", 214 USBDEVNAME(sc->sc_dev), err); 215 } 216 217 #ifdef UMIDI_DEBUG 218 dump_sc(sc); 219 #endif 220 221 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, 222 sc->sc_udev, USBDEV(sc->sc_dev)); 223 224 USB_ATTACH_SUCCESS_RETURN; 225 error: 226 printf("%s: disabled.\n", USBDEVNAME(sc->sc_dev)); 227 sc->sc_dying = 1; 228 USB_ATTACH_ERROR_RETURN; 229 } 230 231 int 232 umidi_activate(device_ptr_t self, enum devact act) 233 { 234 struct umidi_softc *sc = (struct umidi_softc *)self; 235 236 switch (act) { 237 case DVACT_ACTIVATE: 238 DPRINTFN(1,("umidi_activate (activate)\n")); 239 240 return EOPNOTSUPP; 241 break; 242 case DVACT_DEACTIVATE: 243 DPRINTFN(1,("umidi_activate (deactivate)\n")); 244 sc->sc_dying = 1; 245 deactivate_all_mididevs(sc); 246 break; 247 } 248 return 0; 249 } 250 251 USB_DETACH(umidi) 252 { 253 USB_DETACH_START(umidi, sc); 254 255 DPRINTFN(1,("umidi_detach\n")); 256 257 sc->sc_dying = 1; 258 detach_all_mididevs(sc, flags); 259 free_all_mididevs(sc); 260 free_all_jacks(sc); 261 free_all_endpoints(sc); 262 263 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 264 USBDEV(sc->sc_dev)); 265 266 return 0; 267 } 268 269 270 /* 271 * midi_if stuffs 272 */ 273 int 274 umidi_open(void *addr, 275 int flags, 276 void (*iintr)(void *, int), 277 void (*ointr)(void *), 278 void *arg) 279 { 280 struct umidi_mididev *mididev = addr; 281 struct umidi_softc *sc = mididev->sc; 282 usbd_status err; 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 err = open_out_jack(mididev->out_jack, arg, ointr); 297 if ( err != USBD_NORMAL_COMPLETION ) 298 goto bad; 299 } 300 if ((mididev->flags & FREAD) && mididev->in_jack) { 301 err = open_in_jack(mididev->in_jack, arg, iintr); 302 if ( err != USBD_NORMAL_COMPLETION 303 && err != USBD_IN_PROGRESS ) 304 goto bad; 305 } 306 307 return 0; 308 bad: 309 mididev->opened = 0; 310 DPRINTF(("umidi_open: usbd_status %d\n", err)); 311 return USBD_IN_USE == err ? EBUSY : EIO; 312 } 313 314 void 315 umidi_close(void *addr) 316 { 317 int s; 318 struct umidi_mididev *mididev = addr; 319 320 s = splusb(); 321 if ((mididev->flags & FWRITE) && mididev->out_jack) 322 close_out_jack(mididev->out_jack); 323 if ((mididev->flags & FREAD) && mididev->in_jack) 324 close_in_jack(mididev->in_jack); 325 mididev->opened = 0; 326 splx(s); 327 } 328 329 int 330 umidi_output(void *addr, int d) 331 { 332 struct umidi_mididev *mididev = addr; 333 334 if (!mididev->out_jack || !mididev->opened) 335 return EIO; 336 337 return out_jack_output(mididev->out_jack, d); 338 } 339 340 void 341 umidi_getinfo(void *addr, struct midi_info *mi) 342 { 343 struct umidi_mididev *mididev = addr; 344 /* struct umidi_softc *sc = mididev->sc; */ 345 346 mi->name = "USB MIDI I/F"; /* XXX: model name */ 347 mi->props = MIDI_PROP_OUT_INTR; 348 if (mididev->in_jack) 349 mi->props |= MIDI_PROP_CAN_INPUT; 350 } 351 352 353 /* 354 * each endpoint stuffs 355 */ 356 357 /* alloc/free pipe */ 358 static usbd_status 359 alloc_pipe(struct umidi_endpoint *ep) 360 { 361 struct umidi_softc *sc = ep->sc; 362 usbd_status err; 363 usb_endpoint_descriptor_t *epd; 364 365 if ( UE_DIR_OUT == UE_GET_DIR(ep->addr) ) 366 ep->buffer_size = UMIDI_PACKET_SIZE; 367 else { /* only use wMaxPacketSize on inputs (for now) */ 368 epd = usbd_get_endpoint_descriptor(sc->sc_iface, ep->addr); 369 ep->buffer_size = UGETW(epd->wMaxPacketSize); 370 ep->buffer_size -= ep->buffer_size % UMIDI_PACKET_SIZE; 371 } 372 373 DPRINTF(("%s: alloc_pipe %p, buffer size %u\n", 374 USBDEVNAME(sc->sc_dev), ep, ep->buffer_size)); 375 LIST_INIT(&ep->queue_head); 376 ep->xfer = usbd_alloc_xfer(sc->sc_udev); 377 if (ep->xfer == NULL) { 378 err = USBD_NOMEM; 379 goto quit; 380 } 381 ep->buffer = usbd_alloc_buffer(ep->xfer, ep->buffer_size); 382 if (ep->buffer == NULL) { 383 usbd_free_xfer(ep->xfer); 384 err = USBD_NOMEM; 385 goto quit; 386 } 387 err = usbd_open_pipe(sc->sc_iface, ep->addr, 0, &ep->pipe); 388 if (err) 389 usbd_free_xfer(ep->xfer); 390 quit: 391 return err; 392 } 393 394 static void 395 free_pipe(struct umidi_endpoint *ep) 396 { 397 DPRINTF(("%s: free_pipe %p\n", USBDEVNAME(ep->sc->sc_dev), ep)); 398 usbd_abort_pipe(ep->pipe); 399 usbd_close_pipe(ep->pipe); 400 usbd_free_xfer(ep->xfer); 401 } 402 403 404 /* alloc/free the array of endpoint structures */ 405 406 static usbd_status alloc_all_endpoints_fixed_ep(struct umidi_softc *); 407 static usbd_status alloc_all_endpoints_yamaha(struct umidi_softc *); 408 static usbd_status alloc_all_endpoints_genuine(struct umidi_softc *); 409 410 static usbd_status 411 alloc_all_endpoints(struct umidi_softc *sc) 412 { 413 usbd_status err; 414 struct umidi_endpoint *ep; 415 int i; 416 417 if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) { 418 err = alloc_all_endpoints_fixed_ep(sc); 419 } else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) { 420 err = alloc_all_endpoints_yamaha(sc); 421 } else { 422 err = alloc_all_endpoints_genuine(sc); 423 } 424 if (err!=USBD_NORMAL_COMPLETION) 425 return err; 426 427 ep = sc->sc_endpoints; 428 for (i=sc->sc_out_num_endpoints+sc->sc_in_num_endpoints; i>0; i--) { 429 err = alloc_pipe(ep++); 430 if (err!=USBD_NORMAL_COMPLETION) { 431 for (; ep!=sc->sc_endpoints; ep--) 432 free_pipe(ep-1); 433 free(sc->sc_endpoints, M_USBDEV); 434 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 435 break; 436 } 437 } 438 return err; 439 } 440 441 static void 442 free_all_endpoints(struct umidi_softc *sc) 443 { 444 int i; 445 for (i=0; i<sc->sc_in_num_endpoints+sc->sc_out_num_endpoints; i++) 446 free_pipe(&sc->sc_endpoints[i]); 447 if (sc->sc_endpoints != NULL) 448 free(sc->sc_endpoints, M_USBDEV); 449 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 450 } 451 452 static usbd_status 453 alloc_all_endpoints_fixed_ep(struct umidi_softc *sc) 454 { 455 usbd_status err; 456 struct umq_fixed_ep_desc *fp; 457 struct umidi_endpoint *ep; 458 usb_endpoint_descriptor_t *epd; 459 int i; 460 461 fp = umidi_get_quirk_data_from_type(sc->sc_quirk, 462 UMQ_TYPE_FIXED_EP); 463 sc->sc_out_num_jacks = 0; 464 sc->sc_in_num_jacks = 0; 465 sc->sc_out_num_endpoints = fp->num_out_ep; 466 sc->sc_in_num_endpoints = fp->num_in_ep; 467 sc->sc_endpoints = malloc(sizeof(*sc->sc_out_ep)* 468 (sc->sc_out_num_endpoints+ 469 sc->sc_in_num_endpoints), 470 M_USBDEV, M_WAITOK); 471 if (!sc->sc_endpoints) { 472 return USBD_NOMEM; 473 } 474 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 475 sc->sc_in_ep = 476 sc->sc_in_num_endpoints ? 477 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 478 479 ep = &sc->sc_out_ep[0]; 480 for (i=0; i<sc->sc_out_num_endpoints; i++) { 481 epd = usbd_interface2endpoint_descriptor( 482 sc->sc_iface, 483 fp->out_ep[i].ep); 484 if (!epd) { 485 printf("%s: cannot get endpoint descriptor(out:%d)\n", 486 USBDEVNAME(sc->sc_dev), fp->out_ep[i].ep); 487 err = USBD_INVAL; 488 goto error; 489 } 490 if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK || 491 UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_OUT) { 492 printf("%s: illegal endpoint(out:%d)\n", 493 USBDEVNAME(sc->sc_dev), fp->out_ep[i].ep); 494 err = USBD_INVAL; 495 goto error; 496 } 497 ep->sc = sc; 498 ep->addr = epd->bEndpointAddress; 499 ep->num_jacks = fp->out_ep[i].num_jacks; 500 sc->sc_out_num_jacks += fp->out_ep[i].num_jacks; 501 ep->num_open = 0; 502 memset(ep->jacks, 0, sizeof(ep->jacks)); 503 /* other ep alloc subrs don't, and alloc_pipe does, anyway: */ 504 /* LIST_INIT(&ep->queue_head); */ 505 ep++; 506 } 507 ep = &sc->sc_in_ep[0]; 508 for (i=0; i<sc->sc_in_num_endpoints; i++) { 509 epd = usbd_interface2endpoint_descriptor( 510 sc->sc_iface, 511 fp->in_ep[i].ep); 512 if (!epd) { 513 printf("%s: cannot get endpoint descriptor(in:%d)\n", 514 USBDEVNAME(sc->sc_dev), fp->in_ep[i].ep); 515 err = USBD_INVAL; 516 goto error; 517 } 518 /* 519 * MIDISPORT_2X4 inputs on an interrupt rather than a bulk 520 * endpoint. The existing input logic in this driver seems 521 * to work successfully if we just stop treating an interrupt 522 * endpoint as illegal (or the in_progress status we get on 523 * the initial transfer). It does not seem necessary to 524 * actually use the interrupt flavor of alloc_pipe or make 525 * other serious rearrangements of logic. I like that. 526 */ 527 switch ( UE_GET_XFERTYPE(epd->bmAttributes) ) { 528 case UE_BULK: 529 case UE_INTERRUPT: 530 if ( UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress) ) 531 break; 532 /*FALLTHROUGH*/ 533 default: 534 printf("%s: illegal endpoint(in:%d)\n", 535 USBDEVNAME(sc->sc_dev), fp->in_ep[i].ep); 536 err = USBD_INVAL; 537 goto error; 538 } 539 540 ep->sc = sc; 541 ep->addr = epd->bEndpointAddress; 542 ep->num_jacks = fp->in_ep[i].num_jacks; 543 sc->sc_in_num_jacks += fp->in_ep[i].num_jacks; 544 ep->num_open = 0; 545 memset(ep->jacks, 0, sizeof(ep->jacks)); 546 ep++; 547 } 548 549 return USBD_NORMAL_COMPLETION; 550 error: 551 free(sc->sc_endpoints, M_USBDEV); 552 sc->sc_endpoints = NULL; 553 return err; 554 } 555 556 static usbd_status 557 alloc_all_endpoints_yamaha(struct umidi_softc *sc) 558 { 559 /* This driver currently supports max 1in/1out bulk endpoints */ 560 usb_descriptor_t *desc; 561 usb_endpoint_descriptor_t *epd; 562 int out_addr, in_addr, i; 563 int dir; 564 size_t remain, descsize; 565 566 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 567 out_addr = in_addr = 0; 568 569 /* detect endpoints */ 570 desc = TO_D(usbd_get_interface_descriptor(sc->sc_iface)); 571 for (i=(int)TO_IFD(desc)->bNumEndpoints-1; i>=0; i--) { 572 epd = usbd_interface2endpoint_descriptor(sc->sc_iface, i); 573 if (UE_GET_XFERTYPE(epd->bmAttributes) == UE_BULK) { 574 dir = UE_GET_DIR(epd->bEndpointAddress); 575 if (dir==UE_DIR_OUT && !out_addr) 576 out_addr = epd->bEndpointAddress; 577 else if (dir==UE_DIR_IN && !in_addr) 578 in_addr = epd->bEndpointAddress; 579 } 580 } 581 desc = NEXT_D(desc); 582 583 /* count jacks */ 584 if (!(desc->bDescriptorType==UDESC_CS_INTERFACE && 585 desc->bDescriptorSubtype==UMIDI_MS_HEADER)) 586 return USBD_INVAL; 587 remain = (size_t)UGETW(TO_CSIFD(desc)->wTotalLength) - 588 (size_t)desc->bLength; 589 desc = NEXT_D(desc); 590 591 while (remain>=sizeof(usb_descriptor_t)) { 592 descsize = desc->bLength; 593 if (descsize>remain || descsize==0) 594 break; 595 if (desc->bDescriptorType==UDESC_CS_INTERFACE && 596 remain>=UMIDI_JACK_DESCRIPTOR_SIZE) { 597 if (desc->bDescriptorSubtype==UMIDI_OUT_JACK) 598 sc->sc_out_num_jacks++; 599 else if (desc->bDescriptorSubtype==UMIDI_IN_JACK) 600 sc->sc_in_num_jacks++; 601 } 602 desc = NEXT_D(desc); 603 remain-=descsize; 604 } 605 606 /* validate some parameters */ 607 if (sc->sc_out_num_jacks>UMIDI_MAX_EPJACKS) 608 sc->sc_out_num_jacks = UMIDI_MAX_EPJACKS; 609 if (sc->sc_in_num_jacks>UMIDI_MAX_EPJACKS) 610 sc->sc_in_num_jacks = UMIDI_MAX_EPJACKS; 611 if (sc->sc_out_num_jacks && out_addr) { 612 sc->sc_out_num_endpoints = 1; 613 } else { 614 sc->sc_out_num_endpoints = 0; 615 sc->sc_out_num_jacks = 0; 616 } 617 if (sc->sc_in_num_jacks && in_addr) { 618 sc->sc_in_num_endpoints = 1; 619 } else { 620 sc->sc_in_num_endpoints = 0; 621 sc->sc_in_num_jacks = 0; 622 } 623 sc->sc_endpoints = malloc(sizeof(struct umidi_endpoint)* 624 (sc->sc_out_num_endpoints+ 625 sc->sc_in_num_endpoints), 626 M_USBDEV, M_WAITOK); 627 if (!sc->sc_endpoints) 628 return USBD_NOMEM; 629 if (sc->sc_out_num_endpoints) { 630 sc->sc_out_ep = sc->sc_endpoints; 631 sc->sc_out_ep->sc = sc; 632 sc->sc_out_ep->addr = out_addr; 633 sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks; 634 sc->sc_out_ep->num_open = 0; 635 memset(sc->sc_out_ep->jacks, 0, sizeof(sc->sc_out_ep->jacks)); 636 } else 637 sc->sc_out_ep = NULL; 638 639 if (sc->sc_in_num_endpoints) { 640 sc->sc_in_ep = sc->sc_endpoints+sc->sc_out_num_endpoints; 641 sc->sc_in_ep->sc = sc; 642 sc->sc_in_ep->addr = in_addr; 643 sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks; 644 sc->sc_in_ep->num_open = 0; 645 memset(sc->sc_in_ep->jacks, 0, sizeof(sc->sc_in_ep->jacks)); 646 } else 647 sc->sc_in_ep = NULL; 648 649 return USBD_NORMAL_COMPLETION; 650 } 651 652 static usbd_status 653 alloc_all_endpoints_genuine(struct umidi_softc *sc) 654 { 655 usb_interface_descriptor_t *interface_desc; 656 usb_config_descriptor_t *config_desc; 657 usb_descriptor_t *desc; 658 int num_ep; 659 size_t remain, descsize; 660 struct umidi_endpoint *p, *q, *lowest, *endep, tmpep; 661 int epaddr; 662 663 interface_desc = usbd_get_interface_descriptor(sc->sc_iface); 664 num_ep = interface_desc->bNumEndpoints; 665 sc->sc_endpoints = p = malloc(sizeof(struct umidi_endpoint) * num_ep, 666 M_USBDEV, M_WAITOK); 667 if (!p) 668 return USBD_NOMEM; 669 670 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 671 sc->sc_out_num_endpoints = sc->sc_in_num_endpoints = 0; 672 epaddr = -1; 673 674 /* get the list of endpoints for midi stream */ 675 config_desc = usbd_get_config_descriptor(sc->sc_udev); 676 desc = (usb_descriptor_t *) config_desc; 677 remain = (size_t)UGETW(config_desc->wTotalLength); 678 while (remain>=sizeof(usb_descriptor_t)) { 679 descsize = desc->bLength; 680 if (descsize>remain || descsize==0) 681 break; 682 if (desc->bDescriptorType==UDESC_ENDPOINT && 683 remain>=USB_ENDPOINT_DESCRIPTOR_SIZE && 684 UE_GET_XFERTYPE(TO_EPD(desc)->bmAttributes) == UE_BULK) { 685 epaddr = TO_EPD(desc)->bEndpointAddress; 686 } else if (desc->bDescriptorType==UDESC_CS_ENDPOINT && 687 remain>=UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE && 688 epaddr!=-1) { 689 if (num_ep>0) { 690 num_ep--; 691 p->sc = sc; 692 p->addr = epaddr; 693 p->num_jacks = TO_CSEPD(desc)->bNumEmbMIDIJack; 694 if (UE_GET_DIR(epaddr)==UE_DIR_OUT) { 695 sc->sc_out_num_endpoints++; 696 sc->sc_out_num_jacks += p->num_jacks; 697 } else { 698 sc->sc_in_num_endpoints++; 699 sc->sc_in_num_jacks += p->num_jacks; 700 } 701 p++; 702 } 703 } else 704 epaddr = -1; 705 desc = NEXT_D(desc); 706 remain-=descsize; 707 } 708 709 /* sort endpoints */ 710 num_ep = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints; 711 p = sc->sc_endpoints; 712 endep = p + num_ep; 713 while (p<endep) { 714 lowest = p; 715 for (q=p+1; q<endep; q++) { 716 if ((UE_GET_DIR(lowest->addr)==UE_DIR_IN && 717 UE_GET_DIR(q->addr)==UE_DIR_OUT) || 718 ((UE_GET_DIR(lowest->addr)== 719 UE_GET_DIR(q->addr)) && 720 (UE_GET_ADDR(lowest->addr)> 721 UE_GET_ADDR(q->addr)))) 722 lowest = q; 723 } 724 if (lowest != p) { 725 memcpy((void *)&tmpep, (void *)p, sizeof(tmpep)); 726 memcpy((void *)p, (void *)lowest, sizeof(tmpep)); 727 memcpy((void *)lowest, (void *)&tmpep, sizeof(tmpep)); 728 } 729 p->num_open = 0; 730 p++; 731 } 732 733 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 734 sc->sc_in_ep = 735 sc->sc_in_num_endpoints ? 736 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 737 738 return USBD_NORMAL_COMPLETION; 739 } 740 741 742 /* 743 * jack stuffs 744 */ 745 746 static usbd_status 747 alloc_all_jacks(struct umidi_softc *sc) 748 { 749 int i, j; 750 struct umidi_endpoint *ep; 751 struct umidi_jack *jack, **rjack; 752 753 /* allocate/initialize structures */ 754 sc->sc_jacks = 755 malloc(sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+ 756 sc->sc_out_num_jacks), 757 M_USBDEV, M_WAITOK); 758 if (!sc->sc_jacks) 759 return USBD_NOMEM; 760 sc->sc_out_jacks = 761 sc->sc_out_num_jacks ? sc->sc_jacks : NULL; 762 sc->sc_in_jacks = 763 sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL; 764 765 jack = &sc->sc_out_jacks[0]; 766 for (i=0; i<sc->sc_out_num_jacks; i++) { 767 jack->opened = 0; 768 jack->binded = 0; 769 jack->arg = NULL; 770 jack->u.out.intr = NULL; 771 jack->cable_number = i; 772 jack++; 773 } 774 jack = &sc->sc_in_jacks[0]; 775 for (i=0; i<sc->sc_in_num_jacks; i++) { 776 jack->opened = 0; 777 jack->binded = 0; 778 jack->arg = NULL; 779 jack->u.in.intr = NULL; 780 jack->cable_number = i; 781 jack++; 782 } 783 784 /* assign each jacks to each endpoints */ 785 jack = &sc->sc_out_jacks[0]; 786 ep = &sc->sc_out_ep[0]; 787 for (i=0; i<sc->sc_out_num_endpoints; i++) { 788 rjack = &ep->jacks[0]; 789 for (j=0; j<ep->num_jacks; j++) { 790 *rjack = jack; 791 jack->endpoint = ep; 792 jack++; 793 rjack++; 794 } 795 ep++; 796 } 797 jack = &sc->sc_in_jacks[0]; 798 ep = &sc->sc_in_ep[0]; 799 for (i=0; i<sc->sc_in_num_endpoints; i++) { 800 rjack = &ep->jacks[0]; 801 for (j=0; j<ep->num_jacks; j++) { 802 *rjack = jack; 803 jack->endpoint = ep; 804 jack++; 805 rjack++; 806 } 807 ep++; 808 } 809 810 return USBD_NORMAL_COMPLETION; 811 } 812 813 static void 814 free_all_jacks(struct umidi_softc *sc) 815 { 816 int s; 817 818 s = splaudio(); 819 if (sc->sc_out_jacks) { 820 free(sc->sc_jacks, M_USBDEV); 821 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL; 822 } 823 splx(s); 824 } 825 826 static usbd_status 827 bind_jacks_to_mididev(struct umidi_softc *sc, 828 struct umidi_jack *out_jack, 829 struct umidi_jack *in_jack, 830 struct umidi_mididev *mididev) 831 { 832 if ((out_jack && out_jack->binded) || (in_jack && in_jack->binded)) 833 return USBD_IN_USE; 834 if (mididev->out_jack || mididev->in_jack) 835 return USBD_IN_USE; 836 837 if (out_jack) 838 out_jack->binded = 1; 839 if (in_jack) 840 in_jack->binded = 1; 841 mididev->in_jack = in_jack; 842 mididev->out_jack = out_jack; 843 844 return USBD_NORMAL_COMPLETION; 845 } 846 847 static void 848 unbind_jacks_from_mididev(struct umidi_mididev *mididev) 849 { 850 if ((mididev->flags & FWRITE) && mididev->out_jack) 851 close_out_jack(mididev->out_jack); 852 if ((mididev->flags & FREAD) && mididev->in_jack) 853 close_in_jack(mididev->in_jack); 854 855 if (mididev->out_jack) 856 mididev->out_jack->binded = 0; 857 if (mididev->in_jack) 858 mididev->in_jack->binded = 0; 859 mididev->out_jack = mididev->in_jack = NULL; 860 } 861 862 static void 863 unbind_all_jacks(struct umidi_softc *sc) 864 { 865 int i; 866 867 if (sc->sc_mididevs) 868 for (i=0; i<sc->sc_num_mididevs; i++) { 869 unbind_jacks_from_mididev(&sc->sc_mididevs[i]); 870 } 871 } 872 873 static usbd_status 874 assign_all_jacks_automatically(struct umidi_softc *sc) 875 { 876 usbd_status err; 877 int i; 878 struct umidi_jack *out, *in; 879 880 err = 881 alloc_all_mididevs(sc, 882 max(sc->sc_out_num_jacks, sc->sc_in_num_jacks)); 883 if (err!=USBD_NORMAL_COMPLETION) 884 return err; 885 886 for (i=0; i<sc->sc_num_mididevs; i++) { 887 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i]:NULL; 888 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i]:NULL; 889 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]); 890 if (err!=USBD_NORMAL_COMPLETION) { 891 free_all_mididevs(sc); 892 return err; 893 } 894 } 895 896 return USBD_NORMAL_COMPLETION; 897 } 898 899 static usbd_status 900 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *)) 901 { 902 struct umidi_endpoint *ep = jack->endpoint; 903 904 if (jack->opened) 905 return USBD_IN_USE; 906 907 jack->arg = arg; 908 jack->u.out.intr = intr; 909 init_packet(&jack->packet); 910 jack->opened = 1; 911 ep->num_open++; 912 913 return USBD_NORMAL_COMPLETION; 914 } 915 916 static usbd_status 917 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int)) 918 { 919 usbd_status err = USBD_NORMAL_COMPLETION; 920 struct umidi_endpoint *ep = jack->endpoint; 921 922 if (jack->opened) 923 return USBD_IN_USE; 924 925 jack->arg = arg; 926 jack->u.in.intr = intr; 927 jack->opened = 1; 928 if (ep->num_open++==0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) { 929 err = start_input_transfer(ep); 930 if (err != USBD_NORMAL_COMPLETION && 931 err != USBD_IN_PROGRESS) { 932 ep->num_open--; 933 } 934 } 935 936 return err; 937 } 938 939 static void 940 close_out_jack(struct umidi_jack *jack) 941 { 942 struct umidi_jack *tail; 943 int s; 944 945 if (jack->opened) { 946 s = splusb(); 947 LIST_FOREACH(tail, 948 &jack->endpoint->queue_head, 949 u.out.queue_entry) 950 if (tail == jack) { 951 LIST_REMOVE(jack, u.out.queue_entry); 952 break; 953 } 954 if (jack == jack->endpoint->queue_tail) { 955 /* find tail */ 956 LIST_FOREACH(tail, 957 &jack->endpoint->queue_head, 958 u.out.queue_entry) { 959 if (!LIST_NEXT(tail, u.out.queue_entry)) { 960 jack->endpoint->queue_tail = tail; 961 } 962 } 963 } 964 splx(s); 965 jack->opened = 0; 966 jack->endpoint->num_open--; 967 } 968 } 969 970 static void 971 close_in_jack(struct umidi_jack *jack) 972 { 973 if (jack->opened) { 974 jack->opened = 0; 975 if (--jack->endpoint->num_open == 0) { 976 usbd_abort_pipe(jack->endpoint->pipe); 977 } 978 } 979 } 980 981 static usbd_status 982 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev) 983 { 984 if (mididev->sc) 985 return USBD_IN_USE; 986 987 mididev->sc = sc; 988 989 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, &sc->sc_dev); 990 991 return USBD_NORMAL_COMPLETION; 992 } 993 994 static usbd_status 995 detach_mididev(struct umidi_mididev *mididev, int flags) 996 { 997 if (!mididev->sc) 998 return USBD_NO_ADDR; 999 1000 if (mididev->opened) { 1001 umidi_close(mididev); 1002 } 1003 unbind_jacks_from_mididev(mididev); 1004 1005 if (mididev->mdev) 1006 config_detach(mididev->mdev, flags); 1007 1008 mididev->sc = NULL; 1009 1010 return USBD_NORMAL_COMPLETION; 1011 } 1012 1013 static usbd_status 1014 deactivate_mididev(struct umidi_mididev *mididev) 1015 { 1016 if (mididev->out_jack) 1017 mididev->out_jack->binded = 0; 1018 if (mididev->in_jack) 1019 mididev->in_jack->binded = 0; 1020 config_deactivate(mididev->mdev); 1021 1022 return USBD_NORMAL_COMPLETION; 1023 } 1024 1025 static usbd_status 1026 alloc_all_mididevs(struct umidi_softc *sc, int nmidi) 1027 { 1028 sc->sc_num_mididevs = nmidi; 1029 sc->sc_mididevs = malloc(sizeof(*sc->sc_mididevs)*nmidi, 1030 M_USBDEV, M_WAITOK|M_ZERO); 1031 if (!sc->sc_mididevs) 1032 return USBD_NOMEM; 1033 1034 return USBD_NORMAL_COMPLETION; 1035 } 1036 1037 static void 1038 free_all_mididevs(struct umidi_softc *sc) 1039 { 1040 sc->sc_num_mididevs = 0; 1041 if (sc->sc_mididevs) 1042 free(sc->sc_mididevs, M_USBDEV); 1043 } 1044 1045 static usbd_status 1046 attach_all_mididevs(struct umidi_softc *sc) 1047 { 1048 usbd_status err; 1049 int i; 1050 1051 if (sc->sc_mididevs) 1052 for (i=0; i<sc->sc_num_mididevs; i++) { 1053 err = attach_mididev(sc, &sc->sc_mididevs[i]); 1054 if (err!=USBD_NORMAL_COMPLETION) 1055 return err; 1056 } 1057 1058 return USBD_NORMAL_COMPLETION; 1059 } 1060 1061 static usbd_status 1062 detach_all_mididevs(struct umidi_softc *sc, int flags) 1063 { 1064 usbd_status err; 1065 int i; 1066 1067 if (sc->sc_mididevs) 1068 for (i=0; i<sc->sc_num_mididevs; i++) { 1069 err = detach_mididev(&sc->sc_mididevs[i], flags); 1070 if (err!=USBD_NORMAL_COMPLETION) 1071 return err; 1072 } 1073 1074 return USBD_NORMAL_COMPLETION; 1075 } 1076 1077 static usbd_status 1078 deactivate_all_mididevs(struct umidi_softc *sc) 1079 { 1080 usbd_status err; 1081 int i; 1082 1083 if (sc->sc_mididevs) 1084 for (i=0; i<sc->sc_num_mididevs; i++) { 1085 err = deactivate_mididev(&sc->sc_mididevs[i]); 1086 if (err!=USBD_NORMAL_COMPLETION) 1087 return err; 1088 } 1089 1090 return USBD_NORMAL_COMPLETION; 1091 } 1092 1093 #ifdef UMIDI_DEBUG 1094 static void 1095 dump_sc(struct umidi_softc *sc) 1096 { 1097 int i; 1098 1099 DPRINTFN(10, ("%s: dump_sc\n", USBDEVNAME(sc->sc_dev))); 1100 for (i=0; i<sc->sc_out_num_endpoints; i++) { 1101 DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i])); 1102 dump_ep(&sc->sc_out_ep[i]); 1103 } 1104 for (i=0; i<sc->sc_in_num_endpoints; i++) { 1105 DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i])); 1106 dump_ep(&sc->sc_in_ep[i]); 1107 } 1108 } 1109 1110 static void 1111 dump_ep(struct umidi_endpoint *ep) 1112 { 1113 int i; 1114 for (i=0; i<ep->num_jacks; i++) { 1115 DPRINTFN(10, ("\t\tjack(%p):\n", ep->jacks[i])); 1116 dump_jack(ep->jacks[i]); 1117 } 1118 } 1119 static void 1120 dump_jack(struct umidi_jack *jack) 1121 { 1122 DPRINTFN(10, ("\t\t\tep=%p\n", 1123 jack->endpoint)); 1124 } 1125 1126 #endif /* UMIDI_DEBUG */ 1127 1128 1129 1130 /* 1131 * MUX MIDI PACKET 1132 */ 1133 1134 static const int packet_length[16] = { 1135 /*0*/ -1, 1136 /*1*/ -1, 1137 /*2*/ 2, 1138 /*3*/ 3, 1139 /*4*/ 3, 1140 /*5*/ 1, 1141 /*6*/ 2, 1142 /*7*/ 3, 1143 /*8*/ 3, 1144 /*9*/ 3, 1145 /*A*/ 3, 1146 /*B*/ 3, 1147 /*C*/ 2, 1148 /*D*/ 2, 1149 /*E*/ 3, 1150 /*F*/ 1, 1151 }; 1152 1153 static const struct { 1154 int cin; 1155 packet_state_t next; 1156 } packet_0xFX[16] = { 1157 /* System Common Messages (CIN 0x5 for single byte) */ 1158 /*F0: SysEx */ { 0x04, PS_EXCL_1 }, 1159 /*F1: MTC */ { 0x02, PS_NORMAL_1OF2 }, 1160 /*F2: S.POS */ { 0x03, PS_NORMAL_1OF3 }, 1161 /*F3: S.SEL */ { 0x02, PS_NORMAL_1OF2 }, 1162 /*F4: UNDEF */ { 0x00, PS_INITIAL }, 1163 /*F5: UNDEF */ { 0x00, PS_INITIAL }, 1164 /*F6: Tune */ { 0x05, PS_END }, 1165 /*F7: EofEx */ { 0x00, PS_INITIAL }, 1166 /* System Real-Time Messages (CIN 0xf for single byte) */ 1167 /*F8: Timing */ { 0x0F, PS_END }, 1168 /*F9: UNDEF */ { 0x00, PS_INITIAL }, 1169 /*FA: Start */ { 0x0F, PS_END }, 1170 /*FB: Cont */ { 0x0F, PS_END }, 1171 /*FC: Stop */ { 0x0F, PS_END }, 1172 /*FD: UNDEF */ { 0x00, PS_INITIAL }, 1173 /*FE: ActS */ { 0x0F, PS_END }, 1174 /*FF: Reset */ { 0x0F, PS_END }, 1175 }; 1176 1177 #define GET_CN(p) (((unsigned char)(p)>>4)&0x0F) 1178 #define GET_CIN(p) ((unsigned char)(p)&0x0F) 1179 #define MIX_CN_CIN(cn, cin) \ 1180 ((unsigned char)((((unsigned char)(cn)&0x0F)<<4)| \ 1181 ((unsigned char)(cin)&0x0F))) 1182 1183 static void 1184 init_packet(struct umidi_packet *packet) 1185 { 1186 memset(packet->buffer, 0, UMIDI_PACKET_SIZE); 1187 packet->state = PS_INITIAL; 1188 } 1189 1190 static usbd_status 1191 start_input_transfer(struct umidi_endpoint *ep) 1192 { 1193 usbd_setup_xfer(ep->xfer, ep->pipe, 1194 (usbd_private_handle)ep, 1195 ep->buffer, ep->buffer_size, 1196 USBD_SHORT_XFER_OK | USBD_NO_COPY, 1197 USBD_NO_TIMEOUT, in_intr); 1198 return usbd_transfer(ep->xfer); 1199 } 1200 1201 static usbd_status 1202 start_output_transfer(struct umidi_endpoint *ep) 1203 { 1204 usbd_setup_xfer(ep->xfer, ep->pipe, 1205 (usbd_private_handle)ep, 1206 ep->buffer, UMIDI_PACKET_SIZE, 1207 USBD_NO_COPY, USBD_NO_TIMEOUT, out_intr); 1208 return usbd_transfer(ep->xfer); 1209 } 1210 1211 #ifdef UMIDI_DEBUG 1212 #define DPR_PACKET(dir, sc, p) \ 1213 if ((unsigned char)(p)->buffer[1]!=0xFE) \ 1214 DPRINTFN(500, \ 1215 ("%s: umidi packet(" #dir "): %02X %02X %02X %02X\n", \ 1216 USBDEVNAME(sc->sc_dev), \ 1217 (unsigned char)(p)->buffer[0], \ 1218 (unsigned char)(p)->buffer[1], \ 1219 (unsigned char)(p)->buffer[2], \ 1220 (unsigned char)(p)->buffer[3])); 1221 #else 1222 #define DPR_PACKET(dir, sc, p) 1223 #endif 1224 1225 /* 1226 * A 4-byte Midiman packet superficially resembles a 4-byte USB MIDI packet 1227 * with the cable number and length in the last byte instead of the first, 1228 * but there the resemblance ends. Where a USB MIDI packet is a semantic 1229 * unit, a Midiman packet is just a wrapper for 1 to 3 bytes of raw MIDI 1230 * with a cable nybble and a length nybble (which, unlike the CIN of a 1231 * real USB MIDI packet, has no semantics at all besides the length). 1232 * A packet received from a Midiman may contain part of a MIDI message, 1233 * more than one MIDI message, or parts of more than one MIDI message. A 1234 * three-byte MIDI message may arrive in three packets of data length 1, and 1235 * running status may be used. Happily, the midi(4) driver above us will put 1236 * it all back together, so the only cost is in USB bandwidth. The device 1237 * has an easier time with what it receives from us, as we'll just take 1238 * already formed, semantically reasonable USB MIDI packets and munge them 1239 * into Midiman form. 1240 * 1241 * This function is deliberately call-compatible with memcpy and will 1242 * Midiman-garble any number of packets while copying a region a multiple 1243 * of 4 bytes long. out_build_packet should avoid building any packet with 1244 * CIN of 0 or 1 until they are later defined in the spec and given real 1245 * length values in packet_length. 1246 */ 1247 static void * 1248 midiman_garble( void *dst, const void *src, size_t len) { 1249 unsigned char *cd = dst; 1250 unsigned char const *cs = src; 1251 unsigned char *end = cd + len; 1252 1253 while ( cd < end ) { 1254 cd[3] = (0xf0&*cs) | (packet_length[0x0f&*cs]); 1255 *(cd++) = *(++cs); 1256 *(cd++) = *(++cs); 1257 *(cd++) = *(++cs); 1258 ++cd, ++cs; 1259 } 1260 return dst; 1261 } 1262 1263 static int 1264 out_jack_output(struct umidi_jack *out_jack, int d) 1265 { 1266 struct umidi_endpoint *ep = out_jack->endpoint; 1267 struct umidi_softc *sc = ep->sc; 1268 int error; 1269 int s; 1270 1271 if (sc->sc_dying) 1272 return EIO; 1273 1274 error = 0; 1275 if (out_jack->opened) { 1276 DPRINTFN(1000, ("umidi_output: ep=%p 0x%02x\n", ep, d)); 1277 out_build_packet(out_jack->cable_number, &out_jack->packet, d); 1278 switch (out_jack->packet.state) { 1279 case PS_EXCL_0: 1280 case PS_END: 1281 DPR_PACKET(out, sc, &out_jack->packet); 1282 s = splusb(); 1283 if (LIST_EMPTY(&ep->queue_head)) { 1284 (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE) 1285 ? midiman_garble 1286 : memcpy 1287 ) 1288 (ep->buffer, 1289 out_jack->packet.buffer, 1290 UMIDI_PACKET_SIZE); 1291 start_output_transfer(ep); 1292 } 1293 if (LIST_EMPTY(&ep->queue_head)) 1294 LIST_INSERT_HEAD(&ep->queue_head, 1295 out_jack, u.out.queue_entry); 1296 else 1297 LIST_INSERT_AFTER(ep->queue_tail, 1298 out_jack, u.out.queue_entry); 1299 ep->queue_tail = out_jack; 1300 splx(s); 1301 break; 1302 default: 1303 error = EINPROGRESS; 1304 } 1305 } else 1306 error = ENODEV; 1307 1308 return error; 1309 } 1310 1311 static void 1312 in_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1313 { 1314 int cn, len, i; 1315 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1316 struct umidi_jack *jack; 1317 unsigned char *packet; 1318 unsigned char *end; 1319 unsigned char *data; 1320 u_int32_t count; 1321 1322 if (ep->sc->sc_dying || !ep->num_open) 1323 return; 1324 1325 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1326 if ( 0 == count % UMIDI_PACKET_SIZE ) { 1327 DPRINTFN(100,("%s: input endpoint %p transfer length %u\n", 1328 USBDEVNAME(ep->sc->sc_dev), ep, count)); 1329 } else { 1330 DPRINTF(("%s: input endpoint %p odd transfer length %u\n", 1331 USBDEVNAME(ep->sc->sc_dev), ep, count)); 1332 count -= count % UMIDI_PACKET_SIZE; 1333 } 1334 1335 packet = ep->buffer; 1336 for ( end = packet+count; packet < end; packet += UMIDI_PACKET_SIZE ) { 1337 1338 if ( UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE) ) { 1339 cn = (0xf0&(packet[3]))>>4; 1340 len = 0x0f&(packet[3]); 1341 data = packet; 1342 } else { 1343 cn = GET_CN(packet[0]); 1344 len = packet_length[GET_CIN(packet[0])]; 1345 data = packet + 1; 1346 } 1347 1348 if (cn>=ep->num_jacks || !(jack = ep->jacks[cn])) { 1349 DPRINTF(("%s: stray input endpoint %p cable %d len %d: " 1350 "%02X %02X %02X\n", 1351 USBDEVNAME(ep->sc->sc_dev), ep, cn, len, 1352 (unsigned)data[0], 1353 (unsigned)data[1], 1354 (unsigned)data[2])); 1355 return; 1356 } 1357 1358 if (!jack->binded || !jack->opened) 1359 return; 1360 1361 DPRINTFN(500,("%s: input endpoint %p cable %d len %d: " 1362 "%02X %02X %02X\n", 1363 USBDEVNAME(ep->sc->sc_dev), ep, cn, len, 1364 (unsigned)data[0], 1365 (unsigned)data[1], 1366 (unsigned)data[2])); 1367 1368 if (jack->u.in.intr) { 1369 for (i=0; i<len; i++) { 1370 (*jack->u.in.intr)(jack->arg, data[i]); 1371 } 1372 } 1373 1374 } 1375 1376 (void)start_input_transfer(ep); 1377 } 1378 1379 static void 1380 out_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1381 { 1382 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1383 struct umidi_softc *sc = ep->sc; 1384 struct umidi_jack *jack; 1385 1386 if (sc->sc_dying || !ep->num_open) 1387 return; 1388 1389 jack = LIST_FIRST(&ep->queue_head); 1390 if (jack && jack->opened) { 1391 LIST_REMOVE(jack, u.out.queue_entry); 1392 if (!LIST_EMPTY(&ep->queue_head)) { 1393 (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE) 1394 ? midiman_garble 1395 : memcpy 1396 ) 1397 (ep->buffer, 1398 LIST_FIRST(&ep->queue_head)->packet.buffer, 1399 UMIDI_PACKET_SIZE); 1400 (void)start_output_transfer(ep); 1401 } 1402 if (jack->u.out.intr) { 1403 (*jack->u.out.intr)(jack->arg); 1404 } 1405 } 1406 } 1407 1408 /* 1409 * TODO: allow System Real-Time Messages (of which there are only 8, all 1410 * single byte) to be passed through (in immediate CIN 0xf packets) without 1411 * disturbing the state machine for normal packets or being held up during 1412 * SysEx messages. Will require some extra per-jack state, and pointer to 1413 * jack passed by caller. 1414 * 1415 * Signal error when message byte (other than real-time) is encountered 1416 * when expecting data. Just ignoring the error is bogus. Requires a status 1417 * return to caller. 1418 */ 1419 1420 static void 1421 out_build_packet(int cable_number, struct umidi_packet *packet, uByte in) 1422 { 1423 int cin; 1424 uByte prev; 1425 1426 retry: 1427 switch (packet->state) { 1428 case PS_END: 1429 case PS_INITIAL: 1430 prev = packet->buffer[1]; 1431 memset(packet->buffer, 0, UMIDI_PACKET_SIZE); 1432 if (in<0x80) { 1433 if (prev>=0x80 && prev<0xf0) { 1434 /* running status */ 1435 out_build_packet(cable_number, packet, prev); 1436 goto retry; 1437 } 1438 /* ??? */ 1439 break; 1440 } 1441 if (in>=0xf0) { 1442 cin=packet_0xFX[in&0x0F].cin; 1443 packet->state=packet_0xFX[in&0x0F].next; 1444 } else { 1445 cin=(unsigned char)in>>4; 1446 switch (packet_length[cin]) { 1447 case 2: 1448 packet->state = PS_NORMAL_1OF2; 1449 break; 1450 case 3: 1451 packet->state = PS_NORMAL_1OF3; 1452 break; 1453 default: 1454 /* ??? */ 1455 packet->state = PS_INITIAL; 1456 } 1457 } 1458 packet->buffer[0] = MIX_CN_CIN(cable_number, cin); 1459 packet->buffer[1] = in; 1460 break; 1461 case PS_NORMAL_1OF3: 1462 if (in>=0x80) { /* ??? */ packet->state = PS_END; break; } 1463 packet->buffer[2] = in; 1464 packet->state = PS_NORMAL_2OF3; 1465 break; 1466 case PS_NORMAL_2OF3: 1467 if (in>=0x80) { /* ??? */ packet->state = PS_END; break; } 1468 packet->buffer[3] = in; 1469 packet->state = PS_END; 1470 break; 1471 case PS_NORMAL_1OF2: 1472 if (in>=0x80) { /* ??? */ packet->state = PS_END; break; } 1473 packet->buffer[2] = in; 1474 packet->state = PS_END; 1475 break; 1476 case PS_EXCL_0: 1477 memset(packet->buffer, 0, UMIDI_PACKET_SIZE); 1478 if (in==0xF7) { 1479 packet->buffer[0] = MIX_CN_CIN(cable_number, 0x05); 1480 packet->buffer[1] = 0xF7; 1481 packet->state = PS_END; 1482 break; 1483 } 1484 if (in>=0x80) { /* ??? */ packet->state = PS_END; break; } 1485 packet->buffer[1] = in; 1486 packet->state = PS_EXCL_1; 1487 break; 1488 case PS_EXCL_1: 1489 if (in==0xF7) { 1490 packet->buffer[0] = MIX_CN_CIN(cable_number, 0x06); 1491 packet->buffer[2] = 0xF7; 1492 packet->state = PS_END; 1493 break; 1494 } 1495 if (in>=0x80) { /* ??? */ packet->state = PS_END; break; } 1496 packet->buffer[2] = in; 1497 packet->state = PS_EXCL_2; 1498 break; 1499 case PS_EXCL_2: 1500 if (in==0xF7) { 1501 packet->buffer[0] = MIX_CN_CIN(cable_number, 0x07); 1502 packet->buffer[3] = 0xF7; 1503 packet->state = PS_END; 1504 break; 1505 } 1506 if (in>=0x80) { /* ??? */ packet->state = PS_END; break; } 1507 packet->buffer[0] = MIX_CN_CIN(cable_number, 0x04); 1508 packet->buffer[3] = in; 1509 packet->state = PS_EXCL_0; 1510 break; 1511 default: 1512 printf("umidi: ambiguous state.\n"); 1513 packet->state = PS_INITIAL; 1514 goto retry; 1515 } 1516 } 1517 1518
Indexes created Thu Oct 02 14:10:14 GMT 2025