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