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