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