umidi.c revision 1.25.2.15
1 /* $NetBSD: umidi.c,v 1.25.2.15 2006/05/29 16:54: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) 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.15 2006/05/29 16:54:05 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 if ( cnglobal ) 886 jack->cable_number = i; 887 jack++; 888 } 889 jack = &sc->sc_in_jacks[0]; 890 for (i=0; i<sc->sc_in_num_jacks; i++) { 891 jack->opened = 0; 892 jack->binded = 0; 893 jack->arg = NULL; 894 jack->u.in.intr = NULL; 895 if ( cnglobal ) 896 jack->cable_number = i; 897 jack++; 898 } 899 900 /* assign each jacks to each endpoints */ 901 jack = &sc->sc_out_jacks[0]; 902 ep = &sc->sc_out_ep[0]; 903 for (i=0; i<sc->sc_out_num_endpoints; i++) { 904 for (j=0; j<ep->num_jacks; j++) { 905 jack->endpoint = ep; 906 if ( cn_spec != NULL ) 907 jack->cable_number = *cn_spec++; 908 else if ( !cnglobal ) 909 jack->cable_number = j; 910 ep->jacks[jack->cable_number] = jack; 911 jack++; 912 } 913 ep++; 914 } 915 jack = &sc->sc_in_jacks[0]; 916 ep = &sc->sc_in_ep[0]; 917 for (i=0; i<sc->sc_in_num_endpoints; i++) { 918 for (j=0; j<ep->num_jacks; j++) { 919 jack->endpoint = ep; 920 if ( cn_spec != NULL ) 921 jack->cable_number = *cn_spec++; 922 else if ( !cnglobal ) 923 jack->cable_number = j; 924 ep->jacks[jack->cable_number] = jack; 925 jack++; 926 } 927 ep++; 928 } 929 930 return USBD_NORMAL_COMPLETION; 931 } 932 933 static void 934 free_all_jacks(struct umidi_softc *sc) 935 { 936 int s; 937 938 s = splaudio(); 939 if (sc->sc_out_jacks) { 940 free(sc->sc_jacks, M_USBDEV); 941 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL; 942 } 943 splx(s); 944 } 945 946 static usbd_status 947 bind_jacks_to_mididev(struct umidi_softc *sc, 948 struct umidi_jack *out_jack, 949 struct umidi_jack *in_jack, 950 struct umidi_mididev *mididev) 951 { 952 if ((out_jack && out_jack->binded) || (in_jack && in_jack->binded)) 953 return USBD_IN_USE; 954 if (mididev->out_jack || mididev->in_jack) 955 return USBD_IN_USE; 956 957 if (out_jack) 958 out_jack->binded = 1; 959 if (in_jack) 960 in_jack->binded = 1; 961 mididev->in_jack = in_jack; 962 mididev->out_jack = out_jack; 963 964 return USBD_NORMAL_COMPLETION; 965 } 966 967 static void 968 unbind_jacks_from_mididev(struct umidi_mididev *mididev) 969 { 970 if ((mididev->flags & FWRITE) && mididev->out_jack) 971 close_out_jack(mididev->out_jack); 972 if ((mididev->flags & FREAD) && mididev->in_jack) 973 close_in_jack(mididev->in_jack); 974 975 if (mididev->out_jack) 976 mididev->out_jack->binded = 0; 977 if (mididev->in_jack) 978 mididev->in_jack->binded = 0; 979 mididev->out_jack = mididev->in_jack = NULL; 980 } 981 982 static void 983 unbind_all_jacks(struct umidi_softc *sc) 984 { 985 int i; 986 987 if (sc->sc_mididevs) 988 for (i=0; i<sc->sc_num_mididevs; i++) { 989 unbind_jacks_from_mididev(&sc->sc_mididevs[i]); 990 } 991 } 992 993 static usbd_status 994 assign_all_jacks_automatically(struct umidi_softc *sc) 995 { 996 usbd_status err; 997 int i; 998 struct umidi_jack *out, *in; 999 signed char *asg_spec; 1000 1001 err = 1002 alloc_all_mididevs(sc, 1003 max(sc->sc_out_num_jacks, sc->sc_in_num_jacks)); 1004 if (err!=USBD_NORMAL_COMPLETION) 1005 return err; 1006 1007 if ( UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED)) 1008 asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 1009 UMQ_TYPE_MD_FIXED); 1010 else 1011 asg_spec = NULL; 1012 1013 for (i=0; i<sc->sc_num_mididevs; i++) { 1014 if ( asg_spec != NULL ) { 1015 if ( *asg_spec == -1 ) 1016 out = NULL; 1017 else 1018 out = &sc->sc_out_jacks[*asg_spec]; 1019 ++ asg_spec; 1020 if ( *asg_spec == -1 ) 1021 in = NULL; 1022 else 1023 in = &sc->sc_in_jacks[*asg_spec]; 1024 ++ asg_spec; 1025 } else { 1026 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i] 1027 : NULL; 1028 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i] 1029 : NULL; 1030 } 1031 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]); 1032 if (err!=USBD_NORMAL_COMPLETION) { 1033 free_all_mididevs(sc); 1034 return err; 1035 } 1036 } 1037 1038 return USBD_NORMAL_COMPLETION; 1039 } 1040 1041 static usbd_status 1042 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *)) 1043 { 1044 struct umidi_endpoint *ep = jack->endpoint; 1045 umidi_packet_bufp end; 1046 int s; 1047 int err; 1048 1049 if (jack->opened) 1050 return USBD_IN_USE; 1051 1052 jack->arg = arg; 1053 jack->u.out.intr = intr; 1054 end = ep->buffer + ep->buffer_size / sizeof *ep->buffer; 1055 s = splusb(); 1056 jack->opened = 1; 1057 ep->num_open++; 1058 /* 1059 * out_solicit maintains an invariant that there will always be 1060 * (num_open - num_scheduled) slots free in the buffer. as we have 1061 * just incremented num_open, the buffer may be too full to satisfy 1062 * the invariant until a transfer completes, for which we must wait. 1063 */ 1064 while ( end - ep->next_slot < ep->num_open - ep->num_scheduled ) { 1065 err = tsleep(ep, PWAIT|PCATCH, "umi op", mstohz(10)); 1066 if ( err ) { 1067 ep->num_open--; 1068 jack->opened = 0; 1069 splx(s); 1070 return USBD_IOERROR; 1071 } 1072 } 1073 splx(s); 1074 1075 return USBD_NORMAL_COMPLETION; 1076 } 1077 1078 static usbd_status 1079 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int)) 1080 { 1081 usbd_status err = USBD_NORMAL_COMPLETION; 1082 struct umidi_endpoint *ep = jack->endpoint; 1083 1084 if (jack->opened) 1085 return USBD_IN_USE; 1086 1087 jack->arg = arg; 1088 jack->u.in.intr = intr; 1089 jack->opened = 1; 1090 if (ep->num_open++==0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) { 1091 err = start_input_transfer(ep); 1092 if (err != USBD_NORMAL_COMPLETION && 1093 err != USBD_IN_PROGRESS) { 1094 ep->num_open--; 1095 } 1096 } 1097 1098 return err; 1099 } 1100 1101 static void 1102 close_out_jack(struct umidi_jack *jack) 1103 { 1104 struct umidi_endpoint *ep; 1105 int s; 1106 u_int16_t mask; 1107 int err; 1108 1109 if (jack->opened) { 1110 ep = jack->endpoint; 1111 mask = 1 << (jack->cable_number); 1112 s = splusb(); 1113 while ( mask & (ep->this_schedule | ep->next_schedule) ) { 1114 err = tsleep(ep, PWAIT|PCATCH, "umi dr", mstohz(10)); 1115 if ( err ) 1116 break; 1117 } 1118 jack->opened = 0; 1119 jack->endpoint->num_open--; 1120 ep->this_schedule &= ~mask; 1121 ep->next_schedule &= ~mask; 1122 splx(s); 1123 } 1124 } 1125 1126 static void 1127 close_in_jack(struct umidi_jack *jack) 1128 { 1129 if (jack->opened) { 1130 jack->opened = 0; 1131 if (--jack->endpoint->num_open == 0) { 1132 usbd_abort_pipe(jack->endpoint->pipe); 1133 } 1134 } 1135 } 1136 1137 static usbd_status 1138 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev) 1139 { 1140 if (mididev->sc) 1141 return USBD_IN_USE; 1142 1143 mididev->sc = sc; 1144 1145 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, &sc->sc_dev); 1146 1147 return USBD_NORMAL_COMPLETION; 1148 } 1149 1150 static usbd_status 1151 detach_mididev(struct umidi_mididev *mididev, int flags) 1152 { 1153 if (!mididev->sc) 1154 return USBD_NO_ADDR; 1155 1156 if (mididev->opened) { 1157 umidi_close(mididev); 1158 } 1159 unbind_jacks_from_mididev(mididev); 1160 1161 if (mididev->mdev) 1162 config_detach(mididev->mdev, flags); 1163 1164 mididev->sc = NULL; 1165 1166 return USBD_NORMAL_COMPLETION; 1167 } 1168 1169 static usbd_status 1170 deactivate_mididev(struct umidi_mididev *mididev) 1171 { 1172 if (mididev->out_jack) 1173 mididev->out_jack->binded = 0; 1174 if (mididev->in_jack) 1175 mididev->in_jack->binded = 0; 1176 config_deactivate(mididev->mdev); 1177 1178 return USBD_NORMAL_COMPLETION; 1179 } 1180 1181 static usbd_status 1182 alloc_all_mididevs(struct umidi_softc *sc, int nmidi) 1183 { 1184 sc->sc_num_mididevs = nmidi; 1185 sc->sc_mididevs = malloc(sizeof(*sc->sc_mididevs)*nmidi, 1186 M_USBDEV, M_WAITOK|M_ZERO); 1187 if (!sc->sc_mididevs) 1188 return USBD_NOMEM; 1189 1190 return USBD_NORMAL_COMPLETION; 1191 } 1192 1193 static void 1194 free_all_mididevs(struct umidi_softc *sc) 1195 { 1196 sc->sc_num_mididevs = 0; 1197 if (sc->sc_mididevs) 1198 free(sc->sc_mididevs, M_USBDEV); 1199 } 1200 1201 static usbd_status 1202 attach_all_mididevs(struct umidi_softc *sc) 1203 { 1204 usbd_status err; 1205 int i; 1206 1207 if (sc->sc_mididevs) 1208 for (i=0; i<sc->sc_num_mididevs; i++) { 1209 err = attach_mididev(sc, &sc->sc_mididevs[i]); 1210 if (err!=USBD_NORMAL_COMPLETION) 1211 return err; 1212 } 1213 1214 return USBD_NORMAL_COMPLETION; 1215 } 1216 1217 static usbd_status 1218 detach_all_mididevs(struct umidi_softc *sc, int flags) 1219 { 1220 usbd_status err; 1221 int i; 1222 1223 if (sc->sc_mididevs) 1224 for (i=0; i<sc->sc_num_mididevs; i++) { 1225 err = detach_mididev(&sc->sc_mididevs[i], flags); 1226 if (err!=USBD_NORMAL_COMPLETION) 1227 return err; 1228 } 1229 1230 return USBD_NORMAL_COMPLETION; 1231 } 1232 1233 static usbd_status 1234 deactivate_all_mididevs(struct umidi_softc *sc) 1235 { 1236 usbd_status err; 1237 int i; 1238 1239 if (sc->sc_mididevs) 1240 for (i=0; i<sc->sc_num_mididevs; i++) { 1241 err = deactivate_mididev(&sc->sc_mididevs[i]); 1242 if (err!=USBD_NORMAL_COMPLETION) 1243 return err; 1244 } 1245 1246 return USBD_NORMAL_COMPLETION; 1247 } 1248 1249 #ifdef UMIDI_DEBUG 1250 static void 1251 dump_sc(struct umidi_softc *sc) 1252 { 1253 int i; 1254 1255 DPRINTFN(10, ("%s: dump_sc\n", USBDEVNAME(sc->sc_dev))); 1256 for (i=0; i<sc->sc_out_num_endpoints; i++) { 1257 DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i])); 1258 dump_ep(&sc->sc_out_ep[i]); 1259 } 1260 for (i=0; i<sc->sc_in_num_endpoints; i++) { 1261 DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i])); 1262 dump_ep(&sc->sc_in_ep[i]); 1263 } 1264 } 1265 1266 static void 1267 dump_ep(struct umidi_endpoint *ep) 1268 { 1269 int i; 1270 for (i=0; i<UMIDI_MAX_EPJACKS; i++) { 1271 if (NULL==ep->jacks[i]) 1272 continue; 1273 DPRINTFN(10, ("\t\tjack[%d]:%p:\n", i, ep->jacks[i])); 1274 dump_jack(ep->jacks[i]); 1275 } 1276 } 1277 static void 1278 dump_jack(struct umidi_jack *jack) 1279 { 1280 DPRINTFN(10, ("\t\t\tep=%p\n", 1281 jack->endpoint)); 1282 } 1283 1284 #endif /* UMIDI_DEBUG */ 1285 1286 1287 1288 /* 1289 * MUX MIDI PACKET 1290 */ 1291 1292 static const int packet_length[16] = { 1293 /*0*/ -1, 1294 /*1*/ -1, 1295 /*2*/ 2, 1296 /*3*/ 3, 1297 /*4*/ 3, 1298 /*5*/ 1, 1299 /*6*/ 2, 1300 /*7*/ 3, 1301 /*8*/ 3, 1302 /*9*/ 3, 1303 /*A*/ 3, 1304 /*B*/ 3, 1305 /*C*/ 2, 1306 /*D*/ 2, 1307 /*E*/ 3, 1308 /*F*/ 1, 1309 }; 1310 1311 #define GET_CN(p) (((unsigned char)(p)>>4)&0x0F) 1312 #define GET_CIN(p) ((unsigned char)(p)&0x0F) 1313 #define MIX_CN_CIN(cn, cin) \ 1314 ((unsigned char)((((unsigned char)(cn)&0x0F)<<4)| \ 1315 ((unsigned char)(cin)&0x0F))) 1316 1317 static usbd_status 1318 start_input_transfer(struct umidi_endpoint *ep) 1319 { 1320 usbd_setup_xfer(ep->xfer, ep->pipe, 1321 (usbd_private_handle)ep, 1322 ep->buffer, ep->buffer_size, 1323 USBD_SHORT_XFER_OK | USBD_NO_COPY, 1324 USBD_NO_TIMEOUT, in_intr); 1325 return usbd_transfer(ep->xfer); 1326 } 1327 1328 static usbd_status 1329 start_output_transfer(struct umidi_endpoint *ep) 1330 { 1331 u_int32_t length; 1332 length = (ep->next_slot - ep->buffer) * sizeof *ep->buffer; 1333 DPRINTFN(200,("umidi out transfer: start %p end %p length %u\n", 1334 ep->buffer, ep->next_slot, length)); 1335 usbd_setup_xfer(ep->xfer, ep->pipe, 1336 (usbd_private_handle)ep, 1337 ep->buffer, length, 1338 USBD_NO_COPY, USBD_NO_TIMEOUT, out_intr); 1339 return usbd_transfer(ep->xfer); 1340 } 1341 1342 #ifdef UMIDI_DEBUG 1343 #define DPR_PACKET(dir, sc, p) \ 1344 if ((unsigned char)(p)[1]!=0xFE) \ 1345 DPRINTFN(500, \ 1346 ("%s: umidi packet(" #dir "): %02X %02X %02X %02X\n", \ 1347 USBDEVNAME(sc->sc_dev), \ 1348 (unsigned char)(p)[0], \ 1349 (unsigned char)(p)[1], \ 1350 (unsigned char)(p)[2], \ 1351 (unsigned char)(p)[3])); 1352 #else 1353 #define DPR_PACKET(dir, sc, p) 1354 #endif 1355 1356 /* 1357 * A 4-byte Midiman packet superficially resembles a 4-byte USB MIDI packet 1358 * with the cable number and length in the last byte instead of the first, 1359 * but there the resemblance ends. Where a USB MIDI packet is a semantic 1360 * unit, a Midiman packet is just a wrapper for 1 to 3 bytes of raw MIDI 1361 * with a cable nybble and a length nybble (which, unlike the CIN of a 1362 * real USB MIDI packet, has no semantics at all besides the length). 1363 * A packet received from a Midiman may contain part of a MIDI message, 1364 * more than one MIDI message, or parts of more than one MIDI message. A 1365 * three-byte MIDI message may arrive in three packets of data length 1, and 1366 * running status may be used. Happily, the midi(4) driver above us will put 1367 * it all back together, so the only cost is in USB bandwidth. The device 1368 * has an easier time with what it receives from us, as we'll just take 1369 * already formed, semantically reasonable USB MIDI packets and munge them 1370 * into Midiman form. 1371 */ 1372 1373 static int 1374 out_jack_output(struct umidi_jack *out_jack, u_char *src, int len, int cin) 1375 { 1376 struct umidi_endpoint *ep = out_jack->endpoint; 1377 struct umidi_softc *sc = ep->sc; 1378 unsigned char *packet; 1379 int s; 1380 1381 if (sc->sc_dying) 1382 return EIO; 1383 1384 if (!out_jack->opened) 1385 return ENODEV; /* XXX as it was, is this the right errno? */ 1386 1387 #ifdef UMIDI_DEBUG 1388 if ( umididebug >= 100 ) 1389 microtime(&umidi_tv); 1390 #endif 1391 DPRINTFN(100, ("umidi out: %lu.%06lus ep=%p cn=%d len=%d cin=%#x\n", 1392 umidi_tv.tv_sec%100, umidi_tv.tv_usec, 1393 ep, out_jack->cable_number, len, cin)); 1394 1395 s = splusb(); 1396 packet = *ep->next_slot++; 1397 KASSERT(ep->buffer_size >= 1398 (ep->next_slot - ep->buffer) * sizeof *ep->buffer); 1399 memset(packet, 0, UMIDI_PACKET_SIZE); 1400 if (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE)) { 1401 memcpy(packet, src, len); 1402 packet[3] = MIX_CN_CIN(out_jack->cable_number, len); 1403 } else { 1404 packet[0] = MIX_CN_CIN(out_jack->cable_number, cin); 1405 memcpy(packet+1, src, len); 1406 } 1407 DPR_PACKET(out, sc, packet); 1408 ep->next_schedule |= 1<<(out_jack->cable_number); 1409 ++ ep->num_scheduled; 1410 if ( !ep->armed && !ep->soliciting ) { 1411 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS 1412 /* 1413 * It would be bad to call out_solicit directly here (the 1414 * caller need not be reentrant) but a soft interrupt allows 1415 * solicit to run immediately the caller exits its critical 1416 * section, and if the caller has more to write we can get it 1417 * before starting the USB transfer, and send a longer one. 1418 */ 1419 ep->soliciting = 1; 1420 softintr_schedule(ep->solicit_cookie); 1421 #else 1422 /* 1423 * This alternative is a little less desirable, because if the 1424 * writer has several messages to go at once, the first will go 1425 * in a USB frame all to itself, and the rest in a full-size 1426 * transfer one frame later (solicited on the first frame's 1427 * completion interrupt). But it's simple. 1428 */ 1429 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep)); 1430 #endif 1431 } 1432 splx(s); 1433 1434 return 0; 1435 } 1436 1437 static void 1438 in_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1439 { 1440 int cn, len, i; 1441 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1442 struct umidi_jack *jack; 1443 unsigned char *packet; 1444 umidi_packet_bufp slot; 1445 umidi_packet_bufp end; 1446 unsigned char *data; 1447 u_int32_t count; 1448 1449 if (ep->sc->sc_dying || !ep->num_open) 1450 return; 1451 1452 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1453 if ( 0 == count % UMIDI_PACKET_SIZE ) { 1454 DPRINTFN(200,("%s: input endpoint %p transfer length %u\n", 1455 USBDEVNAME(ep->sc->sc_dev), ep, count)); 1456 } else { 1457 DPRINTF(("%s: input endpoint %p odd transfer length %u\n", 1458 USBDEVNAME(ep->sc->sc_dev), ep, count)); 1459 } 1460 1461 slot = ep->buffer; 1462 end = slot + count / sizeof *slot; 1463 1464 for ( packet = *slot; slot < end; packet = *++slot ) { 1465 1466 if ( UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE) ) { 1467 cn = (0xf0&(packet[3]))>>4; 1468 len = 0x0f&(packet[3]); 1469 data = packet; 1470 } else { 1471 cn = GET_CN(packet[0]); 1472 len = packet_length[GET_CIN(packet[0])]; 1473 data = packet + 1; 1474 } 1475 /* 0 <= cn <= 15 by inspection of above code */ 1476 if (!(jack = ep->jacks[cn]) || cn != jack->cable_number) { 1477 DPRINTF(("%s: stray input endpoint %p cable %d len %d: " 1478 "%02X %02X %02X (try CN_SEQ quirk?)\n", 1479 USBDEVNAME(ep->sc->sc_dev), ep, cn, len, 1480 (unsigned)data[0], 1481 (unsigned)data[1], 1482 (unsigned)data[2])); 1483 return; 1484 } 1485 1486 if (!jack->binded || !jack->opened) 1487 continue; 1488 1489 DPRINTFN(500,("%s: input endpoint %p cable %d len %d: " 1490 "%02X %02X %02X\n", 1491 USBDEVNAME(ep->sc->sc_dev), ep, cn, len, 1492 (unsigned)data[0], 1493 (unsigned)data[1], 1494 (unsigned)data[2])); 1495 1496 if (jack->u.in.intr) { 1497 for (i=0; i<len; i++) { 1498 (*jack->u.in.intr)(jack->arg, data[i]); 1499 } 1500 } 1501 1502 } 1503 1504 (void)start_input_transfer(ep); 1505 } 1506 1507 static void 1508 out_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1509 { 1510 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1511 struct umidi_softc *sc = ep->sc; 1512 u_int32_t count; 1513 1514 if (sc->sc_dying) 1515 return; 1516 1517 #ifdef UMIDI_DEBUG 1518 if ( umididebug >= 200 ) 1519 microtime(&umidi_tv); 1520 #endif 1521 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1522 if ( 0 == count % UMIDI_PACKET_SIZE ) { 1523 DPRINTFN(200,("%s: %lu.%06lus out ep %p xfer length %u\n", 1524 USBDEVNAME(ep->sc->sc_dev), 1525 umidi_tv.tv_sec%100, umidi_tv.tv_usec, ep, count)); 1526 } else { 1527 DPRINTF(("%s: output endpoint %p odd transfer length %u\n", 1528 USBDEVNAME(ep->sc->sc_dev), ep, count)); 1529 } 1530 count /= UMIDI_PACKET_SIZE; 1531 1532 /* 1533 * If while the transfer was pending we buffered any new messages, 1534 * move them to the start of the buffer. 1535 */ 1536 ep->next_slot -= count; 1537 if ( ep->buffer < ep->next_slot ) { 1538 memcpy(ep->buffer, ep->buffer + count, 1539 (char *)ep->next_slot - (char *)ep->buffer); 1540 } 1541 wakeup(ep); 1542 /* 1543 * Do not want anyone else to see armed <- 0 before soliciting <- 1. 1544 * Running at splusb so the following should happen to be safe. 1545 */ 1546 ep->armed = 0; 1547 if ( !ep->soliciting ) { 1548 ep->soliciting = 1; 1549 out_solicit(ep); 1550 } 1551 } 1552 1553 /* 1554 * A jack on which we have received a packet must be called back on its 1555 * out.intr handler before it will send us another; it is considered 1556 * 'scheduled'. It is nice and predictable - as long as it is scheduled, 1557 * we need no extra buffer space for it. 1558 * 1559 * In contrast, a jack that is open but not scheduled may supply us a packet 1560 * at any time, driven by the top half, and we must be able to accept it, no 1561 * excuses. So we must ensure that at any point in time there are at least 1562 * (num_open - num_scheduled) slots free. 1563 * 1564 * As long as there are more slots free than that minimum, we can loop calling 1565 * scheduled jacks back on their "interrupt" handlers, soliciting more 1566 * packets, starting the USB transfer only when the buffer space is down to 1567 * the minimum or no jack has any more to send. 1568 */ 1569 static void 1570 out_solicit(void *arg) 1571 { 1572 struct umidi_endpoint *ep = arg; 1573 int s; 1574 umidi_packet_bufp end; 1575 u_int16_t which; 1576 struct umidi_jack *jack; 1577 1578 end = ep->buffer + ep->buffer_size / sizeof *ep->buffer; 1579 1580 for ( ;; ) { 1581 s = splusb(); 1582 if ( end - ep->next_slot <= ep->num_open - ep->num_scheduled ) 1583 break; /* at splusb */ 1584 if ( ep->this_schedule == 0 ) { 1585 if ( ep->next_schedule == 0 ) 1586 break; /* at splusb */ 1587 ep->this_schedule = ep->next_schedule; 1588 ep->next_schedule = 0; 1589 } 1590 /* 1591 * At least one jack is scheduled. Find and mask off the least 1592 * set bit in this_schedule and decrement num_scheduled. 1593 * Convert mask to bit index to find the corresponding jack, 1594 * and call its intr handler. If it has a message, it will call 1595 * back one of the output methods, which will set its bit in 1596 * next_schedule (not copied into this_schedule until the 1597 * latter is empty). In this way we round-robin the jacks that 1598 * have messages to send, until the buffer is as full as we 1599 * dare, and then start a transfer. 1600 */ 1601 which = ep->this_schedule; 1602 which &= (~which)+1; /* now mask of least set bit */ 1603 ep->this_schedule &= ~which; 1604 -- ep->num_scheduled; 1605 splx(s); 1606 1607 -- which; /* now 1s below mask - count 1s to get index */ 1608 which -= ((which >> 1) & 0x5555);/* SWAR credit aggregate.org */ 1609 which = (((which >> 2) & 0x3333) + (which & 0x3333)); 1610 which = (((which >> 4) + which) & 0x0f0f); 1611 which += (which >> 8); 1612 which &= 0x1f; /* the bit index a/k/a jack number */ 1613 1614 jack = ep->jacks[which]; 1615 if (jack->u.out.intr) 1616 (*jack->u.out.intr)(jack->arg); 1617 } 1618 /* splusb at loop exit */ 1619 if ( !ep->armed && ep->next_slot > ep->buffer ) 1620 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep)); 1621 ep->soliciting = 0; 1622 splx(s); 1623 } 1624
Indexes created Thu Oct 02 14:10:14 GMT 2025