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