umidi.c revision 1.44.4.1
1 /* $NetBSD: umidi.c,v 1.44.4.1 2011/11/22 07:56:15 mrg 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 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: umidi.c,v 1.44.4.1 2011/11/22 07:56:15 mrg Exp $"); 34 35 #include <sys/types.h> 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/malloc.h> 40 #include <sys/device.h> 41 #include <sys/ioctl.h> 42 #include <sys/conf.h> 43 #include <sys/file.h> 44 #include <sys/select.h> 45 #include <sys/proc.h> 46 #include <sys/vnode.h> 47 #include <sys/poll.h> 48 #include <sys/intr.h> 49 50 #include <dev/usb/usb.h> 51 #include <dev/usb/usbdi.h> 52 #include <dev/usb/usbdi_util.h> 53 54 #include <dev/usb/usbdevs.h> 55 #include <dev/usb/uaudioreg.h> 56 #include <dev/usb/umidireg.h> 57 #include <dev/usb/umidivar.h> 58 #include <dev/usb/umidi_quirks.h> 59 60 #include <dev/midi_if.h> 61 62 #ifdef UMIDI_DEBUG 63 #define DPRINTF(x) if (umididebug) printf x 64 #define DPRINTFN(n,x) if (umididebug >= (n)) printf x 65 #include <sys/time.h> 66 static struct timeval umidi_tv; 67 int umididebug = 0; 68 #else 69 #define DPRINTF(x) 70 #define DPRINTFN(n,x) 71 #endif 72 73 74 static int umidi_open(void *, int, 75 void (*)(void *, int), void (*)(void *), void *); 76 static void umidi_close(void *); 77 static int umidi_channelmsg(void *, int, int, u_char *, int); 78 static int umidi_commonmsg(void *, int, u_char *, int); 79 static int umidi_sysex(void *, u_char *, int); 80 static int umidi_rtmsg(void *, int); 81 static void umidi_getinfo(void *, struct midi_info *); 82 static void umidi_get_locks(void *, kmutex_t **, kmutex_t **); 83 84 static usbd_status alloc_pipe(struct umidi_endpoint *); 85 static void free_pipe(struct umidi_endpoint *); 86 87 static usbd_status alloc_all_endpoints(struct umidi_softc *); 88 static void free_all_endpoints(struct umidi_softc *); 89 90 static usbd_status alloc_all_jacks(struct umidi_softc *); 91 static void free_all_jacks(struct umidi_softc *); 92 static usbd_status bind_jacks_to_mididev(struct umidi_softc *, 93 struct umidi_jack *, 94 struct umidi_jack *, 95 struct umidi_mididev *); 96 static void unbind_jacks_from_mididev(struct umidi_mididev *); 97 static void unbind_all_jacks(struct umidi_softc *); 98 static usbd_status assign_all_jacks_automatically(struct umidi_softc *); 99 static usbd_status open_out_jack(struct umidi_jack *, void *, 100 void (*)(void *)); 101 static usbd_status open_in_jack(struct umidi_jack *, void *, 102 void (*)(void *, int)); 103 static void close_out_jack(struct umidi_jack *); 104 static void close_in_jack(struct umidi_jack *); 105 106 static usbd_status attach_mididev(struct umidi_softc *, struct umidi_mididev *); 107 static usbd_status detach_mididev(struct umidi_mididev *, int); 108 static void deactivate_mididev(struct umidi_mididev *); 109 static usbd_status alloc_all_mididevs(struct umidi_softc *, int); 110 static void free_all_mididevs(struct umidi_softc *); 111 static usbd_status attach_all_mididevs(struct umidi_softc *); 112 static usbd_status detach_all_mididevs(struct umidi_softc *, int); 113 static void deactivate_all_mididevs(struct umidi_softc *); 114 static char *describe_mididev(struct umidi_mididev *); 115 116 #ifdef UMIDI_DEBUG 117 static void dump_sc(struct umidi_softc *); 118 static void dump_ep(struct umidi_endpoint *); 119 static void dump_jack(struct umidi_jack *); 120 #endif 121 122 static usbd_status start_input_transfer(struct umidi_endpoint *); 123 static usbd_status start_output_transfer(struct umidi_endpoint *); 124 static int out_jack_output(struct umidi_jack *, u_char *, int, int); 125 static void in_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); 126 static void out_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); 127 static void out_solicit(void *); /* struct umidi_endpoint* for softintr */ 128 129 130 const struct midi_hw_if umidi_hw_if = { 131 .open = umidi_open, 132 .close = umidi_close, 133 .output = umidi_rtmsg, 134 .getinfo = umidi_getinfo, 135 .get_locks = umidi_get_locks, 136 }; 137 138 struct midi_hw_if_ext umidi_hw_if_ext = { 139 .channel = umidi_channelmsg, 140 .common = umidi_commonmsg, 141 .sysex = umidi_sysex, 142 }; 143 144 struct midi_hw_if_ext umidi_hw_if_mm = { 145 .channel = umidi_channelmsg, 146 .common = umidi_commonmsg, 147 .sysex = umidi_sysex, 148 .compress = 1, 149 }; 150 151 int umidi_match(device_t, cfdata_t, void *); 152 void umidi_attach(device_t, device_t, void *); 153 void umidi_childdet(device_t, device_t); 154 int umidi_detach(device_t, int); 155 int umidi_activate(device_t, enum devact); 156 extern struct cfdriver umidi_cd; 157 CFATTACH_DECL2_NEW(umidi, sizeof(struct umidi_softc), umidi_match, 158 umidi_attach, umidi_detach, umidi_activate, NULL, umidi_childdet); 159 160 int 161 umidi_match(device_t parent, cfdata_t match, void *aux) 162 { 163 struct usbif_attach_arg *uaa = aux; 164 165 DPRINTFN(1,("umidi_match\n")); 166 167 if (umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno)) 168 return UMATCH_IFACECLASS_IFACESUBCLASS; 169 170 if (uaa->class == UICLASS_AUDIO && 171 uaa->subclass == UISUBCLASS_MIDISTREAM) 172 return UMATCH_IFACECLASS_IFACESUBCLASS; 173 174 return UMATCH_NONE; 175 } 176 177 void 178 umidi_attach(device_t parent, device_t self, void *aux) 179 { 180 usbd_status err; 181 struct umidi_softc *sc = device_private(self); 182 struct usbif_attach_arg *uaa = aux; 183 char *devinfop; 184 185 DPRINTFN(1,("umidi_attach\n")); 186 187 sc->sc_dev = self; 188 189 aprint_naive("\n"); 190 aprint_normal("\n"); 191 192 devinfop = usbd_devinfo_alloc(uaa->device, 0); 193 aprint_normal_dev(self, "%s\n", devinfop); 194 usbd_devinfo_free(devinfop); 195 196 sc->sc_iface = uaa->iface; 197 sc->sc_udev = uaa->device; 198 199 sc->sc_quirk = 200 umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno); 201 aprint_normal_dev(self, ""); 202 umidi_print_quirk(sc->sc_quirk); 203 204 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); 205 mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_USB); 206 207 err = alloc_all_endpoints(sc); 208 if (err!=USBD_NORMAL_COMPLETION) { 209 aprint_error_dev(self, 210 "alloc_all_endpoints failed. (err=%d)\n", err); 211 goto error; 212 } 213 err = alloc_all_jacks(sc); 214 if (err!=USBD_NORMAL_COMPLETION) { 215 free_all_endpoints(sc); 216 aprint_error_dev(self, "alloc_all_jacks failed. (err=%d)\n", 217 err); 218 goto error; 219 } 220 aprint_normal_dev(self, "out=%d, in=%d\n", 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 aprint_error_dev(self, 229 "assign_all_jacks_automatically failed. (err=%d)\n", 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 aprint_error_dev(self, 237 "attach_all_mididevs failed. (err=%d)\n", 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, sc->sc_dev); 246 247 return; 248 error: 249 aprint_error_dev(self, "disabled.\n"); 250 sc->sc_dying = 1; 251 return; 252 } 253 254 void 255 umidi_childdet(device_t self, device_t child) 256 { 257 int i; 258 struct umidi_softc *sc = device_private(self); 259 260 KASSERT(sc->sc_mididevs != NULL); 261 262 for (i = 0; i < sc->sc_num_mididevs; i++) { 263 if (sc->sc_mididevs[i].mdev == child) 264 break; 265 } 266 KASSERT(i < sc->sc_num_mididevs); 267 sc->sc_mididevs[i].mdev = NULL; 268 } 269 270 int 271 umidi_activate(device_t self, enum devact act) 272 { 273 struct umidi_softc *sc = device_private(self); 274 275 switch (act) { 276 case DVACT_DEACTIVATE: 277 DPRINTFN(1,("umidi_activate (deactivate)\n")); 278 sc->sc_dying = 1; 279 deactivate_all_mididevs(sc); 280 return 0; 281 default: 282 DPRINTFN(1,("umidi_activate (%d)\n", act)); 283 return EOPNOTSUPP; 284 } 285 } 286 287 int 288 umidi_detach(device_t self, int flags) 289 { 290 struct umidi_softc *sc = device_private(self); 291 292 DPRINTFN(1,("umidi_detach\n")); 293 294 sc->sc_dying = 1; 295 detach_all_mididevs(sc, flags); 296 free_all_mididevs(sc); 297 free_all_jacks(sc); 298 free_all_endpoints(sc); 299 300 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 301 sc->sc_dev); 302 303 mutex_destroy(&sc->sc_lock); 304 mutex_destroy(&sc->sc_intr_lock); 305 306 return 0; 307 } 308 309 310 /* 311 * midi_if stuffs 312 */ 313 int 314 umidi_open(void *addr, 315 int flags, 316 void (*iintr)(void *, int), 317 void (*ointr)(void *), 318 void *arg) 319 { 320 struct umidi_mididev *mididev = addr; 321 struct umidi_softc *sc = mididev->sc; 322 usbd_status err; 323 324 DPRINTF(("umidi_open: sc=%p\n", sc)); 325 326 if (!sc) 327 return ENXIO; 328 if (mididev->opened) 329 return EBUSY; 330 if (sc->sc_dying) 331 return EIO; 332 333 mididev->opened = 1; 334 mididev->flags = flags; 335 if ((mididev->flags & FWRITE) && mididev->out_jack) { 336 err = open_out_jack(mididev->out_jack, arg, ointr); 337 if ( err != USBD_NORMAL_COMPLETION ) 338 goto bad; 339 } 340 if ((mididev->flags & FREAD) && mididev->in_jack) { 341 err = open_in_jack(mididev->in_jack, arg, iintr); 342 if ( err != USBD_NORMAL_COMPLETION 343 && err != USBD_IN_PROGRESS ) 344 goto bad; 345 } 346 347 return 0; 348 bad: 349 mididev->opened = 0; 350 DPRINTF(("umidi_open: usbd_status %d\n", err)); 351 return USBD_IN_USE == err ? EBUSY : EIO; 352 } 353 354 void 355 umidi_close(void *addr) 356 { 357 int s; 358 struct umidi_mididev *mididev = addr; 359 360 s = splusb(); 361 if ((mididev->flags & FWRITE) && mididev->out_jack) 362 close_out_jack(mididev->out_jack); 363 if ((mididev->flags & FREAD) && mididev->in_jack) 364 close_in_jack(mididev->in_jack); 365 mididev->opened = 0; 366 splx(s); 367 } 368 369 int 370 umidi_channelmsg(void *addr, int status, int channel, u_char *msg, 371 int len) 372 { 373 struct umidi_mididev *mididev = addr; 374 375 if (!mididev->out_jack || !mididev->opened) 376 return EIO; 377 378 return out_jack_output(mididev->out_jack, msg, len, (status>>4)&0xf); 379 } 380 381 int 382 umidi_commonmsg(void *addr, int status, u_char *msg, int len) 383 { 384 struct umidi_mididev *mididev = addr; 385 int cin; 386 387 if (!mididev->out_jack || !mididev->opened) 388 return EIO; 389 390 switch ( len ) { 391 case 1: cin = 5; break; 392 case 2: cin = 2; break; 393 case 3: cin = 3; break; 394 default: return EIO; /* or gcc warns of cin uninitialized */ 395 } 396 397 return out_jack_output(mididev->out_jack, msg, len, cin); 398 } 399 400 int 401 umidi_sysex(void *addr, u_char *msg, int len) 402 { 403 struct umidi_mididev *mididev = addr; 404 int cin; 405 406 if (!mididev->out_jack || !mididev->opened) 407 return EIO; 408 409 switch ( len ) { 410 case 1: cin = 5; break; 411 case 2: cin = 6; break; 412 case 3: cin = (msg[2] == 0xf7) ? 7 : 4; break; 413 default: return EIO; /* or gcc warns of cin uninitialized */ 414 } 415 416 return out_jack_output(mididev->out_jack, msg, len, cin); 417 } 418 419 int 420 umidi_rtmsg(void *addr, int d) 421 { 422 struct umidi_mididev *mididev = addr; 423 u_char msg = d; 424 425 if (!mididev->out_jack || !mididev->opened) 426 return EIO; 427 428 return out_jack_output(mididev->out_jack, &msg, 1, 0xf); 429 } 430 431 void 432 umidi_getinfo(void *addr, struct midi_info *mi) 433 { 434 struct umidi_mididev *mididev = addr; 435 struct umidi_softc *sc = mididev->sc; 436 int mm = UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE); 437 438 mi->name = mididev->label; 439 mi->props = MIDI_PROP_OUT_INTR; 440 if (mididev->in_jack) 441 mi->props |= MIDI_PROP_CAN_INPUT; 442 midi_register_hw_if_ext(mm? &umidi_hw_if_mm : &umidi_hw_if_ext); 443 } 444 445 static void 446 umidi_get_locks(void *addr, kmutex_t **intr, kmutex_t **thread) 447 { 448 struct umidi_mididev *mididev = addr; 449 struct umidi_softc *sc = mididev->sc; 450 451 *intr = &sc->sc_intr_lock; 452 *thread = &sc->sc_lock; 453 } 454 455 /* 456 * each endpoint stuffs 457 */ 458 459 /* alloc/free pipe */ 460 static usbd_status 461 alloc_pipe(struct umidi_endpoint *ep) 462 { 463 struct umidi_softc *sc = ep->sc; 464 usbd_status err; 465 usb_endpoint_descriptor_t *epd; 466 467 epd = usbd_get_endpoint_descriptor(sc->sc_iface, ep->addr); 468 /* 469 * For output, an improvement would be to have a buffer bigger than 470 * wMaxPacketSize by num_jacks-1 additional packet slots; that would 471 * allow out_solicit to fill the buffer to the full packet size in 472 * all cases. But to use usbd_alloc_buffer to get a slightly larger 473 * buffer would not be a good way to do that, because if the addition 474 * would make the buffer exceed USB_MEM_SMALL then a substantially 475 * larger block may be wastefully allocated. Some flavor of double 476 * buffering could serve the same purpose, but would increase the 477 * code complexity, so for now I will live with the current slight 478 * penalty of reducing max transfer size by (num_open-num_scheduled) 479 * packet slots. 480 */ 481 ep->buffer_size = UGETW(epd->wMaxPacketSize); 482 ep->buffer_size -= ep->buffer_size % UMIDI_PACKET_SIZE; 483 484 DPRINTF(("%s: alloc_pipe %p, buffer size %u\n", 485 device_xname(sc->sc_dev), ep, ep->buffer_size)); 486 ep->num_scheduled = 0; 487 ep->this_schedule = 0; 488 ep->next_schedule = 0; 489 ep->soliciting = 0; 490 ep->armed = 0; 491 ep->xfer = usbd_alloc_xfer(sc->sc_udev); 492 if (ep->xfer == NULL) { 493 err = USBD_NOMEM; 494 goto quit; 495 } 496 ep->buffer = usbd_alloc_buffer(ep->xfer, ep->buffer_size); 497 if (ep->buffer == NULL) { 498 usbd_free_xfer(ep->xfer); 499 err = USBD_NOMEM; 500 goto quit; 501 } 502 ep->next_slot = ep->buffer; 503 err = usbd_open_pipe(sc->sc_iface, ep->addr, 0, &ep->pipe); 504 if (err) 505 usbd_free_xfer(ep->xfer); 506 ep->solicit_cookie = softint_establish(SOFTINT_CLOCK, out_solicit, ep); 507 quit: 508 return err; 509 } 510 511 static void 512 free_pipe(struct umidi_endpoint *ep) 513 { 514 DPRINTF(("%s: free_pipe %p\n", device_xname(ep->sc->sc_dev), ep)); 515 usbd_abort_pipe(ep->pipe); 516 usbd_close_pipe(ep->pipe); 517 usbd_free_xfer(ep->xfer); 518 softint_disestablish(ep->solicit_cookie); 519 } 520 521 522 /* alloc/free the array of endpoint structures */ 523 524 static usbd_status alloc_all_endpoints_fixed_ep(struct umidi_softc *); 525 static usbd_status alloc_all_endpoints_yamaha(struct umidi_softc *); 526 static usbd_status alloc_all_endpoints_genuine(struct umidi_softc *); 527 528 static usbd_status 529 alloc_all_endpoints(struct umidi_softc *sc) 530 { 531 usbd_status err; 532 struct umidi_endpoint *ep; 533 int i; 534 535 if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) { 536 err = alloc_all_endpoints_fixed_ep(sc); 537 } else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) { 538 err = alloc_all_endpoints_yamaha(sc); 539 } else { 540 err = alloc_all_endpoints_genuine(sc); 541 } 542 if (err!=USBD_NORMAL_COMPLETION) 543 return err; 544 545 ep = sc->sc_endpoints; 546 for (i=sc->sc_out_num_endpoints+sc->sc_in_num_endpoints; i>0; i--) { 547 err = alloc_pipe(ep++); 548 if (err!=USBD_NORMAL_COMPLETION) { 549 for (; ep!=sc->sc_endpoints; ep--) 550 free_pipe(ep-1); 551 free(sc->sc_endpoints, M_USBDEV); 552 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 553 break; 554 } 555 } 556 return err; 557 } 558 559 static void 560 free_all_endpoints(struct umidi_softc *sc) 561 { 562 int i; 563 for (i=0; i<sc->sc_in_num_endpoints+sc->sc_out_num_endpoints; i++) 564 free_pipe(&sc->sc_endpoints[i]); 565 if (sc->sc_endpoints != NULL) 566 free(sc->sc_endpoints, M_USBDEV); 567 sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL; 568 } 569 570 static usbd_status 571 alloc_all_endpoints_fixed_ep(struct umidi_softc *sc) 572 { 573 usbd_status err; 574 const struct umq_fixed_ep_desc *fp; 575 struct umidi_endpoint *ep; 576 usb_endpoint_descriptor_t *epd; 577 int i; 578 579 fp = umidi_get_quirk_data_from_type(sc->sc_quirk, 580 UMQ_TYPE_FIXED_EP); 581 sc->sc_out_num_jacks = 0; 582 sc->sc_in_num_jacks = 0; 583 sc->sc_out_num_endpoints = fp->num_out_ep; 584 sc->sc_in_num_endpoints = fp->num_in_ep; 585 sc->sc_endpoints = malloc(sizeof(*sc->sc_out_ep)* 586 (sc->sc_out_num_endpoints+ 587 sc->sc_in_num_endpoints), 588 M_USBDEV, M_WAITOK); 589 if (!sc->sc_endpoints) { 590 return USBD_NOMEM; 591 } 592 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 593 sc->sc_in_ep = 594 sc->sc_in_num_endpoints ? 595 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 596 597 ep = &sc->sc_out_ep[0]; 598 for (i=0; i<sc->sc_out_num_endpoints; i++) { 599 epd = usbd_interface2endpoint_descriptor( 600 sc->sc_iface, 601 fp->out_ep[i].ep); 602 if (!epd) { 603 aprint_error_dev(sc->sc_dev, 604 "cannot get endpoint descriptor(out:%d)\n", 605 fp->out_ep[i].ep); 606 err = USBD_INVAL; 607 goto error; 608 } 609 if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK || 610 UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_OUT) { 611 aprint_error_dev(sc->sc_dev, "illegal endpoint(out:%d)\n", 612 fp->out_ep[i].ep); 613 err = USBD_INVAL; 614 goto error; 615 } 616 ep->sc = sc; 617 ep->addr = epd->bEndpointAddress; 618 ep->num_jacks = fp->out_ep[i].num_jacks; 619 sc->sc_out_num_jacks += fp->out_ep[i].num_jacks; 620 ep->num_open = 0; 621 memset(ep->jacks, 0, sizeof(ep->jacks)); 622 ep++; 623 } 624 ep = &sc->sc_in_ep[0]; 625 for (i=0; i<sc->sc_in_num_endpoints; i++) { 626 epd = usbd_interface2endpoint_descriptor( 627 sc->sc_iface, 628 fp->in_ep[i].ep); 629 if (!epd) { 630 aprint_error_dev(sc->sc_dev, 631 "cannot get endpoint descriptor(in:%d)\n", 632 fp->in_ep[i].ep); 633 err = USBD_INVAL; 634 goto error; 635 } 636 /* 637 * MIDISPORT_2X4 inputs on an interrupt rather than a bulk 638 * endpoint. The existing input logic in this driver seems 639 * to work successfully if we just stop treating an interrupt 640 * endpoint as illegal (or the in_progress status we get on 641 * the initial transfer). It does not seem necessary to 642 * actually use the interrupt flavor of alloc_pipe or make 643 * other serious rearrangements of logic. I like that. 644 */ 645 switch ( UE_GET_XFERTYPE(epd->bmAttributes) ) { 646 case UE_BULK: 647 case UE_INTERRUPT: 648 if ( UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress) ) 649 break; 650 /*FALLTHROUGH*/ 651 default: 652 aprint_error_dev(sc->sc_dev, 653 "illegal endpoint(in:%d)\n", fp->in_ep[i].ep); 654 err = USBD_INVAL; 655 goto error; 656 } 657 658 ep->sc = sc; 659 ep->addr = epd->bEndpointAddress; 660 ep->num_jacks = fp->in_ep[i].num_jacks; 661 sc->sc_in_num_jacks += fp->in_ep[i].num_jacks; 662 ep->num_open = 0; 663 memset(ep->jacks, 0, sizeof(ep->jacks)); 664 ep++; 665 } 666 667 return USBD_NORMAL_COMPLETION; 668 error: 669 free(sc->sc_endpoints, M_USBDEV); 670 sc->sc_endpoints = NULL; 671 return err; 672 } 673 674 static usbd_status 675 alloc_all_endpoints_yamaha(struct umidi_softc *sc) 676 { 677 /* This driver currently supports max 1in/1out bulk endpoints */ 678 usb_descriptor_t *desc; 679 umidi_cs_descriptor_t *udesc; 680 usb_endpoint_descriptor_t *epd; 681 int out_addr, in_addr, i; 682 int dir; 683 size_t remain, descsize; 684 685 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 686 out_addr = in_addr = 0; 687 688 /* detect endpoints */ 689 desc = TO_D(usbd_get_interface_descriptor(sc->sc_iface)); 690 for (i=(int)TO_IFD(desc)->bNumEndpoints-1; i>=0; i--) { 691 epd = usbd_interface2endpoint_descriptor(sc->sc_iface, i); 692 KASSERT(epd != NULL); 693 if (UE_GET_XFERTYPE(epd->bmAttributes) == UE_BULK) { 694 dir = UE_GET_DIR(epd->bEndpointAddress); 695 if (dir==UE_DIR_OUT && !out_addr) 696 out_addr = epd->bEndpointAddress; 697 else if (dir==UE_DIR_IN && !in_addr) 698 in_addr = epd->bEndpointAddress; 699 } 700 } 701 udesc = (umidi_cs_descriptor_t *)NEXT_D(desc); 702 703 /* count jacks */ 704 if (!(udesc->bDescriptorType==UDESC_CS_INTERFACE && 705 udesc->bDescriptorSubtype==UMIDI_MS_HEADER)) 706 return USBD_INVAL; 707 remain = (size_t)UGETW(TO_CSIFD(udesc)->wTotalLength) - 708 (size_t)udesc->bLength; 709 udesc = (umidi_cs_descriptor_t *)NEXT_D(udesc); 710 711 while (remain>=sizeof(usb_descriptor_t)) { 712 descsize = udesc->bLength; 713 if (descsize>remain || descsize==0) 714 break; 715 if (udesc->bDescriptorType==UDESC_CS_INTERFACE && 716 remain>=UMIDI_JACK_DESCRIPTOR_SIZE) { 717 if (udesc->bDescriptorSubtype==UMIDI_OUT_JACK) 718 sc->sc_out_num_jacks++; 719 else if (udesc->bDescriptorSubtype==UMIDI_IN_JACK) 720 sc->sc_in_num_jacks++; 721 } 722 udesc = (umidi_cs_descriptor_t *)NEXT_D(udesc); 723 remain-=descsize; 724 } 725 726 /* validate some parameters */ 727 if (sc->sc_out_num_jacks>UMIDI_MAX_EPJACKS) 728 sc->sc_out_num_jacks = UMIDI_MAX_EPJACKS; 729 if (sc->sc_in_num_jacks>UMIDI_MAX_EPJACKS) 730 sc->sc_in_num_jacks = UMIDI_MAX_EPJACKS; 731 if (sc->sc_out_num_jacks && out_addr) { 732 sc->sc_out_num_endpoints = 1; 733 } else { 734 sc->sc_out_num_endpoints = 0; 735 sc->sc_out_num_jacks = 0; 736 } 737 if (sc->sc_in_num_jacks && in_addr) { 738 sc->sc_in_num_endpoints = 1; 739 } else { 740 sc->sc_in_num_endpoints = 0; 741 sc->sc_in_num_jacks = 0; 742 } 743 sc->sc_endpoints = malloc(sizeof(struct umidi_endpoint)* 744 (sc->sc_out_num_endpoints+ 745 sc->sc_in_num_endpoints), 746 M_USBDEV, M_WAITOK); 747 if (!sc->sc_endpoints) 748 return USBD_NOMEM; 749 if (sc->sc_out_num_endpoints) { 750 sc->sc_out_ep = sc->sc_endpoints; 751 sc->sc_out_ep->sc = sc; 752 sc->sc_out_ep->addr = out_addr; 753 sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks; 754 sc->sc_out_ep->num_open = 0; 755 memset(sc->sc_out_ep->jacks, 0, sizeof(sc->sc_out_ep->jacks)); 756 } else 757 sc->sc_out_ep = NULL; 758 759 if (sc->sc_in_num_endpoints) { 760 sc->sc_in_ep = sc->sc_endpoints+sc->sc_out_num_endpoints; 761 sc->sc_in_ep->sc = sc; 762 sc->sc_in_ep->addr = in_addr; 763 sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks; 764 sc->sc_in_ep->num_open = 0; 765 memset(sc->sc_in_ep->jacks, 0, sizeof(sc->sc_in_ep->jacks)); 766 } else 767 sc->sc_in_ep = NULL; 768 769 return USBD_NORMAL_COMPLETION; 770 } 771 772 static usbd_status 773 alloc_all_endpoints_genuine(struct umidi_softc *sc) 774 { 775 usb_interface_descriptor_t *interface_desc; 776 usb_config_descriptor_t *config_desc; 777 usb_descriptor_t *desc; 778 int num_ep; 779 size_t remain, descsize; 780 struct umidi_endpoint *p, *q, *lowest, *endep, tmpep; 781 int epaddr; 782 783 interface_desc = usbd_get_interface_descriptor(sc->sc_iface); 784 num_ep = interface_desc->bNumEndpoints; 785 sc->sc_endpoints = p = malloc(sizeof(struct umidi_endpoint) * num_ep, 786 M_USBDEV, M_WAITOK); 787 if (!p) 788 return USBD_NOMEM; 789 790 sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0; 791 sc->sc_out_num_endpoints = sc->sc_in_num_endpoints = 0; 792 epaddr = -1; 793 794 /* get the list of endpoints for midi stream */ 795 config_desc = usbd_get_config_descriptor(sc->sc_udev); 796 desc = (usb_descriptor_t *) config_desc; 797 remain = (size_t)UGETW(config_desc->wTotalLength); 798 while (remain>=sizeof(usb_descriptor_t)) { 799 descsize = desc->bLength; 800 if (descsize>remain || descsize==0) 801 break; 802 if (desc->bDescriptorType==UDESC_ENDPOINT && 803 remain>=USB_ENDPOINT_DESCRIPTOR_SIZE && 804 UE_GET_XFERTYPE(TO_EPD(desc)->bmAttributes) == UE_BULK) { 805 epaddr = TO_EPD(desc)->bEndpointAddress; 806 } else if (desc->bDescriptorType==UDESC_CS_ENDPOINT && 807 remain>=UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE && 808 epaddr!=-1) { 809 if (num_ep>0) { 810 num_ep--; 811 p->sc = sc; 812 p->addr = epaddr; 813 p->num_jacks = TO_CSEPD(desc)->bNumEmbMIDIJack; 814 if (UE_GET_DIR(epaddr)==UE_DIR_OUT) { 815 sc->sc_out_num_endpoints++; 816 sc->sc_out_num_jacks += p->num_jacks; 817 } else { 818 sc->sc_in_num_endpoints++; 819 sc->sc_in_num_jacks += p->num_jacks; 820 } 821 p++; 822 } 823 } else 824 epaddr = -1; 825 desc = NEXT_D(desc); 826 remain-=descsize; 827 } 828 829 /* sort endpoints */ 830 num_ep = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints; 831 p = sc->sc_endpoints; 832 endep = p + num_ep; 833 while (p<endep) { 834 lowest = p; 835 for (q=p+1; q<endep; q++) { 836 if ((UE_GET_DIR(lowest->addr)==UE_DIR_IN && 837 UE_GET_DIR(q->addr)==UE_DIR_OUT) || 838 ((UE_GET_DIR(lowest->addr)== 839 UE_GET_DIR(q->addr)) && 840 (UE_GET_ADDR(lowest->addr)> 841 UE_GET_ADDR(q->addr)))) 842 lowest = q; 843 } 844 if (lowest != p) { 845 memcpy((void *)&tmpep, (void *)p, sizeof(tmpep)); 846 memcpy((void *)p, (void *)lowest, sizeof(tmpep)); 847 memcpy((void *)lowest, (void *)&tmpep, sizeof(tmpep)); 848 } 849 p->num_open = 0; 850 p++; 851 } 852 853 sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL; 854 sc->sc_in_ep = 855 sc->sc_in_num_endpoints ? 856 sc->sc_endpoints+sc->sc_out_num_endpoints : NULL; 857 858 return USBD_NORMAL_COMPLETION; 859 } 860 861 862 /* 863 * jack stuffs 864 */ 865 866 static usbd_status 867 alloc_all_jacks(struct umidi_softc *sc) 868 { 869 int i, j; 870 struct umidi_endpoint *ep; 871 struct umidi_jack *jack; 872 const unsigned char *cn_spec; 873 874 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_PER_EP)) 875 sc->cblnums_global = 0; 876 else if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_GLOBAL)) 877 sc->cblnums_global = 1; 878 else { 879 /* 880 * I don't think this default is correct, but it preserves 881 * the prior behavior of the code. That's why I defined two 882 * complementary quirks. Any device for which the default 883 * behavior is wrong can be made to work by giving it an 884 * explicit quirk, and if a pattern ever develops (as I suspect 885 * it will) that a lot of otherwise standard USB MIDI devices 886 * need the CN_SEQ_PER_EP "quirk," then this default can be 887 * changed to 0, and the only devices that will break are those 888 * listing neither quirk, and they'll easily be fixed by giving 889 * them the CN_SEQ_GLOBAL quirk. 890 */ 891 sc->cblnums_global = 1; 892 } 893 894 if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_FIXED)) 895 cn_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 896 UMQ_TYPE_CN_FIXED); 897 else 898 cn_spec = NULL; 899 900 /* allocate/initialize structures */ 901 sc->sc_jacks = 902 malloc(sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+ 903 sc->sc_out_num_jacks), 904 M_USBDEV, M_WAITOK); 905 if (!sc->sc_jacks) 906 return USBD_NOMEM; 907 sc->sc_out_jacks = 908 sc->sc_out_num_jacks ? sc->sc_jacks : NULL; 909 sc->sc_in_jacks = 910 sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL; 911 912 jack = &sc->sc_out_jacks[0]; 913 for (i=0; i<sc->sc_out_num_jacks; i++) { 914 jack->opened = 0; 915 jack->binded = 0; 916 jack->arg = NULL; 917 jack->u.out.intr = NULL; 918 jack->midiman_ppkt = NULL; 919 if ( sc->cblnums_global ) 920 jack->cable_number = i; 921 jack++; 922 } 923 jack = &sc->sc_in_jacks[0]; 924 for (i=0; i<sc->sc_in_num_jacks; i++) { 925 jack->opened = 0; 926 jack->binded = 0; 927 jack->arg = NULL; 928 jack->u.in.intr = NULL; 929 if ( sc->cblnums_global ) 930 jack->cable_number = i; 931 jack++; 932 } 933 934 /* assign each jacks to each endpoints */ 935 jack = &sc->sc_out_jacks[0]; 936 ep = &sc->sc_out_ep[0]; 937 for (i=0; i<sc->sc_out_num_endpoints; i++) { 938 for (j=0; j<ep->num_jacks; j++) { 939 jack->endpoint = ep; 940 if ( cn_spec != NULL ) 941 jack->cable_number = *cn_spec++; 942 else if ( !sc->cblnums_global ) 943 jack->cable_number = j; 944 ep->jacks[jack->cable_number] = jack; 945 jack++; 946 } 947 ep++; 948 } 949 jack = &sc->sc_in_jacks[0]; 950 ep = &sc->sc_in_ep[0]; 951 for (i=0; i<sc->sc_in_num_endpoints; i++) { 952 for (j=0; j<ep->num_jacks; j++) { 953 jack->endpoint = ep; 954 if ( cn_spec != NULL ) 955 jack->cable_number = *cn_spec++; 956 else if ( !sc->cblnums_global ) 957 jack->cable_number = j; 958 ep->jacks[jack->cable_number] = jack; 959 jack++; 960 } 961 ep++; 962 } 963 964 return USBD_NORMAL_COMPLETION; 965 } 966 967 static void 968 free_all_jacks(struct umidi_softc *sc) 969 { 970 int s; 971 972 s = splaudio(); 973 if (sc->sc_out_jacks) { 974 free(sc->sc_jacks, M_USBDEV); 975 sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL; 976 } 977 splx(s); 978 } 979 980 static usbd_status 981 bind_jacks_to_mididev(struct umidi_softc *sc, 982 struct umidi_jack *out_jack, 983 struct umidi_jack *in_jack, 984 struct umidi_mididev *mididev) 985 { 986 if ((out_jack && out_jack->binded) || (in_jack && in_jack->binded)) 987 return USBD_IN_USE; 988 if (mididev->out_jack || mididev->in_jack) 989 return USBD_IN_USE; 990 991 if (out_jack) 992 out_jack->binded = 1; 993 if (in_jack) 994 in_jack->binded = 1; 995 mididev->in_jack = in_jack; 996 mididev->out_jack = out_jack; 997 998 return USBD_NORMAL_COMPLETION; 999 } 1000 1001 static void 1002 unbind_jacks_from_mididev(struct umidi_mididev *mididev) 1003 { 1004 if ((mididev->flags & FWRITE) && mididev->out_jack) 1005 close_out_jack(mididev->out_jack); 1006 if ((mididev->flags & FREAD) && mididev->in_jack) 1007 close_in_jack(mididev->in_jack); 1008 1009 if (mididev->out_jack) 1010 mididev->out_jack->binded = 0; 1011 if (mididev->in_jack) 1012 mididev->in_jack->binded = 0; 1013 mididev->out_jack = mididev->in_jack = NULL; 1014 } 1015 1016 static void 1017 unbind_all_jacks(struct umidi_softc *sc) 1018 { 1019 int i; 1020 1021 if (sc->sc_mididevs) 1022 for (i=0; i<sc->sc_num_mididevs; i++) { 1023 unbind_jacks_from_mididev(&sc->sc_mididevs[i]); 1024 } 1025 } 1026 1027 static usbd_status 1028 assign_all_jacks_automatically(struct umidi_softc *sc) 1029 { 1030 usbd_status err; 1031 int i; 1032 struct umidi_jack *out, *in; 1033 const signed char *asg_spec; 1034 1035 err = 1036 alloc_all_mididevs(sc, 1037 max(sc->sc_out_num_jacks, sc->sc_in_num_jacks)); 1038 if (err!=USBD_NORMAL_COMPLETION) 1039 return err; 1040 1041 if ( UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED)) 1042 asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk, 1043 UMQ_TYPE_MD_FIXED); 1044 else 1045 asg_spec = NULL; 1046 1047 for (i=0; i<sc->sc_num_mididevs; i++) { 1048 if ( asg_spec != NULL ) { 1049 if ( *asg_spec == -1 ) 1050 out = NULL; 1051 else 1052 out = &sc->sc_out_jacks[*asg_spec]; 1053 ++ asg_spec; 1054 if ( *asg_spec == -1 ) 1055 in = NULL; 1056 else 1057 in = &sc->sc_in_jacks[*asg_spec]; 1058 ++ asg_spec; 1059 } else { 1060 out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i] 1061 : NULL; 1062 in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i] 1063 : NULL; 1064 } 1065 err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]); 1066 if (err!=USBD_NORMAL_COMPLETION) { 1067 free_all_mididevs(sc); 1068 return err; 1069 } 1070 } 1071 1072 return USBD_NORMAL_COMPLETION; 1073 } 1074 1075 static usbd_status 1076 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *)) 1077 { 1078 struct umidi_endpoint *ep = jack->endpoint; 1079 umidi_packet_bufp end; 1080 int s; 1081 int err; 1082 1083 if (jack->opened) 1084 return USBD_IN_USE; 1085 1086 jack->arg = arg; 1087 jack->u.out.intr = intr; 1088 jack->midiman_ppkt = NULL; 1089 end = ep->buffer + ep->buffer_size / sizeof *ep->buffer; 1090 s = splusb(); 1091 jack->opened = 1; 1092 ep->num_open++; 1093 /* 1094 * out_solicit maintains an invariant that there will always be 1095 * (num_open - num_scheduled) slots free in the buffer. as we have 1096 * just incremented num_open, the buffer may be too full to satisfy 1097 * the invariant until a transfer completes, for which we must wait. 1098 */ 1099 while ( end - ep->next_slot < ep->num_open - ep->num_scheduled ) { 1100 err = tsleep(ep, PWAIT|PCATCH, "umi op", mstohz(10)); 1101 if ( err ) { 1102 ep->num_open--; 1103 jack->opened = 0; 1104 splx(s); 1105 return USBD_IOERROR; 1106 } 1107 } 1108 splx(s); 1109 1110 return USBD_NORMAL_COMPLETION; 1111 } 1112 1113 static usbd_status 1114 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int)) 1115 { 1116 usbd_status err = USBD_NORMAL_COMPLETION; 1117 struct umidi_endpoint *ep = jack->endpoint; 1118 1119 if (jack->opened) 1120 return USBD_IN_USE; 1121 1122 jack->arg = arg; 1123 jack->u.in.intr = intr; 1124 jack->opened = 1; 1125 if (ep->num_open++==0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) { 1126 err = start_input_transfer(ep); 1127 if (err != USBD_NORMAL_COMPLETION && 1128 err != USBD_IN_PROGRESS) { 1129 ep->num_open--; 1130 } 1131 } 1132 1133 return err; 1134 } 1135 1136 static void 1137 close_out_jack(struct umidi_jack *jack) 1138 { 1139 struct umidi_endpoint *ep; 1140 int s; 1141 u_int16_t mask; 1142 int err; 1143 1144 if (jack->opened) { 1145 ep = jack->endpoint; 1146 mask = 1 << (jack->cable_number); 1147 s = splusb(); 1148 while ( mask & (ep->this_schedule | ep->next_schedule) ) { 1149 err = tsleep(ep, PWAIT|PCATCH, "umi dr", mstohz(10)); 1150 if ( err ) 1151 break; 1152 } 1153 jack->opened = 0; 1154 jack->endpoint->num_open--; 1155 ep->this_schedule &= ~mask; 1156 ep->next_schedule &= ~mask; 1157 splx(s); 1158 } 1159 } 1160 1161 static void 1162 close_in_jack(struct umidi_jack *jack) 1163 { 1164 if (jack->opened) { 1165 jack->opened = 0; 1166 if (--jack->endpoint->num_open == 0) { 1167 usbd_abort_pipe(jack->endpoint->pipe); 1168 } 1169 } 1170 } 1171 1172 static usbd_status 1173 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev) 1174 { 1175 if (mididev->sc) 1176 return USBD_IN_USE; 1177 1178 mididev->sc = sc; 1179 1180 mididev->label = describe_mididev(mididev); 1181 1182 mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, sc->sc_dev); 1183 1184 return USBD_NORMAL_COMPLETION; 1185 } 1186 1187 static usbd_status 1188 detach_mididev(struct umidi_mididev *mididev, int flags) 1189 { 1190 if (!mididev->sc) 1191 return USBD_NO_ADDR; 1192 1193 if (mididev->opened) { 1194 umidi_close(mididev); 1195 } 1196 unbind_jacks_from_mididev(mididev); 1197 1198 if (mididev->mdev != NULL) 1199 config_detach(mididev->mdev, flags); 1200 1201 if (NULL != mididev->label) { 1202 free(mididev->label, M_USBDEV); 1203 mididev->label = NULL; 1204 } 1205 1206 mididev->sc = NULL; 1207 1208 return USBD_NORMAL_COMPLETION; 1209 } 1210 1211 static void 1212 deactivate_mididev(struct umidi_mididev *mididev) 1213 { 1214 if (mididev->out_jack) 1215 mididev->out_jack->binded = 0; 1216 if (mididev->in_jack) 1217 mididev->in_jack->binded = 0; 1218 } 1219 1220 static usbd_status 1221 alloc_all_mididevs(struct umidi_softc *sc, int nmidi) 1222 { 1223 sc->sc_num_mididevs = nmidi; 1224 sc->sc_mididevs = malloc(sizeof(*sc->sc_mididevs)*nmidi, 1225 M_USBDEV, M_WAITOK|M_ZERO); 1226 if (!sc->sc_mididevs) 1227 return USBD_NOMEM; 1228 1229 return USBD_NORMAL_COMPLETION; 1230 } 1231 1232 static void 1233 free_all_mididevs(struct umidi_softc *sc) 1234 { 1235 sc->sc_num_mididevs = 0; 1236 if (sc->sc_mididevs) 1237 free(sc->sc_mididevs, M_USBDEV); 1238 } 1239 1240 static usbd_status 1241 attach_all_mididevs(struct umidi_softc *sc) 1242 { 1243 usbd_status err; 1244 int i; 1245 1246 if (sc->sc_mididevs) 1247 for (i=0; i<sc->sc_num_mididevs; i++) { 1248 err = attach_mididev(sc, &sc->sc_mididevs[i]); 1249 if (err!=USBD_NORMAL_COMPLETION) 1250 return err; 1251 } 1252 1253 return USBD_NORMAL_COMPLETION; 1254 } 1255 1256 static usbd_status 1257 detach_all_mididevs(struct umidi_softc *sc, int flags) 1258 { 1259 usbd_status err; 1260 int i; 1261 1262 if (sc->sc_mididevs) 1263 for (i=0; i<sc->sc_num_mididevs; i++) { 1264 err = detach_mididev(&sc->sc_mididevs[i], flags); 1265 if (err!=USBD_NORMAL_COMPLETION) 1266 return err; 1267 } 1268 1269 return USBD_NORMAL_COMPLETION; 1270 } 1271 1272 static void 1273 deactivate_all_mididevs(struct umidi_softc *sc) 1274 { 1275 int i; 1276 1277 if (sc->sc_mididevs) { 1278 for (i=0; i<sc->sc_num_mididevs; i++) 1279 deactivate_mididev(&sc->sc_mididevs[i]); 1280 } 1281 } 1282 1283 /* 1284 * TODO: the 0-based cable numbers will often not match the labeling of the 1285 * equipment. Ideally: 1286 * For class-compliant devices: get the iJack string from the jack descriptor. 1287 * Otherwise: 1288 * - support a DISPLAY_BASE_CN quirk (add the value to each internal cable 1289 * number for display) 1290 * - support an array quirk explictly giving a char * for each jack. 1291 * For now, you get 0-based cable numbers. If there are multiple endpoints and 1292 * the CNs are not globally unique, each is shown with its associated endpoint 1293 * address in hex also. That should not be necessary when using iJack values 1294 * or a quirk array. 1295 */ 1296 static char * 1297 describe_mididev(struct umidi_mididev *md) 1298 { 1299 char in_label[16]; 1300 char out_label[16]; 1301 const char *unit_label; 1302 char *final_label; 1303 struct umidi_softc *sc; 1304 int show_ep_in; 1305 int show_ep_out; 1306 size_t len; 1307 1308 sc = md->sc; 1309 show_ep_in = sc-> sc_in_num_endpoints > 1 && !sc->cblnums_global; 1310 show_ep_out = sc->sc_out_num_endpoints > 1 && !sc->cblnums_global; 1311 1312 if ( NULL == md->in_jack ) 1313 in_label[0] = '\0'; 1314 else if ( show_ep_in ) 1315 snprintf(in_label, sizeof in_label, "<%d(%x) ", 1316 md->in_jack->cable_number, md->in_jack->endpoint->addr); 1317 else 1318 snprintf(in_label, sizeof in_label, "<%d ", 1319 md->in_jack->cable_number); 1320 1321 if ( NULL == md->out_jack ) 1322 out_label[0] = '\0'; 1323 else if ( show_ep_out ) 1324 snprintf(out_label, sizeof out_label, ">%d(%x) ", 1325 md->out_jack->cable_number, md->out_jack->endpoint->addr); 1326 else 1327 snprintf(out_label, sizeof out_label, ">%d ", 1328 md->out_jack->cable_number); 1329 1330 unit_label = device_xname(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", device_xname(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 device_xname(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: %"PRIu64".%06"PRIu64"s ep=%p cn=%d len=%d cin=%#x\n", 1503 umidi_tv.tv_sec%100, (uint64_t)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 /* 1545 * It would be bad to call out_solicit directly here (the 1546 * caller need not be reentrant) but a soft interrupt allows 1547 * solicit to run immediately the caller exits its critical 1548 * section, and if the caller has more to write we can get it 1549 * before starting the USB transfer, and send a longer one. 1550 */ 1551 ep->soliciting = 1; 1552 softint_schedule(ep->solicit_cookie); 1553 } 1554 splx(s); 1555 1556 return 0; 1557 } 1558 1559 static void 1560 in_intr(usbd_xfer_handle xfer, usbd_private_handle priv, 1561 usbd_status status) 1562 { 1563 int cn, len, i; 1564 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1565 struct umidi_softc *sc = ep->sc; 1566 struct umidi_jack *jack; 1567 unsigned char *packet; 1568 umidi_packet_bufp slot; 1569 umidi_packet_bufp end; 1570 unsigned char *data; 1571 u_int32_t count; 1572 1573 if (ep->sc->sc_dying || !ep->num_open) 1574 return; 1575 1576 mutex_enter(&sc->sc_intr_lock); 1577 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1578 if ( 0 == count % UMIDI_PACKET_SIZE ) { 1579 DPRINTFN(200,("%s: input endpoint %p transfer length %u\n", 1580 device_xname(ep->sc->sc_dev), ep, count)); 1581 } else { 1582 DPRINTF(("%s: input endpoint %p odd transfer length %u\n", 1583 device_xname(ep->sc->sc_dev), ep, count)); 1584 } 1585 1586 slot = ep->buffer; 1587 end = slot + count / sizeof *slot; 1588 1589 for ( packet = *slot; slot < end; packet = *++slot ) { 1590 1591 if ( UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE) ) { 1592 cn = (0xf0&(packet[3]))>>4; 1593 len = 0x0f&(packet[3]); 1594 data = packet; 1595 } else { 1596 cn = GET_CN(packet[0]); 1597 len = packet_length[GET_CIN(packet[0])]; 1598 data = packet + 1; 1599 } 1600 /* 0 <= cn <= 15 by inspection of above code */ 1601 if (!(jack = ep->jacks[cn]) || cn != jack->cable_number) { 1602 DPRINTF(("%s: stray input endpoint %p cable %d len %d: " 1603 "%02X %02X %02X (try CN_SEQ quirk?)\n", 1604 device_xname(ep->sc->sc_dev), ep, cn, len, 1605 (unsigned)data[0], 1606 (unsigned)data[1], 1607 (unsigned)data[2])); 1608 mutex_exit(&sc->sc_intr_lock); 1609 return; 1610 } 1611 1612 if (!jack->binded || !jack->opened) 1613 continue; 1614 1615 DPRINTFN(500,("%s: input endpoint %p cable %d len %d: " 1616 "%02X %02X %02X\n", 1617 device_xname(ep->sc->sc_dev), ep, cn, len, 1618 (unsigned)data[0], 1619 (unsigned)data[1], 1620 (unsigned)data[2])); 1621 1622 if (jack->u.in.intr) { 1623 for (i=0; i<len; i++) { 1624 (*jack->u.in.intr)(jack->arg, data[i]); 1625 } 1626 } 1627 1628 } 1629 1630 (void)start_input_transfer(ep); 1631 mutex_exit(&sc->sc_intr_lock); 1632 } 1633 1634 static void 1635 out_intr(usbd_xfer_handle xfer, usbd_private_handle priv, 1636 usbd_status status) 1637 { 1638 struct umidi_endpoint *ep = (struct umidi_endpoint *)priv; 1639 struct umidi_softc *sc = ep->sc; 1640 u_int32_t count; 1641 1642 if (sc->sc_dying) 1643 return; 1644 1645 mutex_enter(&sc->sc_intr_lock); 1646 #ifdef UMIDI_DEBUG 1647 if ( umididebug >= 200 ) 1648 microtime(&umidi_tv); 1649 #endif 1650 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1651 if ( 0 == count % UMIDI_PACKET_SIZE ) { 1652 DPRINTFN(200,("%s: %"PRIu64".%06"PRIu64"s out ep %p xfer length %u\n", 1653 device_xname(ep->sc->sc_dev), 1654 umidi_tv.tv_sec%100, (uint64_t)umidi_tv.tv_usec, ep, count)); 1655 } else { 1656 DPRINTF(("%s: output endpoint %p odd transfer length %u\n", 1657 device_xname(ep->sc->sc_dev), ep, count)); 1658 } 1659 count /= UMIDI_PACKET_SIZE; 1660 1661 /* 1662 * If while the transfer was pending we buffered any new messages, 1663 * move them to the start of the buffer. 1664 */ 1665 ep->next_slot -= count; 1666 if ( ep->buffer < ep->next_slot ) { 1667 memcpy(ep->buffer, ep->buffer + count, 1668 (char *)ep->next_slot - (char *)ep->buffer); 1669 } 1670 wakeup(ep); 1671 /* 1672 * Do not want anyone else to see armed <- 0 before soliciting <- 1. 1673 * Running at splusb so the following should happen to be safe. 1674 */ 1675 ep->armed = 0; 1676 if ( !ep->soliciting ) { 1677 ep->soliciting = 1; 1678 out_solicit(ep); 1679 } 1680 mutex_exit(&sc->sc_intr_lock); 1681 } 1682 1683 /* 1684 * A jack on which we have received a packet must be called back on its 1685 * out.intr handler before it will send us another; it is considered 1686 * 'scheduled'. It is nice and predictable - as long as it is scheduled, 1687 * we need no extra buffer space for it. 1688 * 1689 * In contrast, a jack that is open but not scheduled may supply us a packet 1690 * at any time, driven by the top half, and we must be able to accept it, no 1691 * excuses. So we must ensure that at any point in time there are at least 1692 * (num_open - num_scheduled) slots free. 1693 * 1694 * As long as there are more slots free than that minimum, we can loop calling 1695 * scheduled jacks back on their "interrupt" handlers, soliciting more 1696 * packets, starting the USB transfer only when the buffer space is down to 1697 * the minimum or no jack has any more to send. 1698 */ 1699 static void 1700 out_solicit(void *arg) 1701 { 1702 struct umidi_endpoint *ep = arg; 1703 int s; 1704 umidi_packet_bufp end; 1705 u_int16_t which; 1706 struct umidi_jack *jack; 1707 1708 end = ep->buffer + ep->buffer_size / sizeof *ep->buffer; 1709 1710 for ( ;; ) { 1711 s = splusb(); 1712 if ( end - ep->next_slot <= ep->num_open - ep->num_scheduled ) 1713 break; /* at splusb */ 1714 if ( ep->this_schedule == 0 ) { 1715 if ( ep->next_schedule == 0 ) 1716 break; /* at splusb */ 1717 ep->this_schedule = ep->next_schedule; 1718 ep->next_schedule = 0; 1719 } 1720 /* 1721 * At least one jack is scheduled. Find and mask off the least 1722 * set bit in this_schedule and decrement num_scheduled. 1723 * Convert mask to bit index to find the corresponding jack, 1724 * and call its intr handler. If it has a message, it will call 1725 * back one of the output methods, which will set its bit in 1726 * next_schedule (not copied into this_schedule until the 1727 * latter is empty). In this way we round-robin the jacks that 1728 * have messages to send, until the buffer is as full as we 1729 * dare, and then start a transfer. 1730 */ 1731 which = ep->this_schedule; 1732 which &= (~which)+1; /* now mask of least set bit */ 1733 ep->this_schedule &= ~which; 1734 -- ep->num_scheduled; 1735 splx(s); 1736 1737 -- which; /* now 1s below mask - count 1s to get index */ 1738 which -= ((which >> 1) & 0x5555);/* SWAR credit aggregate.org */ 1739 which = (((which >> 2) & 0x3333) + (which & 0x3333)); 1740 which = (((which >> 4) + which) & 0x0f0f); 1741 which += (which >> 8); 1742 which &= 0x1f; /* the bit index a/k/a jack number */ 1743 1744 jack = ep->jacks[which]; 1745 if (jack->u.out.intr) 1746 (*jack->u.out.intr)(jack->arg); 1747 } 1748 /* splusb at loop exit */ 1749 if ( !ep->armed && ep->next_slot > ep->buffer ) 1750 ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep)); 1751 ep->soliciting = 0; 1752 splx(s); 1753 } 1754
Indexes created Thu Oct 02 14:10:14 GMT 2025