uaudio.c revision 1.24
1 /* $NetBSD: uaudio.c,v 1.24 2000/04/27 15:26:47 augustss Exp $ */ 2 3 /* 4 * Copyright (c) 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (lennart (at) augustsson.net) at 9 * Carlstedt Research & Technology. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * USB audio specs: http://www.teleport.com/~usb/data/Audio10.pdf 42 * http://www.teleport.com/~usb/data/Frmts10.pdf 43 * http://www.teleport.com/~usb/data/Termt10.pdf 44 */ 45 46 #include <sys/param.h> 47 #include <sys/systm.h> 48 #include <sys/kernel.h> 49 #include <sys/malloc.h> 50 #include <sys/device.h> 51 #include <sys/ioctl.h> 52 #include <sys/tty.h> 53 #include <sys/file.h> 54 #include <sys/select.h> 55 #include <sys/proc.h> 56 #include <sys/vnode.h> 57 #include <sys/device.h> 58 #include <sys/poll.h> 59 60 #include <sys/audioio.h> 61 #include <dev/audio_if.h> 62 #include <dev/mulaw.h> 63 #include <dev/auconv.h> 64 65 #include <dev/usb/usb.h> 66 #include <dev/usb/usbdi.h> 67 #include <dev/usb/usbdi_util.h> 68 #include <dev/usb/usb_quirks.h> 69 70 #include <dev/usb/uaudioreg.h> 71 72 #ifdef UAUDIO_DEBUG 73 #define DPRINTF(x) if (uaudiodebug) logprintf x 74 #define DPRINTFN(n,x) if (uaudiodebug>(n)) logprintf x 75 int uaudiodebug = 0; 76 #else 77 #define DPRINTF(x) 78 #define DPRINTFN(n,x) 79 #endif 80 81 #define UAUDIO_NCHANBUFS 6 /* number of outstanding request */ 82 #define UAUDIO_NFRAMES 20 /* ms of sound in each request */ 83 84 85 #define MIX_MAX_CHAN 8 86 struct mixerctl { 87 u_int16_t wValue[MIX_MAX_CHAN]; /* using nchan */ 88 u_int16_t wIndex; 89 u_int8_t nchan; 90 u_int8_t type; 91 #define MIX_ON_OFF 1 92 #define MIX_SIGNED_16 2 93 #define MIX_UNSIGNED_16 3 94 #define MIX_SIGNED_8 4 95 #define MIX_SIZE(n) ((n) == MIX_SIGNED_16 || (n) == MIX_UNSIGNED_16 ? 2 : 1) 96 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16) 97 int minval, maxval; 98 u_int8_t class; 99 char ctlname[MAX_AUDIO_DEV_LEN]; 100 char *ctlunit; 101 }; 102 #define MAKE(h,l) (((h) << 8) | (l)) 103 104 struct as_info { 105 u_int8_t alt; 106 u_int8_t encoding; 107 usb_interface_descriptor_t *idesc; 108 usb_endpoint_descriptor_audio_t *edesc; 109 struct usb_audio_streaming_type1_descriptor *asf1desc; 110 }; 111 112 struct chan { 113 int terminal; /* terminal id */ 114 void (*intr) __P((void *)); /* dma completion intr handler */ 115 void *arg; /* arg for intr() */ 116 usbd_pipe_handle pipe; 117 int dir; /* direction, UE_DIR_XXX */ 118 119 u_int sample_size; 120 u_int sample_rate; 121 u_int bytes_per_frame; 122 u_int fraction; /* fraction/1000 is the extra samples/frame */ 123 u_int residue; /* accumulates the fractional samples */ 124 125 u_char *start; /* upper layer buffer start */ 126 u_char *end; /* upper layer buffer end */ 127 u_char *cur; /* current position in upper layer buffer */ 128 int blksize; /* chunk size to report up */ 129 int transferred; /* transferred bytes not reported up */ 130 131 int curchanbuf; 132 struct chanbuf { 133 struct chan *chan; 134 usbd_xfer_handle xfer; 135 u_char *buffer; 136 u_int16_t sizes[UAUDIO_NFRAMES]; 137 u_int16_t size; 138 } chanbufs[UAUDIO_NCHANBUFS]; 139 140 struct uaudio_softc *sc; /* our softc */ 141 }; 142 143 struct uaudio_softc { 144 USBBASEDEVICE sc_dev; /* base device */ 145 usbd_device_handle sc_udev; /* USB device */ 146 147 int sc_ac_iface; /* Audio Control interface */ 148 int sc_as_iface; /* Audio Streaming interface */ 149 usbd_interface_handle sc_ac_ifaceh; 150 usbd_interface_handle sc_as_ifaceh; 151 152 struct chan sc_chan; 153 154 int sc_curaltidx; 155 156 int sc_nullalt; 157 158 int sc_audio_rev; 159 160 struct as_info *sc_alts; 161 int sc_nalts; 162 int sc_props; 163 164 int sc_altflags; 165 #define HAS_8 0x01 166 #define HAS_16 0x02 167 #define HAS_8U 0x04 168 #define HAS_ALAW 0x08 169 #define HAS_MULAW 0x10 170 171 struct mixerctl *sc_ctls; 172 int sc_nctls; 173 174 device_ptr_t sc_audiodev; 175 char sc_dying; 176 }; 177 178 #define UAC_OUTPUT 0 179 #define UAC_INPUT 1 180 #define UAC_EQUAL 2 181 182 Static usbd_status uaudio_identify_ac __P((struct uaudio_softc *sc, 183 usb_config_descriptor_t *cdesc)); 184 Static usbd_status uaudio_identify_as __P((struct uaudio_softc *sc, 185 usb_config_descriptor_t *cdesc)); 186 Static usbd_status uaudio_process_as __P((struct uaudio_softc *sc, 187 char *buf, int *offsp, int size, 188 usb_interface_descriptor_t *id)); 189 190 Static void uaudio_add_alt __P((struct uaudio_softc *sc, 191 struct as_info *ai)); 192 193 Static usb_interface_descriptor_t *uaudio_find_iface 194 __P((char *buf, int size, int *offsp, int subtype)); 195 196 Static void uaudio_mixer_add_ctl __P((struct uaudio_softc *sc, 197 struct mixerctl *mp)); 198 Static char *uaudio_id_name __P((struct uaudio_softc *sc, 199 usb_descriptor_t **dps, int id)); 200 Static struct usb_audio_cluster uaudio_get_cluster __P((int id, 201 usb_descriptor_t **dps)); 202 Static void uaudio_add_input __P((struct uaudio_softc *sc, 203 usb_descriptor_t *v, usb_descriptor_t **dps)); 204 Static void uaudio_add_output __P((struct uaudio_softc *sc, 205 usb_descriptor_t *v, usb_descriptor_t **dps)); 206 Static void uaudio_add_mixer __P((struct uaudio_softc *sc, 207 usb_descriptor_t *v, usb_descriptor_t **dps)); 208 Static void uaudio_add_selector __P((struct uaudio_softc *sc, 209 usb_descriptor_t *v, usb_descriptor_t **dps)); 210 Static void uaudio_add_feature __P((struct uaudio_softc *sc, 211 usb_descriptor_t *v, usb_descriptor_t **dps)); 212 Static void uaudio_add_processing_updown 213 __P((struct uaudio_softc *sc, 214 usb_descriptor_t *v, usb_descriptor_t **dps)); 215 Static void uaudio_add_processing __P((struct uaudio_softc *sc, 216 usb_descriptor_t *v, usb_descriptor_t **dps)); 217 Static void uaudio_add_extension __P((struct uaudio_softc *sc, 218 usb_descriptor_t *v, usb_descriptor_t **dps)); 219 Static usbd_status uaudio_identify __P((struct uaudio_softc *sc, 220 usb_config_descriptor_t *cdesc)); 221 222 Static int uaudio_signext __P((int type, int val)); 223 Static int uaudio_value2bsd __P((struct mixerctl *mc, int val)); 224 Static int uaudio_bsd2value __P((struct mixerctl *mc, int val)); 225 Static int uaudio_get __P((struct uaudio_softc *sc, int type, 226 int which, int wValue, int wIndex, int len)); 227 Static int uaudio_ctl_get __P((struct uaudio_softc *sc, int which, 228 struct mixerctl *mc, int chan)); 229 Static void uaudio_set __P((struct uaudio_softc *sc, int type, 230 int which, int wValue, int wIndex, int l, int v)); 231 Static void uaudio_ctl_set __P((struct uaudio_softc *sc, int which, 232 struct mixerctl *mc, int chan, int val)); 233 234 Static usbd_status uaudio_set_speed __P((struct uaudio_softc *, int, 235 u_int)); 236 237 Static usbd_status uaudio_chan_open __P((struct uaudio_softc *sc, 238 struct chan *ch)); 239 Static void uaudio_chan_close __P((struct uaudio_softc *sc, 240 struct chan *ch)); 241 Static usbd_status uaudio_chan_alloc_buffers __P((struct uaudio_softc *, 242 struct chan *)); 243 Static void uaudio_chan_free_buffers __P((struct uaudio_softc *, 244 struct chan *)); 245 Static void uaudio_chan_set_param __P((struct chan *ch, 246 struct audio_params *param, u_char *start, 247 u_char *end, int blksize)); 248 Static void uaudio_chan_ptransfer __P((struct chan *ch)); 249 Static void uaudio_chan_pintr __P((usbd_xfer_handle xfer, 250 usbd_private_handle priv, usbd_status status)); 251 252 Static void uaudio_chan_rtransfer __P((struct chan *ch)); 253 Static void uaudio_chan_rintr __P((usbd_xfer_handle xfer, 254 usbd_private_handle priv, usbd_status status)); 255 256 257 258 Static int uaudio_open __P((void *, int)); 259 Static void uaudio_close __P((void *)); 260 Static int uaudio_drain __P((void *)); 261 Static int uaudio_query_encoding __P((void *, 262 struct audio_encoding *)); 263 Static int uaudio_set_params __P((void *, int, int, 264 struct audio_params *, struct audio_params *)); 265 Static int uaudio_round_blocksize __P((void *, int)); 266 Static int uaudio_trigger_output __P((void *, void *, void *, 267 int, void (*)(void *), void *, 268 struct audio_params *)); 269 Static int uaudio_trigger_input __P((void *, void *, void *, 270 int, void (*)(void *), void *, 271 struct audio_params *)); 272 Static int uaudio_halt_in_dma __P((void *)); 273 Static int uaudio_halt_out_dma __P((void *)); 274 Static int uaudio_getdev __P((void *, struct audio_device *)); 275 Static int uaudio_mixer_set_port __P((void *, mixer_ctrl_t *)); 276 Static int uaudio_mixer_get_port __P((void *, mixer_ctrl_t *)); 277 Static int uaudio_query_devinfo __P((void *, mixer_devinfo_t *)); 278 Static int uaudio_get_props __P((void *)); 279 280 Static struct audio_hw_if uaudio_hw_if = { 281 uaudio_open, 282 uaudio_close, 283 uaudio_drain, 284 uaudio_query_encoding, 285 uaudio_set_params, 286 uaudio_round_blocksize, 287 NULL, 288 NULL, 289 NULL, 290 NULL, 291 NULL, 292 uaudio_halt_out_dma, 293 uaudio_halt_in_dma, 294 NULL, 295 uaudio_getdev, 296 NULL, 297 uaudio_mixer_set_port, 298 uaudio_mixer_get_port, 299 uaudio_query_devinfo, 300 NULL, 301 NULL, 302 NULL, 303 NULL, 304 uaudio_get_props, 305 uaudio_trigger_output, 306 uaudio_trigger_input, 307 }; 308 309 Static struct audio_device uaudio_device = { 310 "USB audio", 311 "", 312 "uaudio" 313 }; 314 315 USB_DECLARE_DRIVER(uaudio); 316 317 USB_MATCH(uaudio) 318 { 319 USB_MATCH_START(uaudio, uaa); 320 usb_interface_descriptor_t *id; 321 322 if (uaa->iface == NULL) 323 return (UMATCH_NONE); 324 325 id = usbd_get_interface_descriptor(uaa->iface); 326 /* Trigger on the control interface. */ 327 if (id == NULL || 328 id->bInterfaceClass != UICLASS_AUDIO || 329 id->bInterfaceSubClass != UISUBCLASS_AUDIOCONTROL || 330 (usbd_get_quirks(uaa->device)->uq_flags & UQ_BAD_AUDIO)) 331 return (UMATCH_NONE); 332 333 return (UMATCH_IFACECLASS_IFACESUBCLASS); 334 } 335 336 USB_ATTACH(uaudio) 337 { 338 USB_ATTACH_START(uaudio, sc, uaa); 339 usb_interface_descriptor_t *id; 340 usb_config_descriptor_t *cdesc; 341 char devinfo[1024]; 342 usbd_status err; 343 int i; 344 345 usbd_devinfo(uaa->device, 0, devinfo); 346 printf(": %s\n", devinfo); 347 348 sc->sc_udev = uaa->device; 349 350 cdesc = usbd_get_config_descriptor(sc->sc_udev); 351 if (cdesc == NULL) { 352 printf("%s: failed to get configuration descriptor\n", 353 USBDEVNAME(sc->sc_dev)); 354 USB_ATTACH_ERROR_RETURN; 355 } 356 357 err = uaudio_identify(sc, cdesc); 358 if (err) { 359 printf("%s: audio descriptors make no sense, error=%d\n", 360 USBDEVNAME(sc->sc_dev), err); 361 USB_ATTACH_ERROR_RETURN; 362 } 363 364 sc->sc_ac_ifaceh = uaa->iface; 365 /* Pick up the AS interface. */ 366 for (i = 0; i < uaa->nifaces; i++) { 367 if (uaa->ifaces[i] != NULL) { 368 id = usbd_get_interface_descriptor(uaa->ifaces[i]); 369 if (id != NULL && 370 id->bInterfaceNumber == sc->sc_as_iface) { 371 sc->sc_as_ifaceh = uaa->ifaces[i]; 372 uaa->ifaces[i] = NULL; 373 break; 374 } 375 } 376 } 377 378 if (sc->sc_as_ifaceh == NULL) { 379 printf("%s: missing AS interface(s)\n",USBDEVNAME(sc->sc_dev)); 380 USB_ATTACH_ERROR_RETURN; 381 } 382 383 printf("%s: streaming interface %d, audio rev %d.%02x\n", 384 USBDEVNAME(sc->sc_dev), sc->sc_as_iface, 385 sc->sc_audio_rev >> 8, sc->sc_audio_rev & 0xff); 386 387 sc->sc_chan.sc = sc; 388 389 DPRINTF(("uaudio_attach: doing audio_attach_mi\n")); 390 #if defined(__OpenBSD__) 391 audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev); 392 #else 393 sc->sc_audiodev = audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev); 394 #endif 395 396 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 397 USBDEV(sc->sc_dev)); 398 399 USB_ATTACH_SUCCESS_RETURN; 400 } 401 402 int 403 uaudio_activate(self, act) 404 device_ptr_t self; 405 enum devact act; 406 { 407 struct uaudio_softc *sc = (struct uaudio_softc *)self; 408 int rv = 0; 409 410 switch (act) { 411 case DVACT_ACTIVATE: 412 return (EOPNOTSUPP); 413 break; 414 415 case DVACT_DEACTIVATE: 416 if (sc->sc_audiodev) 417 rv = config_deactivate(sc->sc_audiodev); 418 sc->sc_dying = 1; 419 break; 420 } 421 return (rv); 422 } 423 424 int 425 uaudio_detach(self, flags) 426 device_ptr_t self; 427 int flags; 428 { 429 struct uaudio_softc *sc = (struct uaudio_softc *)self; 430 int rv = 0; 431 432 /* Wait for outstanding requests to complete. */ 433 usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES); 434 435 if (sc->sc_audiodev != NULL) 436 rv = config_detach(sc->sc_audiodev, flags); 437 438 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 439 USBDEV(sc->sc_dev)); 440 441 return (rv); 442 } 443 444 int 445 uaudio_query_encoding(addr, fp) 446 void *addr; 447 struct audio_encoding *fp; 448 { 449 struct uaudio_softc *sc = addr; 450 int flags = sc->sc_altflags; 451 int idx; 452 453 if (sc->sc_dying) 454 return (EIO); 455 456 if (sc->sc_nalts == 0 || flags == 0) 457 return (ENXIO); 458 459 idx = fp->index; 460 switch (idx) { 461 case 0: 462 strcpy(fp->name, AudioEulinear); 463 fp->encoding = AUDIO_ENCODING_ULINEAR; 464 fp->precision = 8; 465 fp->flags = flags&HAS_8U ? 0 : AUDIO_ENCODINGFLAG_EMULATED; 466 return (0); 467 case 1: 468 strcpy(fp->name, AudioEmulaw); 469 fp->encoding = AUDIO_ENCODING_ULAW; 470 fp->precision = 8; 471 fp->flags = flags&HAS_MULAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED; 472 return (0); 473 case 2: 474 strcpy(fp->name, AudioEalaw); 475 fp->encoding = AUDIO_ENCODING_ALAW; 476 fp->precision = 8; 477 fp->flags = flags&HAS_ALAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED; 478 return (0); 479 case 3: 480 strcpy(fp->name, AudioEslinear); 481 fp->encoding = AUDIO_ENCODING_SLINEAR; 482 fp->precision = 8; 483 fp->flags = flags&HAS_8 ? 0 : AUDIO_ENCODINGFLAG_EMULATED; 484 return (0); 485 case 4: 486 strcpy(fp->name, AudioEslinear_le); 487 fp->encoding = AUDIO_ENCODING_SLINEAR_LE; 488 fp->precision = 16; 489 fp->flags = 0; 490 return (0); 491 case 5: 492 strcpy(fp->name, AudioEulinear_le); 493 fp->encoding = AUDIO_ENCODING_ULINEAR_LE; 494 fp->precision = 16; 495 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 496 return (0); 497 case 6: 498 strcpy(fp->name, AudioEslinear_be); 499 fp->encoding = AUDIO_ENCODING_SLINEAR_BE; 500 fp->precision = 16; 501 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 502 return (0); 503 case 7: 504 strcpy(fp->name, AudioEulinear_be); 505 fp->encoding = AUDIO_ENCODING_ULINEAR_BE; 506 fp->precision = 16; 507 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 508 return (0); 509 default: 510 return (EINVAL); 511 } 512 } 513 514 usb_interface_descriptor_t * 515 uaudio_find_iface(buf, size, offsp, subtype) 516 char *buf; 517 int size; 518 int *offsp; 519 int subtype; 520 { 521 usb_interface_descriptor_t *d; 522 523 while (*offsp < size) { 524 d = (void *)(buf + *offsp); 525 *offsp += d->bLength; 526 if (d->bDescriptorType == UDESC_INTERFACE && 527 d->bInterfaceClass == UICLASS_AUDIO && 528 d->bInterfaceSubClass == subtype) 529 return (d); 530 } 531 return (0); 532 } 533 534 void 535 uaudio_mixer_add_ctl(sc, mc) 536 struct uaudio_softc *sc; 537 struct mixerctl *mc; 538 { 539 if (sc->sc_nctls == NULL) 540 sc->sc_ctls = malloc(sizeof *mc, M_USBDEV, M_NOWAIT); 541 else 542 sc->sc_ctls = realloc(sc->sc_ctls, 543 (sc->sc_nctls+1) * sizeof *mc, 544 M_USBDEV, M_NOWAIT); 545 if (sc->sc_ctls == NULL) { 546 printf("uaudio_mixer_add_ctl: no memory\n"); 547 return; 548 } 549 550 if (mc->type != MIX_ON_OFF) { 551 /* Determine min and max values. */ 552 mc->minval = uaudio_signext(mc->type, 553 uaudio_get(sc, GET_MIN, UT_READ_CLASS_INTERFACE, 554 mc->wValue[0], mc->wIndex, 555 MIX_SIZE(mc->type))); 556 mc->maxval = 1 + uaudio_signext(mc->type, 557 uaudio_get(sc, GET_MAX, UT_READ_CLASS_INTERFACE, 558 mc->wValue[0], mc->wIndex, 559 MIX_SIZE(mc->type))); 560 } else { 561 mc->minval = 0; 562 mc->maxval = 1; 563 } 564 565 sc->sc_ctls[sc->sc_nctls++] = *mc; 566 567 #ifdef UAUDIO_DEBUG 568 if (uaudiodebug > 2) { 569 int i; 570 DPRINTF(("uaudio_mixer_add_ctl: wValue=%04x",mc->wValue[0])); 571 for (i = 1; i < mc->nchan; i++) 572 DPRINTF((",%04x", mc->wValue[i])); 573 DPRINTF((" wIndex=%04x type=%d name='%s' unit='%s' " 574 "min=%d max=%d\n", 575 mc->wIndex, mc->type, mc->ctlname, mc->ctlunit, 576 mc->minval, mc->maxval)); 577 } 578 #endif 579 } 580 581 char * 582 uaudio_id_name(sc, dps, id) 583 struct uaudio_softc *sc; 584 usb_descriptor_t **dps; 585 int id; 586 { 587 static char buf[32]; 588 sprintf(buf, "i%d", id); 589 return (buf); 590 } 591 592 struct usb_audio_cluster 593 uaudio_get_cluster(id, dps) 594 int id; 595 usb_descriptor_t **dps; 596 { 597 struct usb_audio_cluster r; 598 usb_descriptor_t *dp; 599 int i; 600 601 for (i = 0; i < 25; i++) { /* avoid infinite loops */ 602 dp = dps[id]; 603 if (dp == 0) 604 goto bad; 605 switch (dp->bDescriptorSubtype) { 606 case UDESCSUB_AC_INPUT: 607 #define p ((struct usb_audio_input_terminal *)dp) 608 r.bNrChannels = p->bNrChannels; 609 USETW(r.wChannelConfig, UGETW(p->wChannelConfig)); 610 r.iChannelNames = p->iChannelNames; 611 #undef p 612 return (r); 613 case UDESCSUB_AC_OUTPUT: 614 #define p ((struct usb_audio_output_terminal *)dp) 615 id = p->bSourceId; 616 #undef p 617 break; 618 case UDESCSUB_AC_MIXER: 619 #define p ((struct usb_audio_mixer_unit *)dp) 620 r = *(struct usb_audio_cluster *) 621 &p->baSourceId[p->bNrInPins]; 622 #undef p 623 return (r); 624 case UDESCSUB_AC_SELECTOR: 625 /* XXX This is not really right */ 626 #define p ((struct usb_audio_selector_unit *)dp) 627 id = p->baSourceId[0]; 628 #undef p 629 break; 630 case UDESCSUB_AC_FEATURE: 631 #define p ((struct usb_audio_feature_unit *)dp) 632 id = p->bSourceId; 633 #undef p 634 break; 635 case UDESCSUB_AC_PROCESSING: 636 #define p ((struct usb_audio_processing_unit *)dp) 637 r = *(struct usb_audio_cluster *) 638 &p->baSourceId[p->bNrInPins]; 639 #undef p 640 return (r); 641 case UDESCSUB_AC_EXTENSION: 642 #define p ((struct usb_audio_extension_unit *)dp) 643 r = *(struct usb_audio_cluster *) 644 &p->baSourceId[p->bNrInPins]; 645 #undef p 646 return (r); 647 default: 648 goto bad; 649 } 650 } 651 bad: 652 printf("uaudio_get_cluster: bad data\n"); 653 memset(&r, 0, sizeof r); 654 return (r); 655 656 } 657 658 void 659 uaudio_add_input(sc, v, dps) 660 struct uaudio_softc *sc; 661 usb_descriptor_t *v; 662 usb_descriptor_t **dps; 663 { 664 #ifdef UAUDIO_DEBUG 665 struct usb_audio_input_terminal *d = 666 (struct usb_audio_input_terminal *)v; 667 668 DPRINTFN(2,("uaudio_add_input: bTerminalId=%d wTerminalType=0x%04x " 669 "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d " 670 "iChannelNames=%d iTerminal=%d\n", 671 d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal, 672 d->bNrChannels, UGETW(d->wChannelConfig), 673 d->iChannelNames, d->iTerminal)); 674 #endif 675 } 676 677 void 678 uaudio_add_output(sc, v, dps) 679 struct uaudio_softc *sc; 680 usb_descriptor_t *v; 681 usb_descriptor_t **dps; 682 { 683 #ifdef UAUDIO_DEBUG 684 struct usb_audio_output_terminal *d = 685 (struct usb_audio_output_terminal *)v; 686 687 DPRINTFN(2,("uaudio_add_output: bTerminalId=%d wTerminalType=0x%04x " 688 "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n", 689 d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal, 690 d->bSourceId, d->iTerminal)); 691 #endif 692 } 693 694 void 695 uaudio_add_mixer(sc, v, dps) 696 struct uaudio_softc *sc; 697 usb_descriptor_t *v; 698 usb_descriptor_t **dps; 699 { 700 struct usb_audio_mixer_unit *d = (struct usb_audio_mixer_unit *)v; 701 struct usb_audio_mixer_unit_1 *d1; 702 int c, chs, ichs, ochs, i, o, bno, p, mo, mc, k; 703 uByte *bm; 704 struct mixerctl mix; 705 706 DPRINTFN(2,("uaudio_add_mixer: bUnitId=%d bNrInPins=%d\n", 707 d->bUnitId, d->bNrInPins)); 708 709 /* Compute the number of input channels */ 710 ichs = 0; 711 for (i = 0; i < d->bNrInPins; i++) 712 ichs += uaudio_get_cluster(d->baSourceId[i], dps).bNrChannels; 713 714 /* and the number of output channels */ 715 d1 = (struct usb_audio_mixer_unit_1 *)&d->baSourceId[d->bNrInPins]; 716 ochs = d1->bNrChannels; 717 DPRINTFN(2,("uaudio_add_mixer: ichs=%d ochs=%d\n", ichs, ochs)); 718 719 bm = d1->bmControls; 720 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 721 mix.class = -1; 722 mix.type = MIX_SIGNED_16; 723 mix.ctlunit = AudioNvolume; 724 #define BIT(bno) ((bm[bno / 8] >> (7 - bno % 8)) & 1) 725 for (p = i = 0; i < d->bNrInPins; i++) { 726 chs = uaudio_get_cluster(d->baSourceId[i], dps).bNrChannels; 727 mc = 0; 728 for (c = 0; c < chs; c++) { 729 mo = 0; 730 for (o = 0; o < ochs; o++) { 731 bno = (p + c) * ochs + o; 732 if (BIT(bno)) 733 mo++; 734 } 735 if (mo == 1) 736 mc++; 737 } 738 if (mc == chs && chs <= MIX_MAX_CHAN) { 739 k = 0; 740 for (c = 0; c < chs; c++) 741 for (o = 0; o < ochs; o++) { 742 bno = (p + c) * ochs + o; 743 if (BIT(bno)) 744 mix.wValue[k++] = 745 MAKE(p+c+1, o+1); 746 } 747 sprintf(mix.ctlname, "mix%d-%s", d->bUnitId, 748 uaudio_id_name(sc, dps, d->baSourceId[i])); 749 mix.nchan = chs; 750 uaudio_mixer_add_ctl(sc, &mix); 751 } else { 752 /* XXX */ 753 } 754 #undef BIT 755 p += chs; 756 } 757 758 } 759 760 void 761 uaudio_add_selector(sc, v, dps) 762 struct uaudio_softc *sc; 763 usb_descriptor_t *v; 764 usb_descriptor_t **dps; 765 { 766 #ifdef UAUDIO_DEBUG 767 struct usb_audio_selector_unit *d = 768 (struct usb_audio_selector_unit *)v; 769 770 DPRINTFN(2,("uaudio_add_selector: bUnitId=%d bNrInPins=%d\n", 771 d->bUnitId, d->bNrInPins)); 772 #endif 773 printf("uaudio_add_selector: NOT IMPLEMENTED\n"); 774 } 775 776 void 777 uaudio_add_feature(sc, v, dps) 778 struct uaudio_softc *sc; 779 usb_descriptor_t *v; 780 usb_descriptor_t **dps; 781 { 782 struct usb_audio_feature_unit *d = (struct usb_audio_feature_unit *)v; 783 uByte *ctls = d->bmaControls; 784 int ctlsize = d->bControlSize; 785 int nchan = (d->bLength - 7) / ctlsize; 786 int srcId = d->bSourceId; 787 u_int fumask, mmask, cmask; 788 struct mixerctl mix; 789 int chan, ctl, i, unit; 790 791 #define GET(i) (ctls[(i)*ctlsize] | \ 792 (ctlsize > 1 ? ctls[(i)*ctlsize+1] << 8 : 0)) 793 794 mmask = GET(0); 795 /* Figure out what we can control */ 796 for (cmask = 0, chan = 1; chan < nchan; chan++) { 797 DPRINTFN(9,("uaudio_add_feature: chan=%d mask=%x\n", 798 chan, GET(chan))); 799 cmask |= GET(chan); 800 } 801 802 DPRINTFN(1,("uaudio_add_feature: bUnitId=%d bSourceId=%d, " 803 "%d channels, mmask=0x%04x, cmask=0x%04x\n", 804 d->bUnitId, srcId, nchan, mmask, cmask)); 805 806 if (nchan > MIX_MAX_CHAN) 807 nchan = MIX_MAX_CHAN; 808 unit = d->bUnitId; 809 mix.wIndex = MAKE(unit, sc->sc_ac_iface); 810 for (ctl = MUTE_CONTROL; ctl < LOUDNESS_CONTROL; ctl++) { 811 fumask = FU_MASK(ctl); 812 DPRINTFN(4,("uaudio_add_feature: ctl=%d fumask=0x%04x\n", 813 ctl, fumask)); 814 if (mmask & fumask) { 815 mix.nchan = 1; 816 mix.wValue[0] = MAKE(ctl, 0); 817 } else if (cmask & fumask) { 818 mix.nchan = nchan - 1; 819 for (i = 1; i < nchan; i++) { 820 if (GET(i) & fumask) 821 mix.wValue[i-1] = MAKE(ctl, i); 822 else 823 mix.wValue[i-1] = -1; 824 } 825 } else { 826 continue; 827 } 828 #undef GET 829 mix.class = -1; /* XXX */ 830 switch (ctl) { 831 case MUTE_CONTROL: 832 mix.type = MIX_ON_OFF; 833 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 834 uaudio_id_name(sc, dps, srcId), 835 AudioNmute); 836 mix.ctlunit = ""; 837 break; 838 case VOLUME_CONTROL: 839 mix.type = MIX_SIGNED_16; 840 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 841 uaudio_id_name(sc, dps, srcId), 842 AudioNmaster); 843 mix.ctlunit = AudioNvolume; 844 break; 845 case BASS_CONTROL: 846 mix.type = MIX_SIGNED_8; 847 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 848 uaudio_id_name(sc, dps, srcId), 849 AudioNbass); 850 mix.ctlunit = AudioNbass; 851 break; 852 case MID_CONTROL: 853 mix.type = MIX_SIGNED_8; 854 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 855 uaudio_id_name(sc, dps, srcId), 856 AudioNmid); 857 mix.ctlunit = AudioNmid; 858 break; 859 case TREBLE_CONTROL: 860 mix.type = MIX_SIGNED_8; 861 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 862 uaudio_id_name(sc, dps, srcId), 863 AudioNtreble); 864 mix.ctlunit = AudioNtreble; 865 break; 866 case GRAPHIC_EQUALIZER_CONTROL: 867 continue; /* XXX don't add anything */ 868 break; 869 case AGC_CONTROL: 870 mix.type = MIX_ON_OFF; 871 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 872 uaudio_id_name(sc, dps, srcId), 873 AudioNagc); 874 mix.ctlunit = ""; 875 break; 876 case DELAY_CONTROL: 877 mix.type = MIX_UNSIGNED_16; 878 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 879 uaudio_id_name(sc, dps, srcId), 880 AudioNdelay); 881 mix.ctlunit = "4 ms"; 882 break; 883 case BASS_BOOST_CONTROL: 884 mix.type = MIX_ON_OFF; 885 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 886 uaudio_id_name(sc, dps, srcId), 887 AudioNbassboost); 888 mix.ctlunit = ""; 889 break; 890 case LOUDNESS_CONTROL: 891 mix.type = MIX_ON_OFF; 892 sprintf(mix.ctlname, "fea%d-%s-%s", unit, 893 uaudio_id_name(sc, dps, srcId), 894 AudioNloudness); 895 mix.ctlunit = ""; 896 break; 897 } 898 uaudio_mixer_add_ctl(sc, &mix); 899 } 900 } 901 902 void 903 uaudio_add_processing_updown(sc, v, dps) 904 struct uaudio_softc *sc; 905 usb_descriptor_t *v; 906 usb_descriptor_t **dps; 907 { 908 struct usb_audio_processing_unit *d = 909 (struct usb_audio_processing_unit *)v; 910 struct usb_audio_processing_unit_1 *d1 = 911 (struct usb_audio_processing_unit_1 *)&d->baSourceId[d->bNrInPins]; 912 struct usb_audio_processing_unit_updown *ud = 913 (struct usb_audio_processing_unit_updown *) 914 &d1->bmControls[d1->bControlSize]; 915 struct mixerctl mix; 916 int i; 917 918 DPRINTFN(2,("uaudio_add_processing_updown: bUnitId=%d bNrModes=%d\n", 919 d->bUnitId, ud->bNrModes)); 920 921 if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) { 922 DPRINTF(("uaudio_add_processing_updown: no mode select\n")); 923 return; 924 } 925 926 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 927 mix.nchan = 1; 928 mix.wValue[0] = MAKE(UD_MODE_SELECT_CONTROL, 0); 929 mix.class = -1; 930 mix.type = MIX_ON_OFF; /* XXX */ 931 mix.ctlunit = ""; 932 sprintf(mix.ctlname, "pro%d-mode", d->bUnitId); 933 934 for (i = 0; i < ud->bNrModes; i++) { 935 DPRINTFN(2,("uaudio_add_processing_updown: i=%d bm=0x%x\n", 936 i, UGETW(ud->waModes[i]))); 937 /* XXX */ 938 } 939 uaudio_mixer_add_ctl(sc, &mix); 940 } 941 942 void 943 uaudio_add_processing(sc, v, dps) 944 struct uaudio_softc *sc; 945 usb_descriptor_t *v; 946 usb_descriptor_t **dps; 947 { 948 struct usb_audio_processing_unit *d = 949 (struct usb_audio_processing_unit *)v; 950 struct usb_audio_processing_unit_1 *d1 = 951 (struct usb_audio_processing_unit_1 *)&d->baSourceId[d->bNrInPins]; 952 int ptype = UGETW(d->wProcessType); 953 struct mixerctl mix; 954 955 DPRINTFN(2,("uaudio_add_processing: wProcessType=%d bUnitId=%d " 956 "bNrInPins=%d\n", ptype, d->bUnitId, d->bNrInPins)); 957 958 if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) { 959 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 960 mix.nchan = 1; 961 mix.wValue[0] = MAKE(XX_ENABLE_CONTROL, 0); 962 mix.class = -1; 963 mix.type = MIX_ON_OFF; 964 mix.ctlunit = ""; 965 sprintf(mix.ctlname, "pro%d.%d-enable", d->bUnitId, ptype); 966 uaudio_mixer_add_ctl(sc, &mix); 967 } 968 969 switch(ptype) { 970 case UPDOWNMIX_PROCESS: 971 uaudio_add_processing_updown(sc, v, dps); 972 break; 973 case DOLBY_PROLOGIC_PROCESS: 974 case P3D_STEREO_EXTENDER_PROCESS: 975 case REVERBATION_PROCESS: 976 case CHORUS_PROCESS: 977 case DYN_RANGE_COMP_PROCESS: 978 default: 979 #ifdef UAUDIO_DEBUG 980 printf("uaudio_add_processing: unit %d, type=%d not impl.\n", 981 d->bUnitId, ptype); 982 #endif 983 break; 984 } 985 } 986 987 void 988 uaudio_add_extension(sc, v, dps) 989 struct uaudio_softc *sc; 990 usb_descriptor_t *v; 991 usb_descriptor_t **dps; 992 { 993 struct usb_audio_extension_unit *d = 994 (struct usb_audio_extension_unit *)v; 995 struct usb_audio_extension_unit_1 *d1 = 996 (struct usb_audio_extension_unit_1 *)&d->baSourceId[d->bNrInPins]; 997 struct mixerctl mix; 998 999 DPRINTFN(2,("uaudio_add_extension: bUnitId=%d bNrInPins=%d\n", 1000 d->bUnitId, d->bNrInPins)); 1001 1002 if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) { 1003 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 1004 mix.nchan = 1; 1005 mix.wValue[0] = MAKE(UA_EXT_ENABLE, 0); 1006 mix.class = -1; 1007 mix.type = MIX_ON_OFF; 1008 mix.ctlunit = ""; 1009 sprintf(mix.ctlname, "ext%d-enable", d->bUnitId); 1010 uaudio_mixer_add_ctl(sc, &mix); 1011 } 1012 } 1013 1014 usbd_status 1015 uaudio_identify(sc, cdesc) 1016 struct uaudio_softc *sc; 1017 usb_config_descriptor_t *cdesc; 1018 { 1019 usbd_status err; 1020 1021 err = uaudio_identify_ac(sc, cdesc); 1022 if (err) 1023 return (err); 1024 return (uaudio_identify_as(sc, cdesc)); 1025 } 1026 1027 void 1028 uaudio_add_alt(sc, ai) 1029 struct uaudio_softc *sc; 1030 struct as_info *ai; 1031 { 1032 if (sc->sc_nalts == NULL) 1033 sc->sc_alts = malloc(sizeof *ai, M_USBDEV, M_NOWAIT); 1034 else 1035 sc->sc_alts = realloc(sc->sc_alts, 1036 (sc->sc_nalts+1) * sizeof *ai, 1037 M_USBDEV, M_NOWAIT); 1038 if (sc->sc_alts == NULL) { 1039 printf("uaudio_add_alt: no memory\n"); 1040 return; 1041 } 1042 DPRINTFN(2,("uaudio_add_alt: adding alt=%d, enc=%d\n", 1043 ai->alt, ai->encoding)); 1044 sc->sc_alts[sc->sc_nalts++] = *ai; 1045 } 1046 1047 usbd_status 1048 uaudio_process_as(sc, buf, offsp, size, id) 1049 struct uaudio_softc *sc; 1050 char *buf; 1051 int *offsp; 1052 #define offs (*offsp) 1053 int size; 1054 usb_interface_descriptor_t *id; 1055 { 1056 struct usb_audio_streaming_interface_descriptor *asid; 1057 struct usb_audio_streaming_type1_descriptor *asf1d; 1058 usb_endpoint_descriptor_audio_t *ed; 1059 struct usb_audio_streaming_endpoint_descriptor *sed; 1060 int format, chan, prec, enc; 1061 int dir, type; 1062 struct as_info ai; 1063 1064 asid = (void *)(buf + offs); 1065 if (asid->bDescriptorType != UDESC_CS_INTERFACE || 1066 asid->bDescriptorSubtype != AS_GENERAL) 1067 return (USBD_INVAL); 1068 offs += asid->bLength; 1069 if (offs > size) 1070 return (USBD_INVAL); 1071 asf1d = (void *)(buf + offs); 1072 if (asf1d->bDescriptorType != UDESC_CS_INTERFACE || 1073 asf1d->bDescriptorSubtype != FORMAT_TYPE) 1074 return (USBD_INVAL); 1075 offs += asf1d->bLength; 1076 if (offs > size) 1077 return (USBD_INVAL); 1078 1079 if (asf1d->bFormatType != FORMAT_TYPE_I) { 1080 printf("%s: ignored setting with type %d format\n", 1081 USBDEVNAME(sc->sc_dev), UGETW(asid->wFormatTag)); 1082 return (USBD_NORMAL_COMPLETION); 1083 } 1084 1085 ed = (void *)(buf + offs); 1086 if (ed->bDescriptorType != UDESC_ENDPOINT) 1087 return (USBD_INVAL); 1088 DPRINTF(("uaudio_process_as: endpoint bLength=%d bDescriptorType=%d " 1089 "bEndpointAddress=%d bmAttributes=0x%x wMaxPacketSize=%d " 1090 "bInterval=%d bRefresh=%d bSynchAddress=%d\n", 1091 ed->bLength, ed->bDescriptorType, ed->bEndpointAddress, 1092 ed->bmAttributes, UGETW(ed->wMaxPacketSize), 1093 ed->bInterval, ed->bRefresh, ed->bSynchAddress)); 1094 offs += ed->bLength; 1095 if (offs > size) 1096 return (USBD_INVAL); 1097 if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS) 1098 return (USBD_INVAL); 1099 1100 dir = UE_GET_DIR(ed->bEndpointAddress); 1101 type = UE_GET_ISO_TYPE(ed->bmAttributes); 1102 /* We can't handle endpoints that need a sync pipe. */ 1103 if (dir == UE_DIR_IN ? type == UE_ISO_ADAPT : type == UE_ISO_ASYNC) { 1104 printf("%s: ignored %sput endpoint of type 0x%x\n", 1105 USBDEVNAME(sc->sc_dev), 1106 dir == UE_DIR_IN ? "in" : "out", 1107 ed->bmAttributes & UE_ISO_TYPE); 1108 return (USBD_NORMAL_COMPLETION); 1109 } 1110 1111 sed = (void *)(buf + offs); 1112 if (sed->bDescriptorType != UDESC_CS_ENDPOINT || 1113 sed->bDescriptorSubtype != AS_GENERAL) 1114 return (USBD_INVAL); 1115 offs += sed->bLength; 1116 if (offs > size) 1117 return (USBD_INVAL); 1118 1119 format = UGETW(asid->wFormatTag); 1120 chan = asf1d->bNrChannels; 1121 prec = asf1d->bBitResolution; 1122 if (prec != 8 && prec != 16) { 1123 #ifdef AUDIO_DEBUG 1124 printf("%s: ignored setting with precision %d\n", 1125 USBDEVNAME(sc->sc_dev), prec); 1126 #endif 1127 return (USBD_NORMAL_COMPLETION); 1128 } 1129 switch (format) { 1130 case UA_FMT_PCM: 1131 sc->sc_altflags |= prec == 8 ? HAS_8 : HAS_16; 1132 enc = AUDIO_ENCODING_SLINEAR_LE; 1133 break; 1134 case UA_FMT_PCM8: 1135 enc = AUDIO_ENCODING_ULINEAR_LE; 1136 sc->sc_altflags |= HAS_8U; 1137 break; 1138 case UA_FMT_ALAW: 1139 enc = AUDIO_ENCODING_ALAW; 1140 sc->sc_altflags |= HAS_ALAW; 1141 break; 1142 case UA_FMT_MULAW: 1143 enc = AUDIO_ENCODING_ULAW; 1144 sc->sc_altflags |= HAS_MULAW; 1145 break; 1146 default: 1147 printf("%s: ignored setting with format %d\n", 1148 USBDEVNAME(sc->sc_dev), format); 1149 return (USBD_NORMAL_COMPLETION); 1150 } 1151 DPRINTFN(1,("uaudio_identify: alt=%d enc=%d chan=%d prec=%d\n", 1152 id->bAlternateSetting, enc, chan, prec)); 1153 ai.alt = id->bAlternateSetting; 1154 ai.encoding = enc; 1155 ai.idesc = id; 1156 ai.edesc = ed; 1157 ai.asf1desc = asf1d; 1158 uaudio_add_alt(sc, &ai); 1159 sc->sc_chan.terminal = asid->bTerminalLink; /* XXX */ 1160 sc->sc_chan.dir = dir; 1161 return (USBD_NORMAL_COMPLETION); 1162 } 1163 #undef offs 1164 1165 usbd_status 1166 uaudio_identify_as(sc, cdesc) 1167 struct uaudio_softc *sc; 1168 usb_config_descriptor_t *cdesc; 1169 { 1170 usb_interface_descriptor_t *id; 1171 usbd_status err; 1172 char *buf; 1173 int size, offs; 1174 1175 size = UGETW(cdesc->wTotalLength); 1176 buf = (char *)cdesc; 1177 1178 /* Locate the AudioStreaming interface descriptor. */ 1179 offs = 0; 1180 id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOSTREAM); 1181 if (id == NULL) 1182 return (USBD_INVAL); 1183 sc->sc_as_iface = id->bInterfaceNumber; 1184 DPRINTF(("uaudio_identify_as: AS interface is %d\n", sc->sc_as_iface)); 1185 1186 sc->sc_chan.terminal = -1; 1187 1188 /* Loop through all the alternate settings. */ 1189 while (offs <= size) { 1190 switch (id->bNumEndpoints) { 1191 case 0: 1192 DPRINTFN(2, ("uaudio_identify: AS null alt=%d\n", 1193 id->bAlternateSetting)); 1194 sc->sc_nullalt = id->bAlternateSetting; 1195 break; 1196 case 1: 1197 err = uaudio_process_as(sc, buf, &offs, size, id); 1198 break; 1199 default: 1200 #ifdef AUDIO_DEBUG 1201 printf("%s: ignored audio interface with %d " 1202 "endpoints\n", 1203 USBDEVNAME(sc->sc_dev), id->bNumEndpoints); 1204 #endif 1205 break; 1206 } 1207 id = uaudio_find_iface(buf, size, &offs,UISUBCLASS_AUDIOSTREAM); 1208 if (id == NULL) 1209 break; 1210 } 1211 if (offs > size) 1212 return (USBD_INVAL); 1213 DPRINTF(("uaudio_identify_as: %d alts available\n", sc->sc_nalts)); 1214 if (sc->sc_chan.terminal < 0) { 1215 printf("%s: no useable endpoint found\n", 1216 USBDEVNAME(sc->sc_dev)); 1217 return (USBD_INVAL); 1218 } 1219 return (USBD_NORMAL_COMPLETION); 1220 } 1221 1222 usbd_status 1223 uaudio_identify_ac(sc, cdesc) 1224 struct uaudio_softc *sc; 1225 usb_config_descriptor_t *cdesc; 1226 { 1227 usb_interface_descriptor_t *id; 1228 struct usb_audio_control_descriptor *acdp; 1229 usb_descriptor_t *dp, *dps[256]; 1230 char *buf, *ibuf, *ibufend; 1231 int size, offs, aclen, ndps, i; 1232 1233 size = UGETW(cdesc->wTotalLength); 1234 buf = (char *)cdesc; 1235 1236 /* Locate the AudioControl interface descriptor. */ 1237 offs = 0; 1238 id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOCONTROL); 1239 if (id == NULL) 1240 return (USBD_INVAL); 1241 if (offs + sizeof *acdp > size) 1242 return (USBD_INVAL); 1243 sc->sc_ac_iface = id->bInterfaceNumber; 1244 DPRINTFN(2,("uaudio_identify: AC interface is %d\n", sc->sc_ac_iface)); 1245 1246 /* A class-specific AC interface header should follow. */ 1247 ibuf = buf + offs; 1248 acdp = (struct usb_audio_control_descriptor *)ibuf; 1249 if (acdp->bDescriptorType != UDESC_CS_INTERFACE || 1250 acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER) 1251 return (USBD_INVAL); 1252 aclen = UGETW(acdp->wTotalLength); 1253 if (offs + aclen > size) 1254 return (USBD_INVAL); 1255 1256 if (!(usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_BAD_ADC) && 1257 UGETW(acdp->bcdADC) != UAUDIO_VERSION) 1258 return (USBD_INVAL); 1259 1260 sc->sc_audio_rev = UGETW(acdp->bcdADC); 1261 DPRINTFN(2,("uaudio_identify: found AC header, vers=%03x, len=%d\n", 1262 sc->sc_audio_rev, aclen)); 1263 1264 sc->sc_nullalt = -1; 1265 1266 /* Scan through all the AC specific descriptors */ 1267 ibufend = ibuf + aclen; 1268 dp = (usb_descriptor_t *)ibuf; 1269 ndps = 0; 1270 memset(dps, 0, sizeof dps); 1271 for (;;) { 1272 ibuf += dp->bLength; 1273 if (ibuf >= ibufend) 1274 break; 1275 dp = (usb_descriptor_t *)ibuf; 1276 if (ibuf + dp->bLength > ibufend) 1277 return (USBD_INVAL); 1278 if (dp->bDescriptorType != UDESC_CS_INTERFACE) { 1279 printf("uaudio_identify: skip desc type=0x%02x\n", 1280 dp->bDescriptorType); 1281 continue; 1282 } 1283 i = ((struct usb_audio_input_terminal *)dp)->bTerminalId; 1284 dps[i] = dp; 1285 if (i > ndps) 1286 ndps = i; 1287 } 1288 ndps++; 1289 1290 for (i = 0; i < ndps; i++) { 1291 dp = dps[i]; 1292 if (dp == NULL) 1293 continue; 1294 DPRINTF(("uaudio_identify: subtype=%d\n", 1295 dp->bDescriptorSubtype)); 1296 switch (dp->bDescriptorSubtype) { 1297 case UDESCSUB_AC_HEADER: 1298 printf("uaudio_identify: unexpected AC header\n"); 1299 break; 1300 case UDESCSUB_AC_INPUT: 1301 uaudio_add_input(sc, dp, dps); 1302 break; 1303 case UDESCSUB_AC_OUTPUT: 1304 uaudio_add_output(sc, dp, dps); 1305 break; 1306 case UDESCSUB_AC_MIXER: 1307 uaudio_add_mixer(sc, dp, dps); 1308 break; 1309 case UDESCSUB_AC_SELECTOR: 1310 uaudio_add_selector(sc, dp, dps); 1311 break; 1312 case UDESCSUB_AC_FEATURE: 1313 uaudio_add_feature(sc, dp, dps); 1314 break; 1315 case UDESCSUB_AC_PROCESSING: 1316 uaudio_add_processing(sc, dp, dps); 1317 break; 1318 case UDESCSUB_AC_EXTENSION: 1319 uaudio_add_extension(sc, dp, dps); 1320 break; 1321 default: 1322 printf("uaudio_identify: bad AC desc subtype=0x%02x\n", 1323 dp->bDescriptorSubtype); 1324 break; 1325 } 1326 } 1327 return (USBD_NORMAL_COMPLETION); 1328 } 1329 1330 int 1331 uaudio_query_devinfo(addr, mi) 1332 void *addr; 1333 mixer_devinfo_t *mi; 1334 { 1335 struct uaudio_softc *sc = addr; 1336 struct mixerctl *mc; 1337 int n, nctls; 1338 1339 DPRINTFN(2,("uaudio_query_devinfo: index=%d\n", mi->index)); 1340 if (sc->sc_dying) 1341 return (EIO); 1342 1343 n = mi->index; 1344 nctls = sc->sc_nctls; 1345 1346 if (n < 0 || n >= nctls) { 1347 switch (n - nctls) { 1348 case UAC_OUTPUT: 1349 mi->type = AUDIO_MIXER_CLASS; 1350 mi->mixer_class = nctls + UAC_OUTPUT; 1351 mi->next = mi->prev = AUDIO_MIXER_LAST; 1352 strcpy(mi->label.name, AudioCoutputs); 1353 return (0); 1354 case UAC_INPUT: 1355 mi->type = AUDIO_MIXER_CLASS; 1356 mi->mixer_class = nctls + UAC_INPUT; 1357 mi->next = mi->prev = AUDIO_MIXER_LAST; 1358 strcpy(mi->label.name, AudioCinputs); 1359 return (0); 1360 case UAC_EQUAL: 1361 mi->type = AUDIO_MIXER_CLASS; 1362 mi->mixer_class = nctls + UAC_EQUAL; 1363 mi->next = mi->prev = AUDIO_MIXER_LAST; 1364 strcpy(mi->label.name, AudioCequalization); 1365 return (0); 1366 default: 1367 return (ENXIO); 1368 } 1369 } 1370 mc = &sc->sc_ctls[n]; 1371 strncpy(mi->label.name, mc->ctlname, MAX_AUDIO_DEV_LEN); 1372 mi->mixer_class = mc->class; 1373 mi->next = mi->prev = AUDIO_MIXER_LAST; /* XXX */ 1374 switch (mc->type) { 1375 case MIX_ON_OFF: 1376 mi->type = AUDIO_MIXER_ENUM; 1377 mi->un.e.num_mem = 2; 1378 strcpy(mi->un.e.member[0].label.name, AudioNoff); 1379 mi->un.e.member[0].ord = 0; 1380 strcpy(mi->un.e.member[1].label.name, AudioNon); 1381 mi->un.e.member[1].ord = 1; 1382 break; 1383 default: 1384 mi->type = AUDIO_MIXER_VALUE; 1385 strncpy(mi->un.v.units.name, mc->ctlunit, MAX_AUDIO_DEV_LEN); 1386 mi->un.v.num_channels = mc->nchan; 1387 break; 1388 } 1389 return (0); 1390 } 1391 1392 int 1393 uaudio_open(addr, flags) 1394 void *addr; 1395 int flags; 1396 { 1397 struct uaudio_softc *sc = addr; 1398 1399 DPRINTF(("uaudio_open: sc=%p\n", sc)); 1400 if (sc->sc_dying) 1401 return (EIO); 1402 1403 if (sc->sc_chan.terminal < 0) 1404 return (ENXIO); 1405 1406 if ((flags & FREAD) && sc->sc_chan.dir != UE_DIR_IN) 1407 return (EACCES); 1408 if ((flags & FWRITE) && sc->sc_chan.dir != UE_DIR_OUT) 1409 return (EACCES); 1410 1411 sc->sc_chan.intr = 0; 1412 1413 return (0); 1414 } 1415 1416 /* 1417 * Close function is called at splaudio(). 1418 */ 1419 void 1420 uaudio_close(addr) 1421 void *addr; 1422 { 1423 struct uaudio_softc *sc = addr; 1424 1425 DPRINTF(("uaudio_close: sc=%p\n", sc)); 1426 uaudio_halt_in_dma(sc); 1427 uaudio_halt_out_dma(sc); 1428 1429 sc->sc_chan.intr = 0; 1430 } 1431 1432 int 1433 uaudio_drain(addr) 1434 void *addr; 1435 { 1436 struct uaudio_softc *sc = addr; 1437 1438 usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES); 1439 1440 return (0); 1441 } 1442 1443 int 1444 uaudio_halt_out_dma(addr) 1445 void *addr; 1446 { 1447 struct uaudio_softc *sc = addr; 1448 1449 DPRINTF(("uaudio_halt_out_dma: enter\n")); 1450 if (sc->sc_chan.pipe != NULL) { 1451 uaudio_chan_close(sc, &sc->sc_chan); 1452 sc->sc_chan.pipe = 0; 1453 uaudio_chan_free_buffers(sc, &sc->sc_chan); 1454 } 1455 return (0); 1456 } 1457 1458 int 1459 uaudio_halt_in_dma(addr) 1460 void *addr; 1461 { 1462 struct uaudio_softc *sc = addr; 1463 1464 DPRINTF(("uaudio_halt_in_dma: enter\n")); 1465 if (sc->sc_chan.pipe != NULL) { 1466 uaudio_chan_close(sc, &sc->sc_chan); 1467 sc->sc_chan.pipe = 0; 1468 uaudio_chan_free_buffers(sc, &sc->sc_chan); 1469 } 1470 return (0); 1471 } 1472 1473 int 1474 uaudio_getdev(addr, retp) 1475 void *addr; 1476 struct audio_device *retp; 1477 { 1478 struct uaudio_softc *sc = addr; 1479 1480 DPRINTF(("uaudio_mixer_getdev:\n")); 1481 if (sc->sc_dying) 1482 return (EIO); 1483 1484 *retp = uaudio_device; 1485 return (0); 1486 } 1487 1488 /* 1489 * Make sure the block size is large enough to hold all outstanding transfers. 1490 */ 1491 int 1492 uaudio_round_blocksize(addr, blk) 1493 void *addr; 1494 int blk; 1495 { 1496 struct uaudio_softc *sc = addr; 1497 int bpf; 1498 1499 bpf = sc->sc_chan.bytes_per_frame + sc->sc_chan.sample_size; 1500 /* XXX */ 1501 bpf *= UAUDIO_NFRAMES * UAUDIO_NCHANBUFS; 1502 1503 bpf = (bpf + 15) &~ 15; 1504 1505 if (blk < bpf) 1506 blk = bpf; 1507 1508 #ifdef DIAGNOSTIC 1509 if (blk <= 0) { 1510 printf("uaudio_round_blocksize: blk=%d\n", blk); 1511 blk = 512; 1512 } 1513 #endif 1514 1515 DPRINTFN(1,("uaudio_round_blocksize: blk=%d\n", blk)); 1516 return (blk); 1517 } 1518 1519 int 1520 uaudio_get_props(addr) 1521 void *addr; 1522 { 1523 struct uaudio_softc *sc = addr; 1524 1525 return (sc->sc_props); 1526 } 1527 1528 int 1529 uaudio_get(sc, which, type, wValue, wIndex, len) 1530 struct uaudio_softc *sc; 1531 int type, which, wValue, wIndex, len; 1532 { 1533 usb_device_request_t req; 1534 u_int8_t data[4]; 1535 usbd_status err; 1536 int val; 1537 1538 if (wValue == -1) 1539 return (0); 1540 1541 req.bmRequestType = type; 1542 req.bRequest = which; 1543 USETW(req.wValue, wValue); 1544 USETW(req.wIndex, wIndex); 1545 USETW(req.wLength, len); 1546 DPRINTFN(2,("uaudio_get: type=0x%02x req=0x%02x wValue=0x%04x " 1547 "wIndex=0x%04x len=%d\n", 1548 type, which, wValue, wIndex, len)); 1549 err = usbd_do_request(sc->sc_udev, &req, &data); 1550 if (err) { 1551 DPRINTF(("uaudio_get: err=%s\n", usbd_errstr(err))); 1552 return (-1); 1553 } 1554 switch (len) { 1555 case 1: 1556 val = data[0]; 1557 break; 1558 case 2: 1559 val = data[0] | (data[1] << 8); 1560 break; 1561 default: 1562 DPRINTF(("uaudio_get: bad length=%d\n", len)); 1563 return (-1); 1564 } 1565 DPRINTFN(2,("uaudio_get: val=%d\n", val)); 1566 return (val); 1567 } 1568 1569 void 1570 uaudio_set(sc, which, type, wValue, wIndex, len, val) 1571 struct uaudio_softc *sc; 1572 int type, which, wValue, wIndex, len, val; 1573 { 1574 usb_device_request_t req; 1575 u_int8_t data[4]; 1576 usbd_status err; 1577 1578 if (wValue == -1) 1579 return; 1580 1581 req.bmRequestType = type; 1582 req.bRequest = which; 1583 USETW(req.wValue, wValue); 1584 USETW(req.wIndex, wIndex); 1585 USETW(req.wLength, len); 1586 switch (len) { 1587 case 1: 1588 data[0] = val; 1589 break; 1590 case 2: 1591 data[0] = val; 1592 data[1] = val >> 8; 1593 break; 1594 default: 1595 return; 1596 } 1597 DPRINTFN(2,("uaudio_set: type=0x%02x req=0x%02x wValue=0x%04x " 1598 "wIndex=0x%04x len=%d, val=%d\n", 1599 type, which, wValue, wIndex, len, val & 0xffff)); 1600 err = usbd_do_request(sc->sc_udev, &req, &data); 1601 #ifdef UAUDIO_DEBUG 1602 if (err) 1603 DPRINTF(("uaudio_set: err=%d\n", err)); 1604 #endif 1605 } 1606 1607 int 1608 uaudio_signext(type, val) 1609 int type, val; 1610 { 1611 if (!MIX_UNSIGNED(type)) { 1612 if (MIX_SIZE(type) == 2) 1613 val = (int16_t)val; 1614 else 1615 val = (int8_t)val; 1616 } 1617 return (val); 1618 } 1619 1620 int 1621 uaudio_value2bsd(mc, val) 1622 struct mixerctl *mc; 1623 int val; 1624 { 1625 DPRINTFN(5, ("uaudio_value2bsd: type=%03x val=%d min=%d max=%d ", 1626 mc->type, val, mc->minval, mc->maxval)); 1627 if (mc->type == MIX_ON_OFF) 1628 val = val != 0; 1629 else 1630 val = (uaudio_signext(mc->type, val) - mc->minval) * 256 1631 / (mc->maxval - mc->minval); 1632 DPRINTFN(5, ("val'=%d\n", val)); 1633 return (val); 1634 } 1635 1636 int 1637 uaudio_bsd2value(mc, val) 1638 struct mixerctl *mc; 1639 int val; 1640 { 1641 DPRINTFN(5,("uaudio_bsd2value: type=%03x val=%d min=%d max=%d ", 1642 mc->type, val, mc->minval, mc->maxval)); 1643 if (mc->type == MIX_ON_OFF) 1644 val = val != 0; 1645 else 1646 val = val * (mc->maxval - mc->minval) / 256 + mc->minval; 1647 DPRINTFN(5, ("val'=%d\n", val)); 1648 return (val); 1649 } 1650 1651 int 1652 uaudio_ctl_get(sc, which, mc, chan) 1653 struct uaudio_softc *sc; 1654 int which; 1655 struct mixerctl *mc; 1656 int chan; 1657 { 1658 int val; 1659 1660 DPRINTFN(5,("uaudio_ctl_get: which=%d chan=%d\n", which, chan)); 1661 val = uaudio_get(sc, which, UT_READ_CLASS_INTERFACE, mc->wValue[chan], 1662 mc->wIndex, MIX_SIZE(mc->type)); 1663 return (uaudio_value2bsd(mc, val)); 1664 } 1665 1666 void 1667 uaudio_ctl_set(sc, which, mc, chan, val) 1668 struct uaudio_softc *sc; 1669 int which; 1670 struct mixerctl *mc; 1671 int chan; 1672 int val; 1673 { 1674 val = uaudio_bsd2value(mc, val); 1675 uaudio_set(sc, which, UT_WRITE_CLASS_INTERFACE, mc->wValue[chan], 1676 mc->wIndex, MIX_SIZE(mc->type), val); 1677 } 1678 1679 int 1680 uaudio_mixer_get_port(addr, cp) 1681 void *addr; 1682 mixer_ctrl_t *cp; 1683 { 1684 struct uaudio_softc *sc = addr; 1685 struct mixerctl *mc; 1686 int i, n, vals[MIX_MAX_CHAN], val; 1687 1688 DPRINTFN(2,("uaudio_mixer_get_port: index=%d\n", cp->dev)); 1689 1690 if (sc->sc_dying) 1691 return (EIO); 1692 1693 n = cp->dev; 1694 if (n < 0 || n >= sc->sc_nctls) 1695 return (ENXIO); 1696 mc = &sc->sc_ctls[n]; 1697 1698 if (mc->type == MIX_ON_OFF) { 1699 if (cp->type != AUDIO_MIXER_ENUM) 1700 return (EINVAL); 1701 cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0); 1702 } else { 1703 if (cp->type != AUDIO_MIXER_VALUE) 1704 return (EINVAL); 1705 if (cp->un.value.num_channels != 1 && 1706 cp->un.value.num_channels != mc->nchan) 1707 return (EINVAL); 1708 for (i = 0; i < mc->nchan; i++) 1709 vals[i] = uaudio_ctl_get(sc, GET_CUR, mc, i); 1710 if (cp->un.value.num_channels == 1 && mc->nchan != 1) { 1711 for (val = 0, i = 0; i < mc->nchan; i++) 1712 val += vals[i]; 1713 vals[0] = val / mc->nchan; 1714 } 1715 for (i = 0; i < cp->un.value.num_channels; i++) 1716 cp->un.value.level[i] = vals[i]; 1717 } 1718 1719 return (0); 1720 } 1721 1722 int 1723 uaudio_mixer_set_port(addr, cp) 1724 void *addr; 1725 mixer_ctrl_t *cp; 1726 { 1727 struct uaudio_softc *sc = addr; 1728 struct mixerctl *mc; 1729 int i, n, vals[MIX_MAX_CHAN]; 1730 1731 DPRINTFN(2,("uaudio_mixer_set_port: index = %d\n", cp->dev)); 1732 if (sc->sc_dying) 1733 return (EIO); 1734 1735 n = cp->dev; 1736 if (n < 0 || n >= sc->sc_nctls) 1737 return (ENXIO); 1738 mc = &sc->sc_ctls[n]; 1739 1740 if (mc->type == MIX_ON_OFF) { 1741 if (cp->type != AUDIO_MIXER_ENUM) 1742 return (EINVAL); 1743 uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord); 1744 } else { 1745 if (cp->type != AUDIO_MIXER_VALUE) 1746 return (EINVAL); 1747 if (cp->un.value.num_channels == 1) 1748 for (i = 0; i < mc->nchan; i++) 1749 vals[i] = cp->un.value.level[0]; 1750 else if (cp->un.value.num_channels == mc->nchan) 1751 for (i = 0; i < mc->nchan; i++) 1752 vals[i] = cp->un.value.level[i]; 1753 else 1754 return (EINVAL); 1755 for (i = 0; i < mc->nchan; i++) 1756 uaudio_ctl_set(sc, SET_CUR, mc, i, vals[i]); 1757 } 1758 return (0); 1759 } 1760 1761 int 1762 uaudio_trigger_input(addr, start, end, blksize, intr, arg, param) 1763 void *addr; 1764 void *start, *end; 1765 int blksize; 1766 void (*intr) __P((void *)); 1767 void *arg; 1768 struct audio_params *param; 1769 { 1770 struct uaudio_softc *sc = addr; 1771 struct chan *ch = &sc->sc_chan; 1772 usbd_status err; 1773 int i, s; 1774 1775 if (sc->sc_dying) 1776 return (EIO); 1777 1778 DPRINTFN(3,("uaudio_trigger_input: sc=%p start=%p end=%p " 1779 "blksize=%d\n", sc, start, end, blksize)); 1780 1781 uaudio_chan_set_param(ch, param, start, end, blksize); 1782 DPRINTFN(3,("uaudio_trigger_input: sample_size=%d bytes/frame=%d " 1783 "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame, 1784 ch->fraction)); 1785 1786 err = uaudio_chan_alloc_buffers(sc, ch); 1787 if (err) 1788 return (EIO); 1789 1790 err = uaudio_chan_open(sc, ch); 1791 if (err) { 1792 uaudio_chan_free_buffers(sc, ch); 1793 return (EIO); 1794 } 1795 1796 sc->sc_chan.intr = intr; 1797 sc->sc_chan.arg = arg; 1798 1799 s = splusb(); 1800 for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */ 1801 uaudio_chan_rtransfer(ch); 1802 splx(s); 1803 1804 return (0); 1805 } 1806 1807 int 1808 uaudio_trigger_output(addr, start, end, blksize, intr, arg, param) 1809 void *addr; 1810 void *start, *end; 1811 int blksize; 1812 void (*intr) __P((void *)); 1813 void *arg; 1814 struct audio_params *param; 1815 { 1816 struct uaudio_softc *sc = addr; 1817 struct chan *ch = &sc->sc_chan; 1818 usbd_status err; 1819 int i, s; 1820 1821 if (sc->sc_dying) 1822 return (EIO); 1823 1824 DPRINTFN(3,("uaudio_trigger_output: sc=%p start=%p end=%p " 1825 "blksize=%d\n", sc, start, end, blksize)); 1826 1827 uaudio_chan_set_param(ch, param, start, end, blksize); 1828 DPRINTFN(3,("uaudio_trigger_output: sample_size=%d bytes/frame=%d " 1829 "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame, 1830 ch->fraction)); 1831 1832 err = uaudio_chan_alloc_buffers(sc, ch); 1833 if (err) 1834 return (EIO); 1835 1836 err = uaudio_chan_open(sc, ch); 1837 if (err) { 1838 uaudio_chan_free_buffers(sc, ch); 1839 return (EIO); 1840 } 1841 1842 sc->sc_chan.intr = intr; 1843 sc->sc_chan.arg = arg; 1844 1845 s = splusb(); 1846 for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */ 1847 uaudio_chan_ptransfer(ch); 1848 splx(s); 1849 1850 return (0); 1851 } 1852 1853 /* Set up a pipe for a channel. */ 1854 usbd_status 1855 uaudio_chan_open(sc, ch) 1856 struct uaudio_softc *sc; 1857 struct chan *ch; 1858 { 1859 struct as_info *as = &sc->sc_alts[sc->sc_curaltidx]; 1860 int endpt = as->edesc->bEndpointAddress; 1861 usbd_status err; 1862 1863 DPRINTF(("uaudio_open_chan: endpt=0x%02x, speed=%d, alt=%d\n", 1864 endpt, ch->sample_rate, as->alt)); 1865 1866 /* Set alternate interface corresponding to the mode. */ 1867 err = usbd_set_interface(sc->sc_as_ifaceh, as->alt); 1868 if (err) 1869 return (err); 1870 1871 /* Some devices do not support this request, so ignore errors. */ 1872 #ifdef UAUDIO_DEBUG 1873 err = uaudio_set_speed(sc, endpt, ch->sample_rate); 1874 if (err) 1875 DPRINTF(("uaudio_chan_open: set_speed failed err=%s\n", 1876 usbd_errstr(err))); 1877 #else 1878 (void)uaudio_set_speed(sc, endpt, ch->sample_rate); 1879 #endif 1880 1881 DPRINTF(("uaudio_open_chan: create pipe to 0x%02x\n", endpt)); 1882 err = usbd_open_pipe(sc->sc_as_ifaceh, endpt, 0, &ch->pipe); 1883 return (err); 1884 } 1885 1886 void 1887 uaudio_chan_close(sc, ch) 1888 struct uaudio_softc *sc; 1889 struct chan *ch; 1890 { 1891 if (sc->sc_nullalt >= 0) { 1892 DPRINTF(("uaudio_close_chan: set null alt=%d\n", 1893 sc->sc_nullalt)); 1894 usbd_set_interface(sc->sc_as_ifaceh, sc->sc_nullalt); 1895 } 1896 usbd_abort_pipe(ch->pipe); 1897 usbd_close_pipe(ch->pipe); 1898 } 1899 1900 usbd_status 1901 uaudio_chan_alloc_buffers(sc, ch) 1902 struct uaudio_softc *sc; 1903 struct chan *ch; 1904 { 1905 usbd_xfer_handle xfer; 1906 void *buf; 1907 int i, size; 1908 1909 size = (ch->bytes_per_frame + ch->sample_size) * UAUDIO_NFRAMES; 1910 for (i = 0; i < UAUDIO_NCHANBUFS; i++) { 1911 xfer = usbd_alloc_xfer(sc->sc_udev); 1912 if (xfer == 0) 1913 goto bad; 1914 ch->chanbufs[i].xfer = xfer; 1915 buf = usbd_alloc_buffer(xfer, size); 1916 if (buf == 0) { 1917 i++; 1918 goto bad; 1919 } 1920 ch->chanbufs[i].buffer = buf; 1921 ch->chanbufs[i].chan = ch; 1922 } 1923 1924 return (USBD_NORMAL_COMPLETION); 1925 1926 bad: 1927 while (--i >= 0) 1928 /* implicit buffer free */ 1929 usbd_free_xfer(ch->chanbufs[i].xfer); 1930 return (USBD_NOMEM); 1931 } 1932 1933 void 1934 uaudio_chan_free_buffers(sc, ch) 1935 struct uaudio_softc *sc; 1936 struct chan *ch; 1937 { 1938 int i; 1939 1940 for (i = 0; i < UAUDIO_NCHANBUFS; i++) 1941 usbd_free_xfer(ch->chanbufs[i].xfer); 1942 } 1943 1944 /* Called at splusb() */ 1945 void 1946 uaudio_chan_ptransfer(ch) 1947 struct chan *ch; 1948 { 1949 struct chanbuf *cb; 1950 int i, n, size, residue, total; 1951 1952 if (ch->sc->sc_dying) 1953 return; 1954 1955 /* Pick the next channel buffer. */ 1956 cb = &ch->chanbufs[ch->curchanbuf]; 1957 if (++ch->curchanbuf >= UAUDIO_NCHANBUFS) 1958 ch->curchanbuf = 0; 1959 1960 /* Compute the size of each frame in the next transfer. */ 1961 residue = ch->residue; 1962 total = 0; 1963 for (i = 0; i < UAUDIO_NFRAMES; i++) { 1964 size = ch->bytes_per_frame; 1965 residue += ch->fraction; 1966 if (residue >= USB_FRAMES_PER_SECOND) { 1967 size += ch->sample_size; 1968 residue -= USB_FRAMES_PER_SECOND; 1969 } 1970 cb->sizes[i] = size; 1971 total += size; 1972 } 1973 ch->residue = residue; 1974 cb->size = total; 1975 1976 /* 1977 * Transfer data from upper layer buffer to channel buffer, taking 1978 * care of wrapping the upper layer buffer. 1979 */ 1980 n = min(total, ch->end - ch->cur); 1981 memcpy(cb->buffer, ch->cur, n); 1982 ch->cur += n; 1983 if (ch->cur >= ch->end) 1984 ch->cur = ch->start; 1985 if (total > n) { 1986 total -= n; 1987 memcpy(cb->buffer + n, ch->cur, total); 1988 ch->cur += total; 1989 } 1990 1991 #ifdef UAUDIO_DEBUG 1992 if (uaudiodebug > 8) { 1993 DPRINTF(("uaudio_chan_ptransfer: buffer=%p, residue=0.%03d\n", 1994 cb->buffer, ch->residue)); 1995 for (i = 0; i < UAUDIO_NFRAMES; i++) { 1996 DPRINTF((" [%d] length %d\n", i, cb->sizes[i])); 1997 } 1998 } 1999 #endif 2000 2001 DPRINTFN(5,("uaudio_chan_transfer: ptransfer xfer=%p\n", cb->xfer)); 2002 /* Fill the request */ 2003 usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes, 2004 UAUDIO_NFRAMES, USBD_NO_COPY, 2005 uaudio_chan_pintr); 2006 2007 (void)usbd_transfer(cb->xfer); 2008 } 2009 2010 void 2011 uaudio_chan_pintr(xfer, priv, status) 2012 usbd_xfer_handle xfer; 2013 usbd_private_handle priv; 2014 usbd_status status; 2015 { 2016 struct chanbuf *cb = priv; 2017 struct chan *ch = cb->chan; 2018 u_int32_t count; 2019 int s; 2020 2021 /* Return if we are aborting. */ 2022 if (status == USBD_CANCELLED) 2023 return; 2024 2025 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 2026 DPRINTFN(5,("uaudio_chan_pintr: count=%d, transferred=%d\n", 2027 count, ch->transferred)); 2028 #ifdef DIAGNOSTIC 2029 if (count != cb->size) { 2030 printf("uaudio_chan_pintr: count(%d) != size(%d)\n", 2031 count, cb->size); 2032 } 2033 #endif 2034 2035 ch->transferred += cb->size; 2036 s = splaudio(); 2037 /* Call back to upper layer */ 2038 while (ch->transferred >= ch->blksize) { 2039 ch->transferred -= ch->blksize; 2040 DPRINTFN(5,("uaudio_chan_pintr: call %p(%p)\n", 2041 ch->intr, ch->arg)); 2042 ch->intr(ch->arg); 2043 } 2044 splx(s); 2045 2046 /* start next transfer */ 2047 uaudio_chan_ptransfer(ch); 2048 } 2049 2050 /* Called at splusb() */ 2051 void 2052 uaudio_chan_rtransfer(ch) 2053 struct chan *ch; 2054 { 2055 struct chanbuf *cb; 2056 int i, size, residue, total; 2057 2058 if (ch->sc->sc_dying) 2059 return; 2060 2061 /* Pick the next channel buffer. */ 2062 cb = &ch->chanbufs[ch->curchanbuf]; 2063 if (++ch->curchanbuf >= UAUDIO_NCHANBUFS) 2064 ch->curchanbuf = 0; 2065 2066 /* Compute the size of each frame in the next transfer. */ 2067 residue = ch->residue; 2068 total = 0; 2069 for (i = 0; i < UAUDIO_NFRAMES; i++) { 2070 size = ch->bytes_per_frame; 2071 residue += ch->fraction; 2072 if (residue >= USB_FRAMES_PER_SECOND) { 2073 size += ch->sample_size; 2074 residue -= USB_FRAMES_PER_SECOND; 2075 } 2076 cb->sizes[i] = size; 2077 total += size; 2078 } 2079 ch->residue = residue; 2080 cb->size = total; 2081 2082 #ifdef UAUDIO_DEBUG 2083 if (uaudiodebug > 8) { 2084 DPRINTF(("uaudio_chan_rtransfer: buffer=%p, residue=0.%03d\n", 2085 cb->buffer, ch->residue)); 2086 for (i = 0; i < UAUDIO_NFRAMES; i++) { 2087 DPRINTF((" [%d] length %d\n", i, cb->sizes[i])); 2088 } 2089 } 2090 #endif 2091 2092 DPRINTFN(5,("uaudio_chan_rtransfer: transfer xfer=%p\n", cb->xfer)); 2093 /* Fill the request */ 2094 usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes, 2095 UAUDIO_NFRAMES, USBD_NO_COPY, 2096 uaudio_chan_rintr); 2097 2098 (void)usbd_transfer(cb->xfer); 2099 } 2100 2101 void 2102 uaudio_chan_rintr(xfer, priv, status) 2103 usbd_xfer_handle xfer; 2104 usbd_private_handle priv; 2105 usbd_status status; 2106 { 2107 struct chanbuf *cb = priv; 2108 struct chan *ch = cb->chan; 2109 u_int32_t count; 2110 int s, n; 2111 2112 /* Return if we are aborting. */ 2113 if (status == USBD_CANCELLED) 2114 return; 2115 2116 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 2117 DPRINTFN(5,("uaudio_chan_rintr: count=%d, transferred=%d\n", 2118 count, ch->transferred)); 2119 #ifdef DIAGNOSTIC 2120 if (count != cb->size) { 2121 printf("uaudio_chan_pintr: count(%d) != size(%d)\n", 2122 count, cb->size); 2123 } 2124 #endif 2125 2126 /* 2127 * Transfer data from channel buffer to upper layer buffer, taking 2128 * care of wrapping the upper layer buffer. 2129 */ 2130 n = min(count, ch->end - ch->cur); 2131 memcpy(ch->cur, cb->buffer, n); 2132 ch->cur += n; 2133 if (ch->cur >= ch->end) 2134 ch->cur = ch->start; 2135 if (count > n) { 2136 memcpy(ch->cur, cb->buffer + n, count - n); 2137 ch->cur += count - n; 2138 } 2139 2140 /* Call back to upper layer */ 2141 ch->transferred += cb->size; 2142 s = splaudio(); 2143 while (ch->transferred >= ch->blksize) { 2144 ch->transferred -= ch->blksize; 2145 DPRINTFN(5,("uaudio_chan_pintr: call %p(%p)\n", 2146 ch->intr, ch->arg)); 2147 ch->intr(ch->arg); 2148 } 2149 splx(s); 2150 2151 /* start next transfer */ 2152 uaudio_chan_rtransfer(ch); 2153 } 2154 2155 void 2156 uaudio_chan_set_param(ch, param, start, end, blksize) 2157 struct chan *ch; 2158 struct audio_params *param; 2159 u_char *start, *end; 2160 int blksize; 2161 { 2162 int samples_per_frame, sample_size; 2163 2164 sample_size = param->precision * param->channels / 8; 2165 samples_per_frame = param->sample_rate / USB_FRAMES_PER_SECOND; 2166 ch->fraction = param->sample_rate % USB_FRAMES_PER_SECOND; 2167 ch->sample_size = sample_size; 2168 ch->sample_rate = param->sample_rate; 2169 ch->bytes_per_frame = samples_per_frame * sample_size; 2170 ch->residue = 0; 2171 2172 ch->start = start; 2173 ch->end = end; 2174 ch->cur = start; 2175 ch->blksize = blksize; 2176 ch->transferred = 0; 2177 2178 ch->curchanbuf = 0; 2179 } 2180 2181 int 2182 uaudio_set_params(addr, setmode, usemode, p, r) 2183 void *addr; 2184 int setmode, usemode; 2185 struct audio_params *p, *r; 2186 { 2187 struct uaudio_softc *sc = addr; 2188 int flags = sc->sc_altflags; 2189 int pfactor, rfactor; 2190 int enc, i, j; 2191 void (*pswcode) __P((void *, u_char *buf, int cnt)); 2192 void (*rswcode) __P((void *, u_char *buf, int cnt)); 2193 2194 if (sc->sc_dying) 2195 return (EIO); 2196 2197 if (sc->sc_chan.pipe != NULL) 2198 return (EBUSY); 2199 2200 pswcode = rswcode = 0; 2201 pfactor = rfactor = 1; 2202 enc = p->encoding; 2203 switch (p->encoding) { 2204 case AUDIO_ENCODING_SLINEAR_BE: 2205 if (p->precision == 16) { 2206 rswcode = pswcode = swap_bytes; 2207 enc = AUDIO_ENCODING_SLINEAR_LE; 2208 } else if (p->precision == 8 && !(flags & HAS_8)) { 2209 pswcode = rswcode = change_sign8; 2210 enc = AUDIO_ENCODING_ULINEAR_LE; 2211 } 2212 break; 2213 case AUDIO_ENCODING_SLINEAR_LE: 2214 if (p->precision == 8 && !(flags & HAS_8)) { 2215 pswcode = rswcode = change_sign8; 2216 enc = AUDIO_ENCODING_ULINEAR_LE; 2217 } 2218 break; 2219 case AUDIO_ENCODING_ULINEAR_BE: 2220 if (p->precision == 16) { 2221 pswcode = swap_bytes_change_sign16_le; 2222 rswcode = change_sign16_swap_bytes_le; 2223 enc = AUDIO_ENCODING_SLINEAR_LE; 2224 } else if (p->precision == 8 && !(flags & HAS_8U)) { 2225 pswcode = rswcode = change_sign8; 2226 enc = AUDIO_ENCODING_SLINEAR_LE; 2227 } 2228 break; 2229 case AUDIO_ENCODING_ULINEAR_LE: 2230 if (p->precision == 16) { 2231 pswcode = rswcode = change_sign16_le; 2232 enc = AUDIO_ENCODING_SLINEAR_LE; 2233 } else if (p->precision == 8 && !(flags & HAS_8U)) { 2234 pswcode = rswcode = change_sign8; 2235 enc = AUDIO_ENCODING_SLINEAR_LE; 2236 } 2237 break; 2238 case AUDIO_ENCODING_ULAW: 2239 if (!(flags & HAS_MULAW)) { 2240 if (flags & HAS_8U) { 2241 pswcode = mulaw_to_ulinear8; 2242 rswcode = ulinear8_to_mulaw; 2243 enc = AUDIO_ENCODING_ULINEAR_LE; 2244 } else if (flags & HAS_8) { 2245 pswcode = mulaw_to_slinear8; 2246 rswcode = slinear8_to_mulaw; 2247 enc = AUDIO_ENCODING_SLINEAR_LE; 2248 #if 0 2249 } else if (flags & HAS_16) { 2250 pswcode = mulaw_to_slinear16_le; 2251 pfactor = 2; 2252 /* XXX recording not handled */ 2253 enc = AUDIO_ENCODING_SLINEAR_LE; 2254 #endif 2255 } else 2256 return (EINVAL); 2257 } 2258 break; 2259 case AUDIO_ENCODING_ALAW: 2260 if (!(flags & HAS_ALAW)) { 2261 if (flags & HAS_8U) { 2262 pswcode = alaw_to_ulinear8; 2263 rswcode = ulinear8_to_alaw; 2264 enc = AUDIO_ENCODING_ULINEAR_LE; 2265 } else if (flags & HAS_8) { 2266 pswcode = alaw_to_slinear8; 2267 rswcode = slinear8_to_alaw; 2268 enc = AUDIO_ENCODING_SLINEAR_LE; 2269 #if 0 2270 } else if (flags & HAS_16) { 2271 pswcode = alaw_to_slinear16_le; 2272 pfactor = 2; 2273 /* XXX recording not handled */ 2274 enc = AUDIO_ENCODING_SLINEAR_LE; 2275 #endif 2276 } else 2277 return (EINVAL); 2278 } 2279 break; 2280 default: 2281 return (EINVAL); 2282 } 2283 /* XXX do some other conversions... */ 2284 2285 DPRINTF(("uaudio_set_params: chan=%d prec=%d enc=%d rate=%ld\n", 2286 p->channels, p->precision, enc, p->sample_rate)); 2287 2288 for (i = 0; i < sc->sc_nalts; i++) { 2289 struct usb_audio_streaming_type1_descriptor *a1d = 2290 sc->sc_alts[i].asf1desc; 2291 if (p->channels == a1d->bNrChannels && 2292 p->precision ==a1d->bBitResolution && 2293 enc == sc->sc_alts[i].encoding) { 2294 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) { 2295 DPRINTFN(2,("uaudio_set_params: cont %d-%d\n", 2296 UA_SAMP_LO(a1d), UA_SAMP_HI(a1d))); 2297 if (UA_SAMP_LO(a1d) < p->sample_rate && 2298 p->sample_rate < UA_SAMP_HI(a1d)) 2299 goto found; 2300 } else { 2301 for (j = 0; j < a1d->bSamFreqType; j++) { 2302 DPRINTFN(2,("uaudio_set_params: disc #" 2303 "%d: %d\n", j, UA_GETSAMP(a1d, j))); 2304 /* XXX allow for some slack */ 2305 if (UA_GETSAMP(a1d, j) == 2306 p->sample_rate) 2307 goto found; 2308 } 2309 } 2310 } 2311 } 2312 return (EINVAL); 2313 2314 found: 2315 p->sw_code = pswcode; 2316 r->sw_code = rswcode; 2317 p->factor = pfactor; 2318 r->factor = rfactor; 2319 sc->sc_curaltidx = i; 2320 2321 DPRINTF(("uaudio_set_params: use altidx=%d, altno=%d\n", 2322 sc->sc_curaltidx, 2323 sc->sc_alts[sc->sc_curaltidx].idesc->bAlternateSetting)); 2324 2325 return (0); 2326 } 2327 2328 usbd_status 2329 uaudio_set_speed(sc, endpt, speed) 2330 struct uaudio_softc *sc; 2331 int endpt; 2332 u_int speed; 2333 { 2334 usb_device_request_t req; 2335 u_int8_t data[3]; 2336 2337 DPRINTFN(5,("uaudio_set_speed: endpt=%d speed=%u\n", endpt, speed)); 2338 req.bmRequestType = UT_WRITE_CLASS_ENDPOINT; 2339 req.bRequest = SET_CUR; 2340 USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0); 2341 USETW(req.wIndex, endpt); 2342 USETW(req.wLength, 3); 2343 data[0] = speed; 2344 data[1] = speed >> 8; 2345 data[2] = speed >> 16; 2346 2347 return (usbd_do_request(sc->sc_udev, &req, &data)); 2348 } 2349 2350
Indexes created Tue Sep 23 14:10:03 GMT 2025