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