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