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