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