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