umidi.c revision 1.25.2.16
1 /* $NetBSD: umidi.c,v 1.25.2.16 2006/05/29 20:36:09 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) and (full-size transfers, extended 8 * hw_if) Chapman Flack (chap (at) NetBSD.org). 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: umidi.c,v 1.25.2.16 2006/05/29 20:36:09 chap Exp $"); 41 42 #include <sys/types.h> 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/malloc.h> 47 #include <sys/device.h> 48 #include <sys/ioctl.h> 49 #include <sys/conf.h> 50 #include <sys/file.h> 51 #include <sys/select.h> 52 #include <sys/proc.h> 53 #include <sys/vnode.h> 54 #include <sys/poll.h> 55 #include <sys/lock.h> 56 57 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS 58 #include <machine/intr.h> 59 #endif 60 61 #include <dev/usb/usb.h> 62 #include <dev/usb/usbdi.h> 63 #include <dev/usb/usbdi_util.h> 64 65 #include <dev/usb/usbdevs.h> 66 #include <dev/usb/uaudioreg.h> 67 #include <dev/usb/umidireg.h> 68 #include <dev/usb/umidivar.h> 69 #include <dev/usb/umidi_quirks.h> 70 71 #include <dev/midi_if.h> 72 73 #ifdef UMIDI_DEBUG 74 #define DPRINTF(x) if (umididebug) printf x 75 #define DPRINTFN(n,x) if (umididebug >= (n)) printf x 76 #include <sys/time.h> 77 static struct timeval umidi_tv; 78 int umididebug = 0; 79 #else 80 #define DPRINTF(x) 81 #define DPRINTFN(n,x) 82 #endif 83 84 85 static int umidi_open(void *, int, 86 void (*)(void *, int), void (*)(void *), void *); 87 static void umidi_close(void *); 88 static int umidi_channelmsg(void *, int, int, u_char *, int); 89 static int umidi_commonmsg(void *, int, u_char *, int); 90 static int umidi_sysex(void *, u_char *, int); 91 static int umidi_rtmsg(void *, int); 92 static void umidi_getinfo(void *, struct midi_info *); 93 94 static usbd_status alloc_pipe(struct umidi_endpoint *); 95 static void free_pipe(struct umidi_endpoint *); 96 97 static usbd_status alloc_all_endpoints(struct umidi_softc *); 98 static void free_all_endpoints(struct umidi_softc *); 99 100 static usbd_status alloc_all_jacks(struct umidi_softc *); 101 static void free_all_jacks(struct umidi_softc *); 102 static usbd_status bind_jacks_to_mididev(struct umidi_softc *, 103 struct umidi_jack *, 104 struct umidi_jack *, 105 struct umidi_mididev *); 106 static void unbind_jacks_from_mididev(struct umidi_mididev *); 107 static void unbind_all_jacks(struct umidi_softc *); 108 static usbd_status assign_all_jacks_automatically(struct umidi_softc *); 109 static usbd_status open_out_jack(struct umidi_jack *, void *, 110 void (*)(void *)); 111 static usbd_status open_in_jack(struct umidi_jack *, void *, 112 void (*)(void *, int)); 113 static void close_out_jack(struct umidi_jack *); 114 static void close_in_jack(struct umidi_jack *); 115 116 static usbd_status attach_mididev(struct umidi_softc *, 117 struct umidi_mididev *); 118 static usbd_status detach_mididev(struct umidi_mididev *, int); 119 static usbd_status deactivate_mididev(struct umidi_mididev *); 120 static usbd_status alloc_all_mididevs(struct umidi_softc *, int); 121 static void free_all_mididevs(struct umidi_softc *); 122 static usbd_status attach_all_mididevs(struct umidi_softc *); 123 static usbd_status detach_all_mididevs(struct umidi_softc *, int); 124 static usbd_status deactivate_all_mididevs(struct umidi_softc *); 125 126 #ifdef UMIDI_DEBUG 127 static void dump_sc(struct umidi_softc *); 128 static void dump_ep(struct umidi_endpoint *); 129 static void dump_jack(struct umidi_jack *); 130 #endif 131 132 static usbd_status start_input_transfer(struct umidi_endpoint *); 133 static usbd_status start_output_transfer(struct umidi_endpoint *); 134 static int out_jack_output(struct umidi_jack *, u_char *, int, int); 135 static void in_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); 136 static void out_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); 137 static void out_solicit(void *); /* struct umidi_endpoint* for softintr */ 138 139 140 const struct midi_hw_if umidi_hw_if = { 141 umidi_open, 142 umidi_close, 143 umidi_rtmsg, 144 umidi_getinfo, 145 0, /* ioctl */ 146 }; 147 148 struct midi_hw_if_ext umidi_hw_if_ext = { 149 .channel = umidi_channelmsg, 150 .common = umidi_commonmsg, 151 .sysex = umidi_sysex, 152 }; 153 154 USB_DECLARE_DRIVER(umidi); 155 156 USB_MATCH(umidi) 157 { 158 USB_MATCH_START(umidi, uaa); 159 usb_interface_descriptor_t *id; 160 161 DPRINTFN(1,("umidi_match\n")); 162 163 if (uaa->iface == NULL) 164 return UMATCH_NONE; 165 166 if (umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno)) 167 return UMATCH_IFACECLASS_IFACESUBCLASS; 168 169 id = usbd_get_interface_descriptor(uaa->iface); 170 if (id!=NULL && 171 id->bInterfaceClass==UICLASS_AUDIO && 172 id->bInterfaceSubClass==UISUBCLASS_MIDISTREAM) 173 return UMATCH_IFACECLASS_IFACESUBCLASS; 174 175 return UMATCH_NONE; 176 } 177 178 USB_ATTACH(umidi) 179 { 180 usbd_status err; 181 USB_ATTACH_START(umidi, sc, uaa); 182 char *devinfop; 183 184 DPRINTFN(1,("umidi_attach\n")); 185 186 devinfop = usbd_devinfo_alloc(uaa->device, 0); 187 printf("\n%s: %s\n", USBDEVNAME(sc->sc_dev), devinfop); 188 usbd_devinfo_free(devinfop); 189 190 sc->sc_iface = uaa->iface; 191 sc->sc_udev = uaa->device; 192 193 sc->sc_quirk = 194 umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno); 195 printf("%s: ", USBDEVNAME(sc->sc_dev)); 196 umidi_print_quirk(sc->sc_quirk); 197 198 199 err = alloc_all_endpoints(sc); 200 if (err!=USBD_NORMAL_COMPLETION) { 201 printf("%s: alloc_all_endpoints failed. (err=%d)\n", 202 USBDEVNAME(sc->sc_dev), err); 203 goto error; 204 } 205 err = alloc_all_jacks(sc); 206 if (err!=USBD_NORMAL_COMPLETION) { 207 free_all_endpoints(sc); 208 printf("%s: alloc_all_jacks failed. (err=%d)\n", 209 USBDEVNAME(sc->sc_dev), err); 210 goto error; 211 } 212 printf("%s: out=%d, in=%d\n", 213 USBDEVNAME(sc->sc_dev), 214 sc->sc_out_num_jacks, sc->sc_in_num_jacks); 215 216 err = assign_all_jacks_automatically(sc); 217 if (err!=USBD_NORMAL_COMPLETION) { 218 unbind_all_jacks(sc); 219 free_all_jacks(sc); 220 free_all_endpoints(sc); 221 printf("%s: assign_all_jacks_automatically failed. (err=%d)\n", 222 USBDEVNAME(sc->sc_dev), err); 223 goto error; 224 } 225 err = attach_all_mididevs(sc); 226 if (err!=USBD_NORMAL_COMPLETION) { 227 free_all_jacks(sc); 228 free_all_endpoints(sc); 229 printf("%s: attach_all_mididevs failed. (err=%d)\n", 230 USBDEVNAME(sc->sc_dev), err); 231 } 232 233 #ifdef UMIDI_DEBUG 234 dump_sc(sc); 235 #endif 236 237 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, 238 sc->sc_udev, USBDEV(sc->sc_dev)); 239 240 USB_ATTACH_SUCCESS_RETURN; 241 error: 242 printf("%s: disabled.\n", USBDEVNAME(sc->sc_dev)); 243 sc->sc_dying = 1; 244 USB_ATTACH_ERROR_RETURN; 245 } 246 247 int 248 umidi_activate(device_ptr_t self, enum devact act) 249 { 250 struct umidi_softc *sc = (struct umidi_softc *)self; 251 252 switch (act) { 253 case DVACT_ACTIVATE: 254 DPRINTFN(1,("umidi_activate (activate)\n")); 255 256 return EOPNOTSUPP; 257 break; 258 case DVACT_DEACTIVATE: 259 DPRINTFN(1,("umidi_activate (deactivate)\n")); 260 sc->sc_dying = 1; 261 deactivate_all_mididevs(sc); 262 break; 263 } 264 return 0; 265 } 266 267 USB_DETACH(umidi) 268 { 269 USB_DETACH_START(umidi, sc); 270 271 DPRINTFN(1,("umidi_detach\n")); 272 273 sc->sc_dying = 1; 274 detach_all_mididevs(sc, flags); 275 free_all_mididevs(sc); 276 free_all_jacks(sc); 277 free_all_endpoints(sc); 278 279 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 280 USBDEV(sc->sc_dev)); 281 282 return 0; 283 } 284 285 286 /* 287 * midi_if stuffs 288 */ 289 int 290 umidi_open(void *addr, 291 int flags, 292 void (*iintr)(void *, int), 293 void (*ointr)(void *), 294 void *arg) 295 { 296 struct umidi_mididev *mididev = addr; 297 struct umidi_softc *sc = mididev->sc; 298 usbd_status err; 299 300 DPRINTF(("umidi_open: sc=%p\n", sc)); 301 302 if (!sc) 303 return ENXIO; 304 if (mididev->opened) 305 return EBUSY; 306 if (sc->sc_dying) 307 return EIO; 308 309 mididev->opened = 1; 310 mididev->flags = flags; 311 if ((mididev->flags & FWRITE) && mididev->out_jack) { 312 err = open_out_jack(mididev->out_jack, arg, ointr); 313 if ( err != USBD_NORMAL_COMPLETION ) 314 goto bad; 315 } 316 if ((mididev->flags & FREAD) && mididev->in_jack) { 317 err = open_in_jack(mididev->in_jack, arg, iintr); 318 if ( err != USBD_NORMAL_COMPLETION 319 && err != USBD_IN_PROGRESS ) 320 goto bad; 321 } 322 323 return 0; 324 bad: 325 mididev->opened = 0; 326 DPRINTF(("umidi_open: usbd_status %d\n", err)); 327 return USBD_IN_USE == err ? EBUSY : EIO; 328 } 329 330 void 331 umidi_close(void *addr) 332 { 333 int s; 334 struct umidi_mididev *mididev = addr; 335 336 s = splusb(); 337 if ((mididev->flags & FWRITE) && mididev->out_jack) 338 close_out_jack(mididev->out_jack); 339 if ((mididev->flags & FREAD) && mididev->in_jack) 340 close_in_jack(mididev->in_jack); 341 mididev->opened = 0; 342 splx(s); 343 } 344 345 int 346 umidi_channelmsg(void *addr, int status, int channel, u_char *msg, int len) 347 { 348 struct umidi_mididev *mididev = addr; 349 350 if (!mididev->out_jack || !mididev->opened) 351 return EIO; 352 353 return out_jack_output(mididev->out_jack, msg, len, (status>>4)&0xf); 354 } 355 356 int 357 umidi_commonmsg(void *addr, int status, u_char *msg, int len) 358 { 359 struct umidi_mididev *mididev = addr; 360 int cin; 361 362 if (!mididev->out_jack || !mididev->opened) 363 return EIO; 364 365 switch ( len ) { 366 case 1: cin = 5; break; 367 case 2: cin = 2; break; 368 case 3: cin = 3; break; 369 default: return EIO; /* or gcc warns of cin uninitialized */ 370 } 371 372 return out_jack_output(mididev->out_jack, msg, len, cin); 373 } 374 375 int 376 umidi_sysex(void *addr, u_char *msg, int len) 377 { 378 struct umidi_mididev *mididev = addr; 379 int cin; 380 381 if (!mididev->out_jack || !mididev->opened) 382 return EIO; 383 384 switch ( len ) { 385 case 1: cin = 5; break; 386 case 2: cin = 6; break; 387 case 3: cin = (msg[2] == 0xf7) ? 7 : 4; break; 388 default: return EIO; /* or gcc warns of cin uninitialized */ 389 } 390 391 return out_jack_output(mididev->out_jack, msg, len, cin); 392 } 393 394 int 395 umidi_rtmsg(void *addr, int d) 396 { 397 struct umidi_mididev *mididev = addr; 398 u_char msg = d; 399 400 if (!mididev->out_jack || !mididev->opened) 401 return EIO; 402 403 return out_jack_output(mididev->out_jack, &msg, 1, 0xf); 404 } 405 406 void 407 umidi_getinfo(void *addr, struct midi_info *mi) 408 { 409 struct umidi_mididev *mididev = addr; 410 /* struct umidi_softc *sc = mididev->sc; */ 411 412 mi->name = "USB MIDI I/F"; /* XXX: model name */ 413 mi->props = MIDI_PROP_OUT_INTR; 414 if (mididev->in_jack) 415 mi->props |= MIDI_PROP_CAN_INPUT; 416 midi_register_hw_if_ext(&umidi_hw_if_ext); 417 } 418 419 420 /* 421 * each endpoint stuffs 422 */ 423 424 /* alloc/free pipe */ 425 static usbd_status 426 alloc_pipe(struct umidi_endpoint *ep) 427 { 428 struct umidi_softc *sc = ep->sc; 429 usbd_status err; 430 usb_endpoint_descriptor_t *epd; 431 432 epd = usbd_get_endpoint_descriptor(sc->sc_iface, ep->addr); 433 /* 434 * For output, an improvement would be to have a buffer bigger than 435 * wMaxPacketSize by num_jacks-1 additional packet slots; that would 436 * allow out_solicit to fill the buffer to the full packet size in 437 * all cases. But to use usbd_alloc_buffer to get a slightly larger 438 * buffer would not be a good way to do that, because if the addition 439 * would make the buffer exceed USB_MEM_SMALL then a substantially 440 * larger block may be wastefully allocated. Some flavor of double 441 * buffering could serve the same purpose, but would increase the 442 * code complexity, so for now I will live with the current slight 443 * penalty of reducing max transfer size by (num_open-num_scheduled) 444 * packet slots. 445 */ 446 ep->buffer_size = UGETW(epd->wMaxPacketSize); 447 ep->buffer_size -= ep->buffer_size % UMIDI_PACKET_SIZE; 448 449 DPRINTF(("%s: alloc_pipe %p, buffer size %u\n", 450 USBDEVNAME(sc->sc_dev), ep, ep->buffer_size)); 451 ep->num_scheduled = 0; 452 ep->this_schedule = 0; 453 ep->next_schedule = 0; 454 ep->soliciting = 0; 455 ep->armed = 0; 456 ep->xfer = usbd_alloc_xfer(sc->sc_udev); 457 if (ep->xfer == NULL) { 458 err = USBD_NOMEM; 459 goto quit; 460 } 461 ep->buffer = usbd_alloc_buffer(ep->xfer, ep->buffer_size); 462 if (ep->buffer == NULL) { 463 usbd_free_xfer(ep->xfer); 464 err = USBD_NOMEM; 465 goto quit; 466 } 467 ep->next_slot = ep->buffer; 468 err = usbd_open_pipe(sc->sc_iface, ep->addr, 0, &ep->pipe); 469 if (err) 470 usbd_free_xfer(ep->xfer); 471 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS 472 ep->solicit_cookie = softintr_establish(IPL_SOFTCLOCK,out_solicit,ep); 473 #endif 474 quit: 475 return err; 476 } 477 478 static void 479 free_pipe(struct umidi_endpoint *ep) 480 { 481 DPRINTF(("%s: free_pipe %p\n", USBDEVNAME(ep->sc->sc_dev), ep)); 482 usbd_abort_pipe(ep->pipe); 483 usbd_close_pipe(ep->pipe); 484 usbd_free_xfer(ep->xfer); 485 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS 486 softintr_disestablish(ep->solicit_cookie); 487 #endif 488 } 489 490 491 /* alloc/free the array of endpoint structures */ 492 493 static usbd_status alloc_all_endpoints_fixed_ep(struct umidi_softc *); 494 static usbd_status alloc_all_endpoints_yamaha(struct umidi_softc *); 495 static usbd_status alloc_all_endpoints_genuine(struct umidi_softc *); 496 497 static usbd_status 498 alloc_all_endpoints(struct umidi_softc *sc) 499 { 500 usbd_status err; 501 struct umidi_endpoint *ep; 502 int i; 503 504 if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) { 505 err = alloc_all_endpoints_fixed_ep(sc); 506 } else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) { 507 err = alloc_all_endpoints_yamaha(sc); 508 } else { 509 err = alloc_all_endpoints_genuine(sc); 510 } 511 if (err!=USBD_NORMAL_COMPLETION) 512 return err; 513 514 ep = sc->sc_endpoints; 515 for (i=sc->sc_out_num_endpoints+sc->sc_in_num_endpoints; i>0; i--) { 516 err = alloc_pipe(ep++); 517 if (err!=USBD_NORMAL_COMPLETION) { 518 for (; ep!=sc->sc_endpoints; ep--) 519 free_pipe(ep-1); 520 free(sc->sc_endpoints, M_USBDEV); 521 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 522 break; 523 } 524 } 525 return err; 526 } 527 528 static void 529 free_all_endpoints(struct umidi_softc *sc) 530 { 531 int i; 532 for (i=0; i<sc->sc_in_num_endpoints+sc->sc_out_num_endpoints; i++) 533 free_pipe(&sc->sc_endpoints[i]); 534 if (sc->sc_endpoints != NULL) 535 free(sc->sc_endpoints, M_USBDEV); 536 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 537 } 538 539 static usbd_status 540 alloc_all_endpoints_fixed_ep(struct umidi_softc *sc) 541 { 542 usbd_status err; 543 struct umq_fixed_ep_desc *fp; 544 struct umidi_endpoint *ep; 545 usb_endpoint_descriptor_t *epd; 546 int i; 547 548 fp = umidi_get_quirk_data_from_type(sc->sc_quirk, 549 UMQ_TYPE_FIXED_EP); 550 sc->sc_out_num_jacks = 0; 551 sc->sc_in_num_jacks = 0; 552 sc->sc_out_num_endpoints = fp->num_out_ep; 553 sc->sc_in_num_endpoints = fp->num_in_ep; 554 sc->sc_endpoints = malloc(sizeof(*sc->sc_out_ep)* 555 (sc->sc_out_num_endpoints+ 556 sc->sc_in_num_endpoints), 557 M_USBDEV, M_WAITOK); 558 if (!sc->sc_endpoints) { 559 return USBD_NOMEM; 560 } 561 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 562 sc->sc_in_ep = 563 sc->sc_in_num_endpoints ? 564 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 565 566 ep = &sc->sc_out_ep[0]; 567 for (i=0; i<sc->sc_out_num_endpoints; i++) { 568 epd = usbd_interface2endpoint_descriptor( 569 sc->sc_iface, 570 fp->out_ep[i].ep); 571 if (!epd) { 572 printf("%s: cannot get endpoint descriptor(out:%d)\n", 573 USBDEVNAME(sc->sc_dev), fp->out_ep[i].ep); 574 err = USBD_INVAL; 575 goto error; 576 } 577 if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK || 578 UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_OUT) { 579 printf("%s: illegal endpoint(out:%d)\n", 580 USBDEVNAME(sc->sc_dev), fp->out_ep[i].ep); 581 err = USBD_INVAL; 582 goto error; 583 } 584 ep->sc = sc; 585 ep->addr = epd->bEndpointAddress; 586 ep->num_jacks = fp->out_ep[i].num_jacks; 587 sc->sc_out_num_jacks += fp->out_ep[i].num_jacks; 588 ep->num_open = 0; 589 memset(ep->jacks, 0, sizeof(ep->jacks)); 590 ep++; 591 } 592 ep = &sc->sc_in_ep[0]; 593 for (i=0; i<sc->sc_in_num_endpoints; i++) { 594 epd = usbd_interface2endpoint_descriptor( 595 sc->sc_iface, 596 fp->in_ep[i].ep); 597 if (!epd) { 598 printf("%s: cannot get endpoint descriptor(in:%d)\n", 599 USBDEVNAME(sc->sc_dev), fp->in_ep[i].ep); 600 err = USBD_INVAL; 601 goto error; 602 } 603 /* 604 * MIDISPORT_2X4 inputs on an interrupt rather than a bulk 605 * endpoint. The existing input logic in this driver seems 606 * to work successfully if we just stop treating an interrupt 607 * endpoint as illegal (or the in_progress status we get on 608 * the initial transfer). It does not seem necessary to 609 * actually use the interrupt flavor of alloc_pipe or make 610 * other serious rearrangements of logic. I like that. 611 */ 612 switch ( UE_GET_XFERTYPE(epd->bmAttributes) ) { 613 case UE_BULK: 614 case UE_INTERRUPT: 615 if ( UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress) ) 616 break; 617 /*FALLTHROUGH*/ 618 default: 619 printf("%s: illegal endpoint(in:%d)\n", 620 USBDEVNAME(sc->sc_dev), fp->in_ep[i].ep); 621 err = USBD_INVAL; 622 goto error; 623 } 624 625 ep->sc = sc; 626 ep->addr = epd->bEndpointAddress; 627 ep->num_jacks = fp->in_ep[i].num_jacks; 628 sc->sc_in_num_jacks += fp->in_ep[i].num_jacks; 629 ep->num_open = 0; 630 memset(ep->jacks, 0, sizeof(ep->jacks)); 631 ep++; 632 } 633 634 return USBD_NORMAL_COMPLETION; 635 error: 636 free(sc->sc_endpoints, M_USBDEV); 637 sc->sc_endpoints = NULL; 638 return err; 639 } 640 641 static usbd_status 642 alloc_all_endpoints_yamaha(struct umidi_softc *sc) 643 { 644 /* This driver currently supports max 1in/1out bulk endpoints */ 645 usb_descriptor_t *desc; 646 usb_endpoint_descriptor_t *epd; 647 int out_addr, in_addr, i; 648 int dir; 649 size_t remain, descsize; 650 651 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 652 out_addr = in_addr = 0; 653 654 /* detect endpoints */ 655 desc = TO_D(usbd_get_interface_descriptor(sc->sc_iface)); 656 for (i=(int)TO_IFD(desc)->bNumEndpoints-1; i>=0; i--) { 657 epd = usbd_interface2endpoint_descriptor(sc->sc_iface, i); 658 KASSERT(epd != NULL); 659 if (UE_GET_XFERTYPE(epd->bmAttributes) == UE_BULK) { 660 dir = UE_GET_DIR(epd->bEndpointAddress); 661 if (dir==UE_DIR_OUT && !out_addr) 662 out_addr = epd->bEndpointAddress; 663 else if (dir==UE_DIR_IN && !in_addr) 664 in_addr = epd->bEndpointAddress; 665 } 666 } 667 desc = NEXT_D(desc); 668 669 /* count jacks */ 670 if (!(desc->bDescriptorType==UDESC_CS_INTERFACE && 671 desc->bDescriptorSubtype==UMIDI_MS_HEADER)) 672 return USBD_INVAL; 673 remain = (size_t)UGETW(TO_CSIFD(desc)->wTotalLength) - 674 (size_t)desc->bLength; 675 desc = NEXT_D(desc); 676 677 while (remain>=sizeof(usb_descriptor_t)) { 678 descsize = desc->bLength; 679 if (descsize>remain || descsize==0) 680 break; 681 if (desc->bDescriptorType==UDESC_CS_INTERFACE && 682 remain>=UMIDI_JACK_DESCRIPTOR_SIZE) { 683 if (desc->bDescriptorSubtype==UMIDI_OUT_JACK) 684 sc->sc_out_num_jacks++; 685 else if (desc->bDescriptorSubtype==UMIDI_IN_JACK) 686 sc->sc_in_num_jacks++; 687 } 688 desc = NEXT_D(desc); 689 remain-=descsize; 690 } 691 692 /* validate some parameters */ 693 if (sc->sc_out_num_jacks>UMIDI_MAX_EPJACKS) 694 sc->sc_out_num_jacks = UMIDI_MAX_EPJACKS; 695 if (sc->sc_in_num_jacks>UMIDI_MAX_EPJACKS) 696 sc->sc_in_num_jacks = UMIDI_MAX_EPJACKS; 697 if (sc->sc_out_num_jacks && out_addr) { 698 sc->sc_out_num_endpoints = 1; 699 } else { 700 sc->sc_out_num_endpoints = 0; 701 sc->sc_out_num_jacks = 0; 702 } 703 if (sc->sc_in_num_jacks && in_addr) { 704 sc->sc_in_num_endpoints = 1; 705 } else { 706 sc->sc_in_num_endpoints = 0; 707 sc->sc_in_num_jacks = 0; 708 } 709 sc->sc_endpoints = malloc(sizeof(struct umidi_endpoint)* 710 (sc->sc_out_num_endpoints+ 711 sc->sc_in_num_endpoints), 712 M_USBDEV, M_WAITOK); 713 if (!sc->sc_endpoints) 714 return USBD_NOMEM; 715 if (sc->sc_out_num_endpoints) { 716 sc->sc_out_ep = sc->sc_endpoints; 717 sc->sc_out_ep->sc = sc; 718 sc->sc_out_ep->addr = out_addr; 719 sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks; 720 sc->sc_out_ep->num_open = 0; 721 memset(sc->sc_out_ep->jacks, 0, sizeof(sc->sc_out_ep->jacks)); 722 } else 723 sc->sc_out_ep = NULL; 724 725 if (sc->sc_in_num_endpoints) { 726 sc->sc_in_ep = sc->sc_endpoints+sc->sc_out_num_endpoints; 727 sc->sc_in_ep->sc = sc; 728 sc->sc_in_ep->addr = in_addr; 729 sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks; 730 sc->sc_in_ep->num_open = 0; 731 memset(sc->sc_in_ep->jacks, 0, sizeof(sc->sc_in_ep->jacks)); 732 } else 733 sc->sc_in_ep = NULL; 734 735 return USBD_NORMAL_COMPLETION; 736 } 737 738 static usbd_status 739 alloc_all_endpoints_genuine(struct umidi_softc *sc) 740 { 741 usb_interface_descriptor_t *interface_desc; 742 usb_config_descriptor_t *config_desc; 743 usb_descriptor_t *desc; 744 int num_ep; 745 size_t remain, descsize; 746 struct umidi_endpoint *p, *q, *lowest, *endep, tmpep; 747 int epaddr; 748 749 interface_desc = usbd_get_interface_descriptor(sc->sc_iface); 750 num_ep = interface_desc->bNumEndpoints; 751 sc->sc_endpoints = p = malloc(sizeof(struct umidi_endpoint) * num_ep, 752 M_USBDEV, M_WAITOK); 753 if (!p) 754 return USBD_NOMEM; 755 756 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 757 sc->sc_out_num_endpoints = sc->sc_in_num_endpoints = 0; 758 epaddr = -1; 759 760 /* get the list of endpoints for midi stream */ 761 config_desc = usbd_get_config_descriptor(sc->sc_udev); 762 desc = (usb_descriptor_t *) config_desc; 763 remain = (size_t)UGETW(config_desc->wTotalLength); 764 while (remain>=sizeof(usb_descriptor_t)) { 765 descsize = desc->bLength; 766 if (descsize>remain || descsize==0) 767 break; 768 if (desc->bDescriptorType==UDESC_ENDPOINT && 769 remain>=USB_ENDPOINT_DESCRIPTOR_SIZE && 770 UE_GET_XFERTYPE(TO_EPD(desc)->bmAttributes) == UE_BULK) { 771 epaddr = TO_EPD(desc)->bEndpointAddress; 772 } else if (desc->bDescriptorType==UDESC_CS_ENDPOINT && 773 remain>=UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE && 774 epaddr!=-1) { 775 if (num_ep>0) { 776 num_ep--; 777 p->sc = sc; 778 p->addr = epaddr; 779 p->num_jacks = TO_CSEPD(desc)->bNumEmbMIDIJack; 780 if (UE_GET_DIR(epaddr)==UE_DIR_OUT) { 781 sc->sc_out_num_endpoints++; 782 sc->sc_out_num_jacks += p->num_jacks; 783 } else { 784 sc->sc_in_num_endpoints++; 785 sc->sc_in_num_jacks += p->num_jacks; 786 } 787 p++; 788 } 789 } else 790 epaddr = -1; 791 desc = NEXT_D(desc); 792 remain-=descsize; 793 } 794 795 /* sort endpoints */ 796 num_ep = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints; 797 p = sc->sc_endpoints; 798 endep = p + num_ep; 799 while (p<endep) { 800 lowest = p; 801 for (q=p+1; q<endep; q++) { 802 if ((UE_GET_DIR(lowest->addr)==UE_DIR_IN && 803 UE_GET_DIR(q->addr)==UE_DIR_OUT) || 804 ((UE_GET_DIR(lowest->addr)== 805 UE_GET_DIR(q->addr)) && 806 (UE_GET_ADDR(lowest->addr)> 807 UE_GET_ADDR(q->addr)))) 808 lowest = q; 809 } 810 if (lowest != p) { 811 memcpy((void *)&tmpep, (void *)p, sizeof(tmpep)); 812 memcpy((void *)p, (void *)lowest, sizeof(tmpep)); 813 memcpy((void *)lowest, (void *)&tmpep, sizeof(tmpep)); 814 } 815 p->num_open = 0; 816 p++; 817 } 818 819 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 820 sc->sc_in_ep = 821 sc->sc_in_num_endpoints ? 822 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 823 824 return USBD_NORMAL_COMPLETION; 825 } 826 827 828 /* 829 * jack stuffs 830 */ 831 832 static usbd_status 833 alloc_all_jacks(struct umidi_softc *sc) 834 { 835 int i, j; 836 struct umidi_endpoint *ep; 837 struct umidi_jack *jack; 838 int cnglobal; 839 unsigned char *cn_spec; 840 841 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_PER_EP)) 842 cnglobal = 0; 843 else if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_GLOBAL)) 844 cnglobal = 1; 845 else { 846 /* 847 * I don't think this default is correct, but it preserves 848 * the prior behavior of the code. That's why I defined two 849 * complementary quirks. Any device for which the default 850 * behavior is wrong can be made to work by giving it an 851 * explicit quirk, and if a pattern ever develops (as I suspect 852 * it will) that a lot of otherwise standard USB MIDI devices 853 * need the CN_SEQ_PER_EP "quirk," then this default can be 854 * changed to 0, and the only devices that will break are those 855 * listing neither quirk, and they'll easily be fixed by giving 856 * them the CN_SEQ_GLOBAL quirk. 857 */ 858 cnglobal = 1; 859 } 860 861 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_FIXED)) 862 cn_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 863 UMQ_TYPE_CN_FIXED); 864 else 865 cn_spec = NULL; 866 867 /* allocate/initialize structures */ 868 sc->sc_jacks = 869 malloc(sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+ 870 sc->sc_out_num_jacks), 871 M_USBDEV, M_WAITOK); 872 if (!sc->sc_jacks) 873 return USBD_NOMEM; 874 sc->sc_out_jacks = 875 sc->sc_out_num_jacks ? sc->sc_jacks : NULL; 876 sc->sc_in_jacks = 877 sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL; 878 879 jack = &sc->sc_out_jacks[0]; 880 for (i=0; i<sc->sc_out_num_jacks; i++) { 881 jack->opened = 0; 882 jack->binded = 0; 883 jack->arg = NULL; 884 jack->u.out.intr = NULL; 885 jack->midiman_ppkt = NULL; 886 if ( cnglobal ) 887 jack->cable_number = i; 888 jack++; 889 } 890 jack = &sc->sc_in_jacks[0]; 891 for (i=0; i<sc->sc_in_num_jacks; i++) { 892 jack->opened = 0; 893 jack->binded = 0; 894 jack->arg = NULL; 895 jack->u.in.intr = NULL; 896 if ( cnglobal ) 897 jack->cable_number = i; 898 jack++; 899 } 900 901 /* assign each jacks to each endpoints */ 902 jack = &sc->sc_out_jacks[0]; 903 ep = &sc->sc_out_ep[0]; 904 for (i=0; i<sc->sc_out_num_endpoints; i++) { 905 for (j=0; j<ep->num_jacks; j++) { 906 jack->endpoint = ep; 907 if ( cn_spec != NULL ) 908 jack->cable_number = *cn_spec++; 909 else if ( !cnglobal ) 910 jack->cable_number = j; 911 ep->jacks[jack->cable_number] = jack; 912 jack++; 913 } 914 ep++; 915 } 916 jack = &sc->sc_in_jacks[0]; 917 ep = &sc->sc_in_ep[0]; 918 for (i=0; i<sc->sc_in_num_endpoints; i++) { 919 for (j=0; j<ep->num_jacks; j++) { 920 jack->endpoint = ep; 921 if ( cn_spec != NULL ) 922 jack->cable_number = *cn_spec++; 923 else if ( !cnglobal ) 924 jack->cable_number = j; 925 ep->jacks[jack->cable_number] = jack; 926 jack++; 927 } 928 ep++; 929 } 930 931 return USBD_NORMAL_COMPLETION; 932 } 933 934 static void 935 free_all_jacks(struct umidi_softc *sc) 936 { 937 int s; 938 939 s = splaudio(); 940 if (sc->sc_out_jacks) { 941 free(sc->sc_jacks, M_USBDEV); 942 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL; 943 } 944 splx(s); 945 } 946 947 static usbd_status 948 bind_jacks_to_mididev(struct umidi_softc *sc, 949 struct umidi_jack *out_jack, 950 struct umidi_jack *in_jack, 951 struct umidi_mididev *mididev) 952 { 953 if ((out_jack && out_jack->binded) || (in_jack && in_jack->binded)) 954 return USBD_IN_USE; 955 if (mididev->out_jack || mididev->in_jack) 956 return USBD_IN_USE; 957 958 if (out_jack) 959 out_jack->binded = 1; 960 if (in_jack) 961 in_jack->binded = 1; 962 mididev->in_jack = in_jack; 963 mididev->out_jack = out_jack; 964 965 return USBD_NORMAL_COMPLETION; 966 } 967 968 static void 969 unbind_jacks_from_mididev(struct umidi_mididev *mididev) 970 { 971 if ((mididev->flags & FWRITE) && mididev->out_jack) 972 close_out_jack(mididev->out_jack); 973 if ((mididev->flags & FREAD) && mididev->in_jack) 974 close_in_jack(mididev->in_jack); 975 976 if (mididev->out_jack) 977 mididev->out_jack->binded = 0; 978 if (mididev->in_jack) 979 mididev->in_jack->binded = 0; 980 mididev->out_jack = mididev->in_jack = NULL; 981 } 982 983 static void 984 unbind_all_jacks(struct umidi_softc *sc) 985 { 986 int i; 987 988 if (sc->sc_mididevs) 989 for (i=0; i<sc->sc_num_mididevs; i++) { 990 unbind_jacks_from_mididev(&sc->sc_mididevs[i]); 991 } 992 } 993 994 static usbd_status 995 assign_all_jacks_automatically(struct umidi_softc *sc) 996 { 997 usbd_status err; 998 int i; 999 struct umidi_jack *out, *in; 1000 signed char *asg_spec; 1001 1002 err = 1003 alloc_all_mididevs(sc, 1004 max(sc->sc_out_num_jacks, sc->sc_in_num_jacks)); 1005 if (err!=USBD_NORMAL_COMPLETION) 1006 return err; 1007 1008 if ( UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED)) 1009 asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 1010 UMQ_TYPE_MD_FIXED); 1011 else 1012 asg_spec = NULL; 1013 1014 for (i=0; i<sc->sc_num_mididevs; i++) { 1015 if ( asg_spec != NULL ) { 1016 if ( *asg_spec == -1 ) 1017 out = NULL; 1018 else 1019 out = &sc->sc_out_jacks[*asg_spec]; 1020 ++ asg_spec; 1021 if ( *asg_spec == -1 ) 1022 in = NULL; 1023 else 1024 in = &sc->sc_in_jacks[*asg_spec]; 1025 ++ asg_spec; 1026 } else { 1027 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i] 1028 : NULL; 1029 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i] 1030 : NULL; 1031 } 1032 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]); 1033 if (err!=USBD_NORMAL_COMPLETION) { 1034 free_all_mididevs(sc); 1035 return err; 1036 } 1037 } 1038 1039 return USBD_NORMAL_COMPLETION; 1040 } 1041 1042 static usbd_status 1043 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *)) 1044 { 1045 struct umidi_endpoint *ep = jack->endpoint; 1046 umidi_packet_bufp end; 1047 int s; 1048 int err; 1049 1050 if (jack->opened) 1051 return USBD_IN_USE; 1052 1053 jack->arg = arg; 1054 jack->u.out.intr = intr; 1055 jack->midiman_ppkt = NULL; 1056 end = ep->buffer + ep->buffer_size / sizeof *ep->buffer; 1057 s = splusb(); 1058 jack->opened = 1; 1059 ep->num_open++; 1060 /* 1061 * out_solicit maintains an invariant that there will always be 1062 * (num_open - num_scheduled) slots free in the buffer. as we have 1063 * just incremented num_open, the buffer may be too full to satisfy 1064 * the invariant until a transfer completes, for which we must wait. 1065 */ 1066 while ( end - ep->next_slot < ep->num_open - ep->num_scheduled ) { 1067 err = tsleep(ep, PWAIT|PCATCH, "umi op", mstohz(10)); 1068 if ( err ) { 1069 ep->num_open--; 1070 jack->opened = 0; 1071 splx(s); 1072 return USBD_IOERROR; 1073 } 1074 } 1075 splx(s); 1076 1077 return USBD_NORMAL_COMPLETION; 1078 } 1079 1080 static usbd_status 1081 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int)) 1082 { 1083 usbd_status err = USBD_NORMAL_COMPLETION; 1084 struct umidi_endpoint *ep = jack->endpoint; 1085 1086 if (jack->opened) 1087 return USBD_IN_USE; 1088 1089 jack->arg = arg; 1090 jack->u.in.intr = intr; 1091 jack->opened = 1; 1092 if (ep->num_open++==0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) { 1093 err = start_input_transfer(ep); 1094 if (err != USBD_NORMAL_COMPLETION && 1095 err != USBD_IN_PROGRESS) { 1096 ep->num_open--; 1097 } 1098 } 1099 1100 return err; 1101 } 1102 1103 static void 1104 close_out_jack(struct umidi_jack *jack) 1105 { 1106 struct umidi_endpoint *ep; 1107 int s; 1108 u_int16_t mask; 1109 int err; 1110 1111 if (jack->opened) { 1112 ep = jack->endpoint; 1113 mask = 1 << (jack->cable_number); 1114 s = splusb(); 1115 while ( mask & (ep->this_schedule | ep->next_schedule) ) { 1116 err = tsleep(ep, PWAIT|PCATCH, "umi dr", mstohz(10)); 1117 if ( err ) 1118 break; 1119 } 1120 jack->opened = 0; 1121 jack->endpoint->num_open--; 1122 ep->this_schedule &= ~mask; 1123 ep->next_schedule &= ~mask; 1124 splx(s); 1125 } 1126 } 1127 1128 static void 1129 close_in_jack(struct umidi_jack *jack) 1130 { 1131 if (jack->opened) { 1132 jack->opened = 0; 1133 if (--jack->endpoint->num_open == 0) { 1134 usbd_abort_pipe(jack->endpoint->pipe); 1135 } 1136 } 1137 } 1138 1139 static usbd_status 1140 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev) 1141 { 1142 if (mididev->sc) 1143 return USBD_IN_USE; 1144 1145 mididev->sc = sc; 1146 1147 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, &sc->sc_dev); 1148 1149 return USBD_NORMAL_COMPLETION; 1150 } 1151 1152 static usbd_status 1153 detach_mididev(struct umidi_mididev *mididev, int flags) 1154 { 1155 if (!mididev->sc) 1156 return USBD_NO_ADDR; 1157 1158 if (mididev->opened) { 1159 umidi_close(mididev); 1160 } 1161 unbind_jacks_from_mididev(mididev); 1162 1163 if (mididev->mdev) 1164 config_detach(mididev->mdev, flags); 1165 1166 mididev->sc = NULL; 1167 1168 return USBD_NORMAL_COMPLETION; 1169 } 1170 1171 static usbd_status 1172 deactivate_mididev(struct umidi_mididev *mididev) 1173 { 1174 if (mididev->out_jack) 1175 mididev->out_jack->binded = 0; 1176 if (mididev->in_jack) 1177 mididev->in_jack->binded = 0; 1178 config_deactivate(mididev->mdev); 1179 1180 return USBD_NORMAL_COMPLETION; 1181 } 1182 1183 static usbd_status 1184 alloc_all_mididevs(struct umidi_softc *sc, int nmidi) 1185 { 1186 sc->sc_num_mididevs = nmidi; 1187 sc->sc_mididevs = malloc(sizeof(*sc->sc_mididevs)*nmidi, 1188 M_USBDEV, M_WAITOK|M_ZERO); 1189 if (!sc->sc_mididevs) 1190 return USBD_NOMEM; 1191 1192 return USBD_NORMAL_COMPLETION; 1193 } 1194 1195 static void 1196 free_all_mididevs(struct umidi_softc *sc) 1197 { 1198 sc->sc_num_mididevs = 0; 1199 if (sc->sc_mididevs) 1200 free(sc->sc_mididevs, M_USBDEV); 1201 } 1202 1203 static usbd_status 1204 attach_all_mididevs(struct umidi_softc *sc) 1205 { 1206 usbd_status err; 1207 int i; 1208 1209 if (sc->sc_mididevs) 1210 for (i=0; i<sc->sc_num_mididevs; i++) { 1211 err = attach_mididev(sc, &sc->sc_mididevs[i]); 1212 if (err!=USBD_NORMAL_COMPLETION) 1213 return err; 1214 } 1215 1216 return USBD_NORMAL_COMPLETION; 1217 } 1218 1219 static usbd_status 1220 detach_all_mididevs(struct umidi_softc *sc, int flags) 1221 { 1222 usbd_status err; 1223 int i; 1224 1225 if (sc->sc_mididevs) 1226 for (i=0; i<sc->sc_num_mididevs; i++) { 1227 err = detach_mididev(&sc->sc_mididevs[i], flags); 1228 if (err!=USBD_NORMAL_COMPLETION) 1229 return err; 1230 } 1231 1232 return USBD_NORMAL_COMPLETION; 1233 } 1234 1235 static usbd_status 1236 deactivate_all_mididevs(struct umidi_softc *sc) 1237 { 1238 usbd_status err; 1239 int i; 1240 1241 if (sc->sc_mididevs) 1242 for (i=0; i<sc->sc_num_mididevs; i++) { 1243 err = deactivate_mididev(&sc->sc_mididevs[i]); 1244 if (err!=USBD_NORMAL_COMPLETION) 1245 return err; 1246 } 1247 1248 return USBD_NORMAL_COMPLETION; 1249 } 1250 1251 #ifdef UMIDI_DEBUG 1252 static void 1253 dump_sc(struct umidi_softc *sc) 1254 { 1255 int i; 1256 1257 DPRINTFN(10, ("%s: dump_sc\n", USBDEVNAME(sc->sc_dev))); 1258 for (i=0; i<sc->sc_out_num_endpoints; i++) { 1259 DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i])); 1260 dump_ep(&sc->sc_out_ep[i]); 1261 } 1262 for (i=0; i<sc->sc_in_num_endpoints; i++) { 1263 DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i])); 1264 dump_ep(&sc->sc_in_ep[i]); 1265 } 1266 } 1267 1268 static void 1269 dump_ep(struct umidi_endpoint *ep) 1270 { 1271 int i; 1272 for (i=0; i<UMIDI_MAX_EPJACKS; i++) { 1273 if (NULL==ep->jacks[i]) 1274 continue; 1275 DPRINTFN(10, ("\t\tjack[%d]:%p:\n", i, ep->jacks[i])); 1276 dump_jack(ep->jacks[i]); 1277 } 1278 } 1279 static void 1280 dump_jack(struct umidi_jack *jack) 1281 { 1282 DPRINTFN(10, ("\t\t\tep=%p\n", 1283 jack->endpoint)); 1284 } 1285 1286 #endif /* UMIDI_DEBUG */ 1287 1288 1289 1290 /* 1291 * MUX MIDI PACKET 1292 */ 1293 1294 static const int packet_length[16] = { 1295 /*0*/ -1, 1296 /*1*/ -1, 1297 /*2*/ 2, 1298 /*3*/ 3, 1299 /*4*/ 3, 1300 /*5*/ 1, 1301 /*6*/ 2, 1302 /*7*/ 3, 1303 /*8*/ 3, 1304 /*9*/ 3, 1305 /*A*/ 3, 1306 /*B*/ 3, 1307 /*C*/ 2, 1308 /*D*/ 2, 1309 /*E*/ 3, 1310 /*F*/ 1, 1311 }; 1312 1313 #define GET_CN(p) (((unsigned char)(p)>>4)&0x0F) 1314 #define GET_CIN(p) ((unsigned char)(p)&0x0F) 1315 #define MIX_CN_CIN(cn, cin) \ 1316 ((unsigned char)((((unsigned char)(cn)&0x0F)<<4)| \ 1317 ((unsigned char)(cin)&0x0F))) 1318 1319 static usbd_status 1320 start_input_transfer(struct umidi_endpoint *ep) 1321 { 1322 usbd_setup_xfer(ep->xfer, ep->pipe, 1323 (usbd_private_handle)ep, 1324 ep->buffer, ep->buffer_size, 1325 USBD_SHORT_XFER_OK | USBD_NO_COPY, 1326 USBD_NO_TIMEOUT, in_intr); 1327 return usbd_transfer(ep->xfer); 1328 } 1329 1330 static usbd_status 1331 start_output_transfer(struct umidi_endpoint *ep) 1332 { 1333 usbd_status rv; 1334 u_int32_t length; 1335 int i; 1336 1337 length = (ep->next_slot - ep->buffer) * sizeof *ep->buffer; 1338 DPRINTFN(200,("umidi out transfer: start %p end %p length %u\n", 1339 ep->buffer, ep->next_slot, length)); 1340 usbd_setup_xfer(ep->xfer, ep->pipe, 1341 (usbd_private_handle)ep, 1342 ep->buffer, length, 1343 USBD_NO_COPY, USBD_NO_TIMEOUT, out_intr); 1344 rv = usbd_transfer(ep->xfer); 1345 1346 /* 1347 * Once the transfer is scheduled, no more adding to partial 1348 * packets within it. 1349 */ 1350 if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1351 for (i=0; i<UMIDI_MAX_EPJACKS; ++i) 1352 if (NULL != ep->jacks[i]) 1353 ep->jacks[i]->midiman_ppkt = NULL; 1354 } 1355 1356 return rv; 1357 } 1358 1359 #ifdef UMIDI_DEBUG 1360 #define DPR_PACKET(dir, sc, p) \ 1361 if ((unsigned char)(p)[1]!=0xFE) \ 1362 DPRINTFN(500, \ 1363 ("%s: umidi packet(" #dir "): %02X %02X %02X %02X\n", \ 1364 USBDEVNAME(sc->sc_dev), \ 1365 (unsigned char)(p)[0], \ 1366 (unsigned char)(p)[1], \ 1367 (unsigned char)(p)[2], \ 1368 (unsigned char)(p)[3])); 1369 #else 1370 #define DPR_PACKET(dir, sc, p) 1371 #endif 1372 1373 /* 1374 * A 4-byte Midiman packet superficially resembles a 4-byte USB MIDI packet 1375 * with the cable number and length in the last byte instead of the first, 1376 * but there the resemblance ends. Where a USB MIDI packet is a semantic 1377 * unit, a Midiman packet is just a wrapper for 1 to 3 bytes of raw MIDI 1378 * with a cable nybble and a length nybble (which, unlike the CIN of a 1379 * real USB MIDI packet, has no semantics at all besides the length). 1380 * A packet received from a Midiman may contain part of a MIDI message, 1381 * more than one MIDI message, or parts of more than one MIDI message. A 1382 * three-byte MIDI message may arrive in three packets of data length 1, and 1383 * running status may be used. Happily, the midi(4) driver above us will put 1384 * it all back together, so the only cost is in USB bandwidth. The device 1385 * has an easier time with what it receives from us: we'll pack messages in 1386 * and across packets, but filling the packets whenever possible and, 1387 * as midi(4) hands us a complete message at a time, we'll never send one 1388 * in a dribble of short packets. 1389 */ 1390 1391 static int 1392 out_jack_output(struct umidi_jack *out_jack, u_char *src, int len, int cin) 1393 { 1394 struct umidi_endpoint *ep = out_jack->endpoint; 1395 struct umidi_softc *sc = ep->sc; 1396 unsigned char *packet; 1397 int s; 1398 int plen; 1399 int poff; 1400 1401 if (sc->sc_dying) 1402 return EIO; 1403 1404 if (!out_jack->opened) 1405 return ENODEV; /* XXX as it was, is this the right errno? */ 1406 1407 #ifdef UMIDI_DEBUG 1408 if ( umididebug >= 100 ) 1409 microtime(&umidi_tv); 1410 #endif 1411 DPRINTFN(100, ("umidi out: %lu.%06lus ep=%p cn=%d len=%d cin=%#x\n", 1412 umidi_tv.tv_sec%100, umidi_tv.tv_usec, 1413 ep, out_jack->cable_number, len, cin)); 1414 1415 s = splusb(); 1416 packet = *ep->next_slot++; 1417 KASSERT(ep->buffer_size >= 1418 (ep->next_slot - ep->buffer) * sizeof *ep->buffer); 1419 memset(packet, 0, UMIDI_PACKET_SIZE); 1420 if (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1421 if (NULL != out_jack->midiman_ppkt) { /* fill out a prev pkt */ 1422 poff = 0x0f & (out_jack->midiman_ppkt[3]); 1423 plen = 3 - poff; 1424 if (plen > len) 1425 plen = len; 1426 memcpy(out_jack->midiman_ppkt+poff, src, plen); 1427 src += plen; 1428 len -= plen; 1429 plen += poff; 1430 out_jack->midiman_ppkt[3] = 1431 MIX_CN_CIN(out_jack->cable_number, plen); 1432 DPR_PACKET(out+, sc, out_jack->midiman_ppkt); 1433 if (3 == plen) 1434 out_jack->midiman_ppkt = NULL; /* no more */ 1435 } 1436 if (0 == len) 1437 ep->next_slot--; /* won't be needed, nevermind */ 1438 else { 1439 memcpy(packet, src, len); 1440 packet[3] = MIX_CN_CIN(out_jack->cable_number, len); 1441 DPR_PACKET(out, sc, packet); 1442 if (len < 3) 1443 out_jack->midiman_ppkt = packet; 1444 } 1445 } else { /* the nice simple USB class-compliant case */ 1446 packet[0] = MIX_CN_CIN(out_jack->cable_number, cin); 1447 memcpy(packet+1, src, len); 1448 DPR_PACKET(out, sc, packet); 1449 } 1450 ep->next_schedule |= 1<<(out_jack->cable_number); 1451 ++ ep->num_scheduled; 1452 if ( !ep->armed && !ep->soliciting ) { 1453 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS 1454 /* 1455 * It would be bad to call out_solicit directly here (the 1456 * caller need not be reentrant) but a soft interrupt allows 1457 * solicit to run immediately the caller exits its critical 1458 * section, and if the caller has more to write we can get it 1459 * before starting the USB transfer, and send a longer one. 1460 */ 1461 ep->soliciting = 1; 1462 softintr_schedule(ep->solicit_cookie); 1463 #else 1464 /* 1465 * This alternative is a little less desirable, because if the 1466 * writer has several messages to go at once, the first will go 1467 * in a USB frame all to itself, and the rest in a full-size 1468 * transfer one frame later (solicited on the first frame's 1469 * completion interrupt). But it's simple. 1470 */ 1471 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep)); 1472 #endif 1473 } 1474 splx(s); 1475 1476 return 0; 1477 } 1478 1479 static void 1480 in_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1481 { 1482 int cn, len, i; 1483 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1484 struct umidi_jack *jack; 1485 unsigned char *packet; 1486 umidi_packet_bufp slot; 1487 umidi_packet_bufp end; 1488 unsigned char *data; 1489 u_int32_t count; 1490 1491 if (ep->sc->sc_dying || !ep->num_open) 1492 return; 1493 1494 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1495 if ( 0 == count % UMIDI_PACKET_SIZE ) { 1496 DPRINTFN(200,("%s: input endpoint %p transfer length %u\n", 1497 USBDEVNAME(ep->sc->sc_dev), ep, count)); 1498 } else { 1499 DPRINTF(("%s: input endpoint %p odd transfer length %u\n", 1500 USBDEVNAME(ep->sc->sc_dev), ep, count)); 1501 } 1502 1503 slot = ep->buffer; 1504 end = slot + count / sizeof *slot; 1505 1506 for ( packet = *slot; slot < end; packet = *++slot ) { 1507 1508 if ( UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE) ) { 1509 cn = (0xf0&(packet[3]))>>4; 1510 len = 0x0f&(packet[3]); 1511 data = packet; 1512 } else { 1513 cn = GET_CN(packet[0]); 1514 len = packet_length[GET_CIN(packet[0])]; 1515 data = packet + 1; 1516 } 1517 /* 0 <= cn <= 15 by inspection of above code */ 1518 if (!(jack = ep->jacks[cn]) || cn != jack->cable_number) { 1519 DPRINTF(("%s: stray input endpoint %p cable %d len %d: " 1520 "%02X %02X %02X (try CN_SEQ quirk?)\n", 1521 USBDEVNAME(ep->sc->sc_dev), ep, cn, len, 1522 (unsigned)data[0], 1523 (unsigned)data[1], 1524 (unsigned)data[2])); 1525 return; 1526 } 1527 1528 if (!jack->binded || !jack->opened) 1529 continue; 1530 1531 DPRINTFN(500,("%s: input endpoint %p cable %d len %d: " 1532 "%02X %02X %02X\n", 1533 USBDEVNAME(ep->sc->sc_dev), ep, cn, len, 1534 (unsigned)data[0], 1535 (unsigned)data[1], 1536 (unsigned)data[2])); 1537 1538 if (jack->u.in.intr) { 1539 for (i=0; i<len; i++) { 1540 (*jack->u.in.intr)(jack->arg, data[i]); 1541 } 1542 } 1543 1544 } 1545 1546 (void)start_input_transfer(ep); 1547 } 1548 1549 static void 1550 out_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1551 { 1552 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1553 struct umidi_softc *sc = ep->sc; 1554 u_int32_t count; 1555 1556 if (sc->sc_dying) 1557 return; 1558 1559 #ifdef UMIDI_DEBUG 1560 if ( umididebug >= 200 ) 1561 microtime(&umidi_tv); 1562 #endif 1563 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1564 if ( 0 == count % UMIDI_PACKET_SIZE ) { 1565 DPRINTFN(200,("%s: %lu.%06lus out ep %p xfer length %u\n", 1566 USBDEVNAME(ep->sc->sc_dev), 1567 umidi_tv.tv_sec%100, umidi_tv.tv_usec, ep, count)); 1568 } else { 1569 DPRINTF(("%s: output endpoint %p odd transfer length %u\n", 1570 USBDEVNAME(ep->sc->sc_dev), ep, count)); 1571 } 1572 count /= UMIDI_PACKET_SIZE; 1573 1574 /* 1575 * If while the transfer was pending we buffered any new messages, 1576 * move them to the start of the buffer. 1577 */ 1578 ep->next_slot -= count; 1579 if ( ep->buffer < ep->next_slot ) { 1580 memcpy(ep->buffer, ep->buffer + count, 1581 (char *)ep->next_slot - (char *)ep->buffer); 1582 } 1583 wakeup(ep); 1584 /* 1585 * Do not want anyone else to see armed <- 0 before soliciting <- 1. 1586 * Running at splusb so the following should happen to be safe. 1587 */ 1588 ep->armed = 0; 1589 if ( !ep->soliciting ) { 1590 ep->soliciting = 1; 1591 out_solicit(ep); 1592 } 1593 } 1594 1595 /* 1596 * A jack on which we have received a packet must be called back on its 1597 * out.intr handler before it will send us another; it is considered 1598 * 'scheduled'. It is nice and predictable - as long as it is scheduled, 1599 * we need no extra buffer space for it. 1600 * 1601 * In contrast, a jack that is open but not scheduled may supply us a packet 1602 * at any time, driven by the top half, and we must be able to accept it, no 1603 * excuses. So we must ensure that at any point in time there are at least 1604 * (num_open - num_scheduled) slots free. 1605 * 1606 * As long as there are more slots free than that minimum, we can loop calling 1607 * scheduled jacks back on their "interrupt" handlers, soliciting more 1608 * packets, starting the USB transfer only when the buffer space is down to 1609 * the minimum or no jack has any more to send. 1610 */ 1611 static void 1612 out_solicit(void *arg) 1613 { 1614 struct umidi_endpoint *ep = arg; 1615 int s; 1616 umidi_packet_bufp end; 1617 u_int16_t which; 1618 struct umidi_jack *jack; 1619 1620 end = ep->buffer + ep->buffer_size / sizeof *ep->buffer; 1621 1622 for ( ;; ) { 1623 s = splusb(); 1624 if ( end - ep->next_slot <= ep->num_open - ep->num_scheduled ) 1625 break; /* at splusb */ 1626 if ( ep->this_schedule == 0 ) { 1627 if ( ep->next_schedule == 0 ) 1628 break; /* at splusb */ 1629 ep->this_schedule = ep->next_schedule; 1630 ep->next_schedule = 0; 1631 } 1632 /* 1633 * At least one jack is scheduled. Find and mask off the least 1634 * set bit in this_schedule and decrement num_scheduled. 1635 * Convert mask to bit index to find the corresponding jack, 1636 * and call its intr handler. If it has a message, it will call 1637 * back one of the output methods, which will set its bit in 1638 * next_schedule (not copied into this_schedule until the 1639 * latter is empty). In this way we round-robin the jacks that 1640 * have messages to send, until the buffer is as full as we 1641 * dare, and then start a transfer. 1642 */ 1643 which = ep->this_schedule; 1644 which &= (~which)+1; /* now mask of least set bit */ 1645 ep->this_schedule &= ~which; 1646 -- ep->num_scheduled; 1647 splx(s); 1648 1649 -- which; /* now 1s below mask - count 1s to get index */ 1650 which -= ((which >> 1) & 0x5555);/* SWAR credit aggregate.org */ 1651 which = (((which >> 2) & 0x3333) + (which & 0x3333)); 1652 which = (((which >> 4) + which) & 0x0f0f); 1653 which += (which >> 8); 1654 which &= 0x1f; /* the bit index a/k/a jack number */ 1655 1656 jack = ep->jacks[which]; 1657 if (jack->u.out.intr) 1658 (*jack->u.out.intr)(jack->arg); 1659 } 1660 /* splusb at loop exit */ 1661 if ( !ep->armed && ep->next_slot > ep->buffer ) 1662 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep)); 1663 ep->soliciting = 0; 1664 splx(s); 1665 } 1666
Indexes created Fri Oct 03 02:09:57 GMT 2025