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