uaudio.c revision 1.82
1 /* $NetBSD: uaudio.c,v 1.82 2004/10/21 12:41:07 kent Exp $ */ 2 3 /* 4 * Copyright (c) 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (lennart (at) augustsson.net) at 9 * Carlstedt Research & Technology. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf 42 * http://www.usb.org/developers/devclass_docs/frmts10.pdf 43 * http://www.usb.org/developers/devclass_docs/termt10.pdf 44 */ 45 46 #include <sys/cdefs.h> 47 __KERNEL_RCSID(0, "$NetBSD: uaudio.c,v 1.82 2004/10/21 12:41:07 kent Exp $"); 48 49 #include <sys/param.h> 50 #include <sys/systm.h> 51 #include <sys/kernel.h> 52 #include <sys/malloc.h> 53 #include <sys/device.h> 54 #include <sys/ioctl.h> 55 #include <sys/tty.h> 56 #include <sys/file.h> 57 #include <sys/reboot.h> /* for bootverbose */ 58 #include <sys/select.h> 59 #include <sys/proc.h> 60 #include <sys/vnode.h> 61 #include <sys/device.h> 62 #include <sys/poll.h> 63 64 #include <sys/audioio.h> 65 #include <dev/audio_if.h> 66 #include <dev/audiovar.h> 67 #include <dev/mulaw.h> 68 #include <dev/auconv.h> 69 70 #include <dev/usb/usb.h> 71 #include <dev/usb/usbdi.h> 72 #include <dev/usb/usbdi_util.h> 73 #include <dev/usb/usb_quirks.h> 74 75 #include <dev/usb/uaudioreg.h> 76 77 /* #define UAUDIO_DEBUG */ 78 /* #define UAUDIO_MULTIPLE_ENDPOINTS */ 79 #ifdef UAUDIO_DEBUG 80 #define DPRINTF(x) if (uaudiodebug) logprintf x 81 #define DPRINTFN(n,x) if (uaudiodebug>(n)) logprintf x 82 int uaudiodebug = 0; 83 #else 84 #define DPRINTF(x) 85 #define DPRINTFN(n,x) 86 #endif 87 88 #define UAUDIO_NCHANBUFS 6 /* number of outstanding request */ 89 #define UAUDIO_NFRAMES 10 /* ms of sound in each request */ 90 91 92 #define MIX_MAX_CHAN 8 93 struct mixerctl { 94 u_int16_t wValue[MIX_MAX_CHAN]; /* using nchan */ 95 u_int16_t wIndex; 96 u_int8_t nchan; 97 u_int8_t type; 98 #define MIX_ON_OFF 1 99 #define MIX_SIGNED_16 2 100 #define MIX_UNSIGNED_16 3 101 #define MIX_SIGNED_8 4 102 #define MIX_SELECTOR 5 103 #define MIX_SIZE(n) ((n) == MIX_SIGNED_16 || (n) == MIX_UNSIGNED_16 ? 2 : 1) 104 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16) 105 int minval, maxval; 106 u_int delta; 107 u_int mul; 108 u_int8_t class; 109 char ctlname[MAX_AUDIO_DEV_LEN]; 110 char *ctlunit; 111 }; 112 #define MAKE(h,l) (((h) << 8) | (l)) 113 114 struct as_info { 115 u_int8_t alt; 116 u_int8_t encoding; 117 u_int8_t attributes; /* Copy of bmAttributes of 118 * usb_audio_streaming_endpoint_descriptor 119 */ 120 usbd_interface_handle ifaceh; 121 const usb_interface_descriptor_t *idesc; 122 const usb_endpoint_descriptor_audio_t *edesc; 123 const usb_endpoint_descriptor_audio_t *edesc1; 124 const struct usb_audio_streaming_type1_descriptor *asf1desc; 125 int sc_busy; /* currently used */ 126 }; 127 128 struct chan { 129 void (*intr)(void *); /* DMA completion intr handler */ 130 void *arg; /* arg for intr() */ 131 usbd_pipe_handle pipe; 132 133 u_int sample_size; 134 u_int sample_rate; 135 u_int bytes_per_frame; 136 u_int fraction; /* fraction/1000 is the extra samples/frame */ 137 u_int residue; /* accumulates the fractional samples */ 138 139 u_char *start; /* upper layer buffer start */ 140 u_char *end; /* upper layer buffer end */ 141 u_char *cur; /* current position in upper layer buffer */ 142 int blksize; /* chunk size to report up */ 143 int transferred; /* transferred bytes not reported up */ 144 145 int altidx; /* currently used altidx */ 146 147 int curchanbuf; 148 struct chanbuf { 149 struct chan *chan; 150 usbd_xfer_handle xfer; 151 u_char *buffer; 152 u_int16_t sizes[UAUDIO_NFRAMES]; 153 u_int16_t offsets[UAUDIO_NFRAMES]; 154 u_int16_t size; 155 } chanbufs[UAUDIO_NCHANBUFS]; 156 157 struct uaudio_softc *sc; /* our softc */ 158 }; 159 160 struct uaudio_softc { 161 USBBASEDEVICE sc_dev; /* base device */ 162 usbd_device_handle sc_udev; /* USB device */ 163 164 int sc_ac_iface; /* Audio Control interface */ 165 usbd_interface_handle sc_ac_ifaceh; 166 167 struct chan sc_playchan; /* play channel */ 168 struct chan sc_recchan; /* record channel */ 169 170 int sc_nullalt; 171 172 int sc_audio_rev; 173 174 struct as_info *sc_alts; 175 int sc_nalts; 176 177 int sc_altflags; 178 #define HAS_8 0x01 179 #define HAS_16 0x02 180 #define HAS_8U 0x04 181 #define HAS_ALAW 0x08 182 #define HAS_MULAW 0x10 183 #define UA_NOFRAC 0x20 /* don't do sample rate adjustment */ 184 #define HAS_24 0x40 185 186 int sc_mode; /* play/record capability */ 187 188 struct mixerctl *sc_ctls; 189 int sc_nctls; 190 191 device_ptr_t sc_audiodev; 192 char sc_dying; 193 }; 194 195 struct terminal_list { 196 int size; 197 uint16_t terminals[1]; 198 }; 199 #define TERMINAL_LIST_SIZE(N) (offsetof(struct terminal_list, terminals) \ 200 + sizeof(uint16_t) * (N)) 201 202 struct io_terminal { 203 union { 204 const usb_descriptor_t *desc; 205 const struct usb_audio_input_terminal *it; 206 const struct usb_audio_output_terminal *ot; 207 const struct usb_audio_mixer_unit *mu; 208 const struct usb_audio_selector_unit *su; 209 const struct usb_audio_feature_unit *fu; 210 const struct usb_audio_processing_unit *pu; 211 const struct usb_audio_extension_unit *eu; 212 } d; 213 int inputs_size; 214 struct terminal_list **inputs; /* list of source input terminals */ 215 struct terminal_list *output; /* list of destination output terminals */ 216 int direct; /* direcly connected to an output terminal */ 217 }; 218 219 #define UAC_OUTPUT 0 220 #define UAC_INPUT 1 221 #define UAC_EQUAL 2 222 #define UAC_RECORD 3 223 #define UAC_NCLASSES 4 224 #ifdef UAUDIO_DEBUG 225 Static const char *uac_names[] = { 226 AudioCoutputs, AudioCinputs, AudioCequalization, AudioCrecord, 227 }; 228 #endif 229 230 Static usbd_status uaudio_identify_ac(struct uaudio_softc *, 231 const usb_config_descriptor_t *); 232 Static usbd_status uaudio_identify_as(struct uaudio_softc *, 233 const usb_config_descriptor_t *); 234 Static usbd_status uaudio_process_as(struct uaudio_softc *, 235 const char *, int *, int, 236 const usb_interface_descriptor_t *); 237 238 Static void uaudio_add_alt(struct uaudio_softc *, const struct as_info *); 239 240 Static const usb_interface_descriptor_t *uaudio_find_iface 241 (const char *, int, int *, int); 242 243 Static void uaudio_mixer_add_ctl(struct uaudio_softc *, struct mixerctl *); 244 Static char *uaudio_id_name(struct uaudio_softc *, 245 const struct io_terminal *, int); 246 Static struct usb_audio_cluster uaudio_get_cluster(int, 247 const struct io_terminal *); 248 Static void uaudio_add_input(struct uaudio_softc *, 249 const struct io_terminal *, int); 250 Static void uaudio_add_output(struct uaudio_softc *, 251 const struct io_terminal *, int); 252 Static void uaudio_add_mixer(struct uaudio_softc *, 253 const struct io_terminal *, int); 254 Static void uaudio_add_selector(struct uaudio_softc *, 255 const struct io_terminal *, int); 256 #ifdef UAUDIO_DEBUG 257 Static const char *uaudio_get_terminal_name(int); 258 #endif 259 Static int uaudio_determine_class(const struct io_terminal *, 260 struct mixerctl *); 261 Static const char *uaudio_feature_name(const struct io_terminal *, 262 struct mixerctl *); 263 Static void uaudio_add_feature(struct uaudio_softc *, 264 const struct io_terminal *, int); 265 Static void uaudio_add_processing_updown(struct uaudio_softc *, 266 const struct io_terminal *, int); 267 Static void uaudio_add_processing(struct uaudio_softc *, 268 const struct io_terminal *, int); 269 Static void uaudio_add_extension(struct uaudio_softc *, 270 const struct io_terminal *, int); 271 Static struct terminal_list *uaudio_merge_terminal_list 272 (const struct io_terminal *); 273 Static struct terminal_list *uaudio_io_terminaltype(int, 274 struct io_terminal *, int); 275 Static usbd_status uaudio_identify(struct uaudio_softc *, 276 const usb_config_descriptor_t *); 277 278 Static int uaudio_signext(int, int); 279 Static int uaudio_value2bsd(struct mixerctl *, int); 280 Static int uaudio_bsd2value(struct mixerctl *, int); 281 Static int uaudio_get(struct uaudio_softc *, int, int, int, int, int); 282 Static int uaudio_ctl_get(struct uaudio_softc *, int, 283 struct mixerctl *, int); 284 Static void uaudio_set(struct uaudio_softc *, int, 285 int, int, int, int, int); 286 Static void uaudio_ctl_set(struct uaudio_softc *, int, 287 struct mixerctl *, int, int); 288 289 Static usbd_status uaudio_set_speed(struct uaudio_softc *, int, u_int); 290 291 Static usbd_status uaudio_chan_open(struct uaudio_softc *, struct chan *); 292 Static void uaudio_chan_close(struct uaudio_softc *, struct chan *); 293 Static usbd_status uaudio_chan_alloc_buffers(struct uaudio_softc *, 294 struct chan *); 295 Static void uaudio_chan_free_buffers(struct uaudio_softc *, struct chan *); 296 Static void uaudio_chan_init(struct chan *, int, 297 const struct audio_params *, int); 298 Static void uaudio_chan_set_param(struct chan *, u_char *, u_char *, int); 299 Static void uaudio_chan_ptransfer(struct chan *); 300 Static void uaudio_chan_pintr(usbd_xfer_handle, 301 usbd_private_handle, usbd_status); 302 303 Static void uaudio_chan_rtransfer(struct chan *); 304 Static void uaudio_chan_rintr(usbd_xfer_handle, 305 usbd_private_handle, usbd_status); 306 307 Static int uaudio_open(void *, int); 308 Static void uaudio_close(void *); 309 Static int uaudio_drain(void *); 310 Static int uaudio_query_encoding(void *, struct audio_encoding *); 311 Static void uaudio_get_minmax_rates(int, const struct as_info *, 312 const struct audio_params *, 313 int, u_long *, u_long *); 314 Static int uaudio_match_alt_sub(int, const struct as_info *, 315 const struct audio_params *, int, u_long); 316 Static int uaudio_match_alt_chan(int, const struct as_info *, 317 struct audio_params *, int); 318 Static int uaudio_match_alt(int, const struct as_info *, 319 struct audio_params *, int); 320 Static int uaudio_set_params(void *, int, int, struct audio_params *, 321 struct audio_params *); 322 Static int uaudio_round_blocksize(void *, int); 323 Static int uaudio_trigger_output(void *, void *, void *, int, 324 void (*)(void *), void *, struct audio_params *); 325 Static int uaudio_trigger_input (void *, void *, void *, int, 326 void (*)(void *), void *, struct audio_params *); 327 Static int uaudio_halt_in_dma(void *); 328 Static int uaudio_halt_out_dma(void *); 329 Static int uaudio_getdev(void *, struct audio_device *); 330 Static int uaudio_mixer_set_port(void *, mixer_ctrl_t *); 331 Static int uaudio_mixer_get_port(void *, mixer_ctrl_t *); 332 Static int uaudio_query_devinfo(void *, mixer_devinfo_t *); 333 Static int uaudio_get_props(void *); 334 335 Static struct audio_hw_if uaudio_hw_if = { 336 uaudio_open, 337 uaudio_close, 338 uaudio_drain, 339 uaudio_query_encoding, 340 uaudio_set_params, 341 uaudio_round_blocksize, 342 NULL, 343 NULL, 344 NULL, 345 NULL, 346 NULL, 347 uaudio_halt_out_dma, 348 uaudio_halt_in_dma, 349 NULL, 350 uaudio_getdev, 351 NULL, 352 uaudio_mixer_set_port, 353 uaudio_mixer_get_port, 354 uaudio_query_devinfo, 355 NULL, 356 NULL, 357 NULL, 358 NULL, 359 uaudio_get_props, 360 uaudio_trigger_output, 361 uaudio_trigger_input, 362 NULL, 363 }; 364 365 Static struct audio_device uaudio_device = { 366 "USB audio", 367 "", 368 "uaudio" 369 }; 370 371 USB_DECLARE_DRIVER(uaudio); 372 373 USB_MATCH(uaudio) 374 { 375 USB_MATCH_START(uaudio, uaa); 376 usb_interface_descriptor_t *id; 377 378 if (uaa->iface == NULL) 379 return (UMATCH_NONE); 380 381 id = usbd_get_interface_descriptor(uaa->iface); 382 /* Trigger on the control interface. */ 383 if (id == NULL || 384 id->bInterfaceClass != UICLASS_AUDIO || 385 id->bInterfaceSubClass != UISUBCLASS_AUDIOCONTROL || 386 (usbd_get_quirks(uaa->device)->uq_flags & UQ_BAD_AUDIO)) 387 return (UMATCH_NONE); 388 389 return (UMATCH_IFACECLASS_IFACESUBCLASS); 390 } 391 392 USB_ATTACH(uaudio) 393 { 394 USB_ATTACH_START(uaudio, sc, uaa); 395 usb_interface_descriptor_t *id; 396 usb_config_descriptor_t *cdesc; 397 char devinfo[1024]; 398 usbd_status err; 399 int i, j, found; 400 401 usbd_devinfo(uaa->device, 0, devinfo, sizeof(devinfo)); 402 printf(": %s\n", devinfo); 403 404 sc->sc_udev = uaa->device; 405 406 cdesc = usbd_get_config_descriptor(sc->sc_udev); 407 if (cdesc == NULL) { 408 printf("%s: failed to get configuration descriptor\n", 409 USBDEVNAME(sc->sc_dev)); 410 USB_ATTACH_ERROR_RETURN; 411 } 412 413 err = uaudio_identify(sc, cdesc); 414 if (err) { 415 printf("%s: audio descriptors make no sense, error=%d\n", 416 USBDEVNAME(sc->sc_dev), err); 417 USB_ATTACH_ERROR_RETURN; 418 } 419 420 sc->sc_ac_ifaceh = uaa->iface; 421 /* Pick up the AS interface. */ 422 for (i = 0; i < uaa->nifaces; i++) { 423 if (uaa->ifaces[i] == NULL) 424 continue; 425 id = usbd_get_interface_descriptor(uaa->ifaces[i]); 426 if (id == NULL) 427 continue; 428 found = 0; 429 for (j = 0; j < sc->sc_nalts; j++) { 430 if (id->bInterfaceNumber == 431 sc->sc_alts[j].idesc->bInterfaceNumber) { 432 sc->sc_alts[j].ifaceh = uaa->ifaces[i]; 433 found = 1; 434 } 435 } 436 if (found) 437 uaa->ifaces[i] = NULL; 438 } 439 440 for (j = 0; j < sc->sc_nalts; j++) { 441 if (sc->sc_alts[j].ifaceh == NULL) { 442 printf("%s: alt %d missing AS interface(s)\n", 443 USBDEVNAME(sc->sc_dev), j); 444 USB_ATTACH_ERROR_RETURN; 445 } 446 } 447 448 printf("%s: audio rev %d.%02x\n", USBDEVNAME(sc->sc_dev), 449 sc->sc_audio_rev >> 8, sc->sc_audio_rev & 0xff); 450 451 sc->sc_playchan.sc = sc->sc_recchan.sc = sc; 452 sc->sc_playchan.altidx = -1; 453 sc->sc_recchan.altidx = -1; 454 455 if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_FRAC) 456 sc->sc_altflags |= UA_NOFRAC; 457 458 #ifndef UAUDIO_DEBUG 459 if (bootverbose) 460 #endif 461 printf("%s: %d mixer controls\n", USBDEVNAME(sc->sc_dev), 462 sc->sc_nctls); 463 464 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 465 USBDEV(sc->sc_dev)); 466 467 DPRINTF(("uaudio_attach: doing audio_attach_mi\n")); 468 #if defined(__OpenBSD__) 469 audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev); 470 #else 471 sc->sc_audiodev = audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev); 472 #endif 473 474 USB_ATTACH_SUCCESS_RETURN; 475 } 476 477 int 478 uaudio_activate(device_ptr_t self, enum devact act) 479 { 480 struct uaudio_softc *sc = (struct uaudio_softc *)self; 481 int rv = 0; 482 483 switch (act) { 484 case DVACT_ACTIVATE: 485 return (EOPNOTSUPP); 486 break; 487 488 case DVACT_DEACTIVATE: 489 if (sc->sc_audiodev != NULL) 490 rv = config_deactivate(sc->sc_audiodev); 491 sc->sc_dying = 1; 492 break; 493 } 494 return (rv); 495 } 496 497 int 498 uaudio_detach(device_ptr_t self, int flags) 499 { 500 struct uaudio_softc *sc = (struct uaudio_softc *)self; 501 int rv = 0; 502 503 /* Wait for outstanding requests to complete. */ 504 usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES); 505 506 if (sc->sc_audiodev != NULL) 507 rv = config_detach(sc->sc_audiodev, flags); 508 509 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 510 USBDEV(sc->sc_dev)); 511 512 return (rv); 513 } 514 515 int 516 uaudio_query_encoding(void *addr, struct audio_encoding *fp) 517 { 518 struct uaudio_softc *sc = addr; 519 int flags = sc->sc_altflags; 520 int idx; 521 522 if (sc->sc_dying) 523 return (EIO); 524 525 if (sc->sc_nalts == 0 || flags == 0) 526 return (ENXIO); 527 528 idx = fp->index; 529 switch (idx) { 530 case 0: 531 strlcpy(fp->name, AudioEulinear, sizeof(fp->name)); 532 fp->encoding = AUDIO_ENCODING_ULINEAR; 533 fp->precision = 8; 534 fp->flags = flags&HAS_8U ? 0 : AUDIO_ENCODINGFLAG_EMULATED; 535 return (0); 536 case 1: 537 strlcpy(fp->name, AudioEmulaw, sizeof(fp->name)); 538 fp->encoding = AUDIO_ENCODING_ULAW; 539 fp->precision = 8; 540 fp->flags = flags&HAS_MULAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED; 541 return (0); 542 case 2: 543 strlcpy(fp->name, AudioEalaw, sizeof(fp->name)); 544 fp->encoding = AUDIO_ENCODING_ALAW; 545 fp->precision = 8; 546 fp->flags = flags&HAS_ALAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED; 547 return (0); 548 case 3: 549 strlcpy(fp->name, AudioEslinear, sizeof(fp->name)); 550 fp->encoding = AUDIO_ENCODING_SLINEAR; 551 fp->precision = 8; 552 fp->flags = flags&HAS_8 ? 0 : AUDIO_ENCODINGFLAG_EMULATED; 553 return (0); 554 case 4: 555 strlcpy(fp->name, AudioEslinear_le, sizeof(fp->name)); 556 fp->encoding = AUDIO_ENCODING_SLINEAR_LE; 557 fp->precision = 16; 558 fp->flags = 0; 559 return (0); 560 case 5: 561 strlcpy(fp->name, AudioEulinear_le, sizeof(fp->name)); 562 fp->encoding = AUDIO_ENCODING_ULINEAR_LE; 563 fp->precision = 16; 564 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 565 return (0); 566 case 6: 567 strlcpy(fp->name, AudioEslinear_be, sizeof(fp->name)); 568 fp->encoding = AUDIO_ENCODING_SLINEAR_BE; 569 fp->precision = 16; 570 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 571 return (0); 572 case 7: 573 strlcpy(fp->name, AudioEulinear_be, sizeof(fp->name)); 574 fp->encoding = AUDIO_ENCODING_ULINEAR_BE; 575 fp->precision = 16; 576 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 577 return (0); 578 default: 579 return (EINVAL); 580 } 581 } 582 583 const usb_interface_descriptor_t * 584 uaudio_find_iface(const char *buf, int size, int *offsp, int subtype) 585 { 586 const usb_interface_descriptor_t *d; 587 588 while (*offsp < size) { 589 d = (const void *)(buf + *offsp); 590 *offsp += d->bLength; 591 if (d->bDescriptorType == UDESC_INTERFACE && 592 d->bInterfaceClass == UICLASS_AUDIO && 593 d->bInterfaceSubClass == subtype) 594 return (d); 595 } 596 return (NULL); 597 } 598 599 void 600 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct mixerctl *mc) 601 { 602 int res; 603 size_t len = sizeof(*mc) * (sc->sc_nctls + 1); 604 struct mixerctl *nmc = sc->sc_nctls == 0 ? 605 malloc(len, M_USBDEV, M_NOWAIT) : 606 realloc(sc->sc_ctls, len, M_USBDEV, M_NOWAIT); 607 608 if (mc->class < UAC_NCLASSES) { 609 DPRINTF(("%s: adding %s.%s\n", 610 __func__, uac_names[mc->class], mc->ctlname)); 611 } else { 612 DPRINTF(("%s: adding %s\n", __func__, mc->ctlname)); 613 } 614 if (nmc == NULL) { 615 printf("uaudio_mixer_add_ctl: no memory\n"); 616 return; 617 } 618 sc->sc_ctls = nmc; 619 620 mc->delta = 0; 621 if (mc->type == MIX_ON_OFF) { 622 mc->minval = 0; 623 mc->maxval = 1; 624 } else if (mc->type == MIX_SELECTOR) { 625 ; 626 } else { 627 /* Determine min and max values. */ 628 mc->minval = uaudio_signext(mc->type, 629 uaudio_get(sc, GET_MIN, UT_READ_CLASS_INTERFACE, 630 mc->wValue[0], mc->wIndex, 631 MIX_SIZE(mc->type))); 632 mc->maxval = 1 + uaudio_signext(mc->type, 633 uaudio_get(sc, GET_MAX, UT_READ_CLASS_INTERFACE, 634 mc->wValue[0], mc->wIndex, 635 MIX_SIZE(mc->type))); 636 mc->mul = mc->maxval - mc->minval; 637 if (mc->mul == 0) 638 mc->mul = 1; 639 res = uaudio_get(sc, GET_RES, UT_READ_CLASS_INTERFACE, 640 mc->wValue[0], mc->wIndex, 641 MIX_SIZE(mc->type)); 642 if (res > 0) 643 mc->delta = (res * 255 + mc->mul/2) / mc->mul; 644 } 645 646 sc->sc_ctls[sc->sc_nctls++] = *mc; 647 648 #ifdef UAUDIO_DEBUG 649 if (uaudiodebug > 2) { 650 int i; 651 DPRINTF(("uaudio_mixer_add_ctl: wValue=%04x",mc->wValue[0])); 652 for (i = 1; i < mc->nchan; i++) 653 DPRINTF((",%04x", mc->wValue[i])); 654 DPRINTF((" wIndex=%04x type=%d name='%s' unit='%s' " 655 "min=%d max=%d\n", 656 mc->wIndex, mc->type, mc->ctlname, mc->ctlunit, 657 mc->minval, mc->maxval)); 658 } 659 #endif 660 } 661 662 char * 663 uaudio_id_name(struct uaudio_softc *sc, const struct io_terminal *iot, int id) 664 { 665 static char buf[32]; 666 snprintf(buf, sizeof(buf), "i%d", id); 667 return (buf); 668 } 669 670 struct usb_audio_cluster 671 uaudio_get_cluster(int id, const struct io_terminal *iot) 672 { 673 struct usb_audio_cluster r; 674 const usb_descriptor_t *dp; 675 int i; 676 677 for (i = 0; i < 25; i++) { /* avoid infinite loops */ 678 dp = iot[id].d.desc; 679 if (dp == 0) 680 goto bad; 681 switch (dp->bDescriptorSubtype) { 682 case UDESCSUB_AC_INPUT: 683 r.bNrChannels = iot[id].d.it->bNrChannels; 684 USETW(r.wChannelConfig, UGETW(iot[id].d.it->wChannelConfig)); 685 r.iChannelNames = iot[id].d.it->iChannelNames; 686 return (r); 687 case UDESCSUB_AC_OUTPUT: 688 id = iot[id].d.ot->bSourceId; 689 break; 690 case UDESCSUB_AC_MIXER: 691 r = *(struct usb_audio_cluster *) 692 &iot[id].d.mu->baSourceId[iot[id].d.mu->bNrInPins]; 693 return (r); 694 case UDESCSUB_AC_SELECTOR: 695 /* XXX This is not really right */ 696 id = iot[id].d.su->baSourceId[0]; 697 break; 698 case UDESCSUB_AC_FEATURE: 699 id = iot[id].d.fu->bSourceId; 700 break; 701 case UDESCSUB_AC_PROCESSING: 702 r = *(struct usb_audio_cluster *) 703 &iot[id].d.pu->baSourceId[iot[id].d.pu->bNrInPins]; 704 return (r); 705 case UDESCSUB_AC_EXTENSION: 706 r = *(struct usb_audio_cluster *) 707 &iot[id].d.eu->baSourceId[iot[id].d.eu->bNrInPins]; 708 return (r); 709 default: 710 goto bad; 711 } 712 } 713 bad: 714 printf("uaudio_get_cluster: bad data\n"); 715 memset(&r, 0, sizeof r); 716 return (r); 717 718 } 719 720 void 721 uaudio_add_input(struct uaudio_softc *sc, const struct io_terminal *iot, int id) 722 { 723 #ifdef UAUDIO_DEBUG 724 const struct usb_audio_input_terminal *d = iot[id].d.it; 725 726 DPRINTFN(2,("uaudio_add_input: bTerminalId=%d wTerminalType=0x%04x " 727 "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d " 728 "iChannelNames=%d iTerminal=%d\n", 729 d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal, 730 d->bNrChannels, UGETW(d->wChannelConfig), 731 d->iChannelNames, d->iTerminal)); 732 #endif 733 } 734 735 void 736 uaudio_add_output(struct uaudio_softc *sc, const struct io_terminal *iot, int id) 737 { 738 #ifdef UAUDIO_DEBUG 739 const struct usb_audio_output_terminal *d = iot[id].d.ot; 740 741 DPRINTFN(2,("uaudio_add_output: bTerminalId=%d wTerminalType=0x%04x " 742 "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n", 743 d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal, 744 d->bSourceId, d->iTerminal)); 745 #endif 746 } 747 748 void 749 uaudio_add_mixer(struct uaudio_softc *sc, const struct io_terminal *iot, int id) 750 { 751 const struct usb_audio_mixer_unit *d = iot[id].d.mu; 752 struct usb_audio_mixer_unit_1 *d1; 753 int c, chs, ichs, ochs, i, o, bno, p, mo, mc, k; 754 uByte *bm; 755 struct mixerctl mix; 756 757 DPRINTFN(2,("uaudio_add_mixer: bUnitId=%d bNrInPins=%d\n", 758 d->bUnitId, d->bNrInPins)); 759 760 /* Compute the number of input channels */ 761 ichs = 0; 762 for (i = 0; i < d->bNrInPins; i++) 763 ichs += uaudio_get_cluster(d->baSourceId[i], iot).bNrChannels; 764 765 /* and the number of output channels */ 766 d1 = (struct usb_audio_mixer_unit_1 *)&d->baSourceId[d->bNrInPins]; 767 ochs = d1->bNrChannels; 768 DPRINTFN(2,("uaudio_add_mixer: ichs=%d ochs=%d\n", ichs, ochs)); 769 770 bm = d1->bmControls; 771 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 772 uaudio_determine_class(&iot[id], &mix); 773 mix.type = MIX_SIGNED_16; 774 mix.ctlunit = AudioNvolume; 775 #define BIT(bno) ((bm[bno / 8] >> (7 - bno % 8)) & 1) 776 for (p = i = 0; i < d->bNrInPins; i++) { 777 chs = uaudio_get_cluster(d->baSourceId[i], iot).bNrChannels; 778 mc = 0; 779 for (c = 0; c < chs; c++) { 780 mo = 0; 781 for (o = 0; o < ochs; o++) { 782 bno = (p + c) * ochs + o; 783 if (BIT(bno)) 784 mo++; 785 } 786 if (mo == 1) 787 mc++; 788 } 789 if (mc == chs && chs <= MIX_MAX_CHAN) { 790 k = 0; 791 for (c = 0; c < chs; c++) 792 for (o = 0; o < ochs; o++) { 793 bno = (p + c) * ochs + o; 794 if (BIT(bno)) 795 mix.wValue[k++] = 796 MAKE(p+c+1, o+1); 797 } 798 snprintf(mix.ctlname, sizeof(mix.ctlname), "mix%d-%s", 799 d->bUnitId, uaudio_id_name(sc, iot, 800 d->baSourceId[i])); 801 mix.nchan = chs; 802 uaudio_mixer_add_ctl(sc, &mix); 803 } else { 804 /* XXX */ 805 } 806 #undef BIT 807 p += chs; 808 } 809 810 } 811 812 void 813 uaudio_add_selector(struct uaudio_softc *sc, const struct io_terminal *iot, int id) 814 { 815 const struct usb_audio_selector_unit *d = iot[id].d.su; 816 struct mixerctl mix; 817 int i, wp; 818 819 DPRINTFN(2,("uaudio_add_selector: bUnitId=%d bNrInPins=%d\n", 820 d->bUnitId, d->bNrInPins)); 821 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 822 mix.wValue[0] = MAKE(0, 0); 823 uaudio_determine_class(&iot[id], &mix); 824 mix.nchan = 1; 825 mix.type = MIX_SELECTOR; 826 mix.ctlunit = ""; 827 mix.minval = 1; 828 mix.maxval = d->bNrInPins; 829 mix.mul = mix.maxval - mix.minval; 830 wp = snprintf(mix.ctlname, MAX_AUDIO_DEV_LEN, "sel%d-", d->bUnitId); 831 for (i = 1; i <= d->bNrInPins; i++) { 832 wp += snprintf(mix.ctlname + wp, MAX_AUDIO_DEV_LEN - wp, 833 "i%d", d->baSourceId[i - 1]); 834 if (wp > MAX_AUDIO_DEV_LEN - 1) 835 break; 836 } 837 uaudio_mixer_add_ctl(sc, &mix); 838 } 839 840 #ifdef UAUDIO_DEBUG 841 const char * 842 uaudio_get_terminal_name(int terminal_type) 843 { 844 static char buf[100]; 845 846 switch (terminal_type) { 847 case UAT_STREAM: return "UAT_STREAM"; 848 case UATI_MICROPHONE: return "UATI_MICROPHONE"; 849 case UATI_DESKMICROPHONE: return "UATI_DESKMICROPHONE"; 850 case UATI_PERSONALMICROPHONE: return "UATI_PERSONALMICROPHONE"; 851 case UATI_OMNIMICROPHONE: return "UATI_OMNIMICROPHONE"; 852 case UATI_MICROPHONEARRAY: return "UATI_MICROPHONEARRAY"; 853 case UATI_PROCMICROPHONEARR: return "UATI_PROCMICROPHONEARR"; 854 case UATO_SPEAKER: return "UATO_SPEAKER"; 855 case UATO_DESKTOPSPEAKER: return "UATO_DESKTOPSPEAKER"; 856 case UATO_ROOMSPEAKER: return "UATO_ROOMSPEAKER"; 857 case UATO_COMMSPEAKER: return "UATO_COMMSPEAKER"; 858 case UATO_HEADPHONES: return "UATO_HEADPHONES"; 859 case UATE_ANALOGCONN: return "UATE_ANALOGCONN"; 860 case UATE_LINECONN: return "UATE_LINECONN"; 861 case UATE_LEGACYCONN: return "UATE_LEGACYCONN"; 862 case UATE_DIGITALAUIFC: return "UATE_DIGITALAUIFC"; 863 case UATE_SPDIF: return "UATE_SPDIF"; 864 case UATE_1394DA: return "UATE_1394DA"; 865 case UATE_1394DV: return "UATE_1394DV"; 866 case UATF_CDPLAYER: return "UATF_CDPLAYER"; 867 case UATF_SYNTHESIZER: return "UATF_SYNTHESIZER"; 868 case UATF_VIDEODISCAUDIO: return "UATF_VIDEODISCAUDIO"; 869 case UATF_DVDAUDIO: return "UATF_DVDAUDIO"; 870 case UATF_TVTUNERAUDIO: return "UATF_TVTUNERAUDIO"; 871 case UAT_UNDEFINED: return "UAT_UNDEFINED"; 872 case UAT_VENDOR: return "UAT_VENDOR"; 873 case UATI_UNDEFINED: return "UATI_UNDEFINED"; 874 /* output terminal types */ 875 case UATO_UNDEFINED: return "UATO_UNDEFINED"; 876 case UATO_DISPLAYAUDIO: return "UATO_DISPLAYAUDIO"; 877 case UATO_SUBWOOFER: return "UATO_SUBWOOFER"; 878 /* bidir terminal types */ 879 case UATB_UNDEFINED: return "UATB_UNDEFINED"; 880 case UATB_HANDSET: return "UATB_HANDSET"; 881 case UATB_HEADSET: return "UATB_HEADSET"; 882 case UATB_SPEAKERPHONE: return "UATB_SPEAKERPHONE"; 883 case UATB_SPEAKERPHONEESUP: return "UATB_SPEAKERPHONEESUP"; 884 case UATB_SPEAKERPHONEECANC: return "UATB_SPEAKERPHONEECANC"; 885 /* telephony terminal types */ 886 case UATT_UNDEFINED: return "UATT_UNDEFINED"; 887 case UATT_PHONELINE: return "UATT_PHONELINE"; 888 case UATT_TELEPHONE: return "UATT_TELEPHONE"; 889 case UATT_DOWNLINEPHONE: return "UATT_DOWNLINEPHONE"; 890 /* external terminal types */ 891 case UATE_UNDEFINED: return "UATE_UNDEFINED"; 892 /* embedded function terminal types */ 893 case UATF_UNDEFINED: return "UATF_UNDEFINED"; 894 case UATF_CALIBNOISE: return "UATF_CALIBNOISE"; 895 case UATF_EQUNOISE: return "UATF_EQUNOISE"; 896 case UATF_DAT: return "UATF_DAT"; 897 case UATF_DCC: return "UATF_DCC"; 898 case UATF_MINIDISK: return "UATF_MINIDISK"; 899 case UATF_ANALOGTAPE: return "UATF_ANALOGTAPE"; 900 case UATF_PHONOGRAPH: return "UATF_PHONOGRAPH"; 901 case UATF_VCRAUDIO: return "UATF_VCRAUDIO"; 902 case UATF_SATELLITE: return "UATF_SATELLITE"; 903 case UATF_CABLETUNER: return "UATF_CABLETUNER"; 904 case UATF_DSS: return "UATF_DSS"; 905 case UATF_RADIORECV: return "UATF_RADIORECV"; 906 case UATF_RADIOXMIT: return "UATF_RADIOXMIT"; 907 case UATF_MULTITRACK: return "UATF_MULTITRACK"; 908 default: 909 snprintf(buf, sizeof(buf), "unknown type (0x%.4x)", terminal_type); 910 return buf; 911 } 912 } 913 #endif 914 915 int 916 uaudio_determine_class(const struct io_terminal *iot, struct mixerctl *mix) 917 { 918 int terminal_type; 919 920 if (iot == NULL || iot->output == NULL) { 921 mix->class = UAC_OUTPUT; 922 return 0; 923 } 924 terminal_type = 0; 925 if (iot->output->size == 1) 926 terminal_type = iot->output->terminals[0]; 927 /* 928 * If the only output terminal is USB, 929 * the class is UAC_RECORD. 930 */ 931 if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) { 932 mix->class = UAC_RECORD; 933 if (iot->inputs_size == 1 934 && iot->inputs[0] != NULL 935 && iot->inputs[0]->size == 1) 936 return iot->inputs[0]->terminals[0]; 937 else 938 return 0; 939 } 940 /* 941 * If the ulitimate destination of the unit is just one output 942 * terminal and the unit is connected to the output terminal 943 * directly, the class is UAC_OUTPUT. 944 */ 945 if (terminal_type != 0 && iot->direct) { 946 mix->class = UAC_OUTPUT; 947 return terminal_type; 948 } 949 /* 950 * If the unit is connected to just one input terminal, 951 * the class is UAC_INPUT. 952 */ 953 if (iot->inputs_size == 1 && iot->inputs[0] != NULL 954 && iot->inputs[0]->size == 1) { 955 mix->class = UAC_INPUT; 956 return iot->inputs[0]->terminals[0]; 957 } 958 /* 959 * Otherwise, the class is UAC_OUTPUT. 960 */ 961 mix->class = UAC_OUTPUT; 962 return terminal_type; 963 } 964 965 const char * 966 uaudio_feature_name(const struct io_terminal *iot, struct mixerctl *mix) 967 { 968 int terminal_type; 969 970 terminal_type = uaudio_determine_class(iot, mix); 971 if (mix->class == UAC_RECORD && terminal_type == 0) 972 return AudioNmixerout; 973 DPRINTF(("%s: terminal_type=%s\n", __func__, 974 uaudio_get_terminal_name(terminal_type))); 975 switch (terminal_type) { 976 case UAT_STREAM: 977 return AudioNdac; 978 979 case UATI_MICROPHONE: 980 case UATI_DESKMICROPHONE: 981 case UATI_PERSONALMICROPHONE: 982 case UATI_OMNIMICROPHONE: 983 case UATI_MICROPHONEARRAY: 984 case UATI_PROCMICROPHONEARR: 985 return AudioNmicrophone; 986 987 case UATO_SPEAKER: 988 case UATO_DESKTOPSPEAKER: 989 case UATO_ROOMSPEAKER: 990 case UATO_COMMSPEAKER: 991 return AudioNspeaker; 992 993 case UATO_HEADPHONES: 994 return AudioNheadphone; 995 996 case UATE_ANALOGCONN: 997 case UATE_LINECONN: 998 case UATE_LEGACYCONN: 999 return AudioNline; 1000 1001 case UATE_DIGITALAUIFC: 1002 case UATE_SPDIF: 1003 case UATE_1394DA: 1004 case UATE_1394DV: 1005 return AudioNaux; 1006 1007 case UATF_CDPLAYER: 1008 return AudioNcd; 1009 1010 case UATF_SYNTHESIZER: 1011 return AudioNfmsynth; 1012 1013 case UATF_VIDEODISCAUDIO: 1014 case UATF_DVDAUDIO: 1015 case UATF_TVTUNERAUDIO: 1016 return AudioNvideo; 1017 1018 case UAT_UNDEFINED: 1019 case UAT_VENDOR: 1020 case UATI_UNDEFINED: 1021 /* output terminal types */ 1022 case UATO_UNDEFINED: 1023 case UATO_DISPLAYAUDIO: 1024 case UATO_SUBWOOFER: 1025 /* bidir terminal types */ 1026 case UATB_UNDEFINED: 1027 case UATB_HANDSET: 1028 case UATB_HEADSET: 1029 case UATB_SPEAKERPHONE: 1030 case UATB_SPEAKERPHONEESUP: 1031 case UATB_SPEAKERPHONEECANC: 1032 /* telephony terminal types */ 1033 case UATT_UNDEFINED: 1034 case UATT_PHONELINE: 1035 case UATT_TELEPHONE: 1036 case UATT_DOWNLINEPHONE: 1037 /* external terminal types */ 1038 case UATE_UNDEFINED: 1039 /* embedded function terminal types */ 1040 case UATF_UNDEFINED: 1041 case UATF_CALIBNOISE: 1042 case UATF_EQUNOISE: 1043 case UATF_DAT: 1044 case UATF_DCC: 1045 case UATF_MINIDISK: 1046 case UATF_ANALOGTAPE: 1047 case UATF_PHONOGRAPH: 1048 case UATF_VCRAUDIO: 1049 case UATF_SATELLITE: 1050 case UATF_CABLETUNER: 1051 case UATF_DSS: 1052 case UATF_RADIORECV: 1053 case UATF_RADIOXMIT: 1054 case UATF_MULTITRACK: 1055 case 0xffff: 1056 default: 1057 DPRINTF(("%s: 'master' for 0x%.4x\n", __func__, terminal_type)); 1058 return AudioNmaster; 1059 } 1060 return AudioNmaster; 1061 } 1062 1063 void 1064 uaudio_add_feature(struct uaudio_softc *sc, const struct io_terminal *iot, int id) 1065 { 1066 const struct usb_audio_feature_unit *d = iot[id].d.fu; 1067 uByte *ctls = d->bmaControls; 1068 int ctlsize = d->bControlSize; 1069 int nchan = (d->bLength - 7) / ctlsize; 1070 u_int fumask, mmask, cmask; 1071 struct mixerctl mix; 1072 int chan, ctl, i, unit; 1073 const char *mixername; 1074 1075 #define GET(i) (ctls[(i)*ctlsize] | \ 1076 (ctlsize > 1 ? ctls[(i)*ctlsize+1] << 8 : 0)) 1077 1078 mmask = GET(0); 1079 /* Figure out what we can control */ 1080 for (cmask = 0, chan = 1; chan < nchan; chan++) { 1081 DPRINTFN(9,("uaudio_add_feature: chan=%d mask=%x\n", 1082 chan, GET(chan))); 1083 cmask |= GET(chan); 1084 } 1085 1086 DPRINTFN(1,("uaudio_add_feature: bUnitId=%d, " 1087 "%d channels, mmask=0x%04x, cmask=0x%04x\n", 1088 d->bUnitId, nchan, mmask, cmask)); 1089 1090 if (nchan > MIX_MAX_CHAN) 1091 nchan = MIX_MAX_CHAN; 1092 unit = d->bUnitId; 1093 mix.wIndex = MAKE(unit, sc->sc_ac_iface); 1094 for (ctl = MUTE_CONTROL; ctl < LOUDNESS_CONTROL; ctl++) { 1095 fumask = FU_MASK(ctl); 1096 DPRINTFN(4,("uaudio_add_feature: ctl=%d fumask=0x%04x\n", 1097 ctl, fumask)); 1098 if (mmask & fumask) { 1099 mix.nchan = 1; 1100 mix.wValue[0] = MAKE(ctl, 0); 1101 } else if (cmask & fumask) { 1102 mix.nchan = nchan - 1; 1103 for (i = 1; i < nchan; i++) { 1104 if (GET(i) & fumask) 1105 mix.wValue[i-1] = MAKE(ctl, i); 1106 else 1107 mix.wValue[i-1] = -1; 1108 } 1109 } else { 1110 continue; 1111 } 1112 #undef GET 1113 mixername = uaudio_feature_name(&iot[id], &mix); 1114 switch (ctl) { 1115 case MUTE_CONTROL: 1116 mix.type = MIX_ON_OFF; 1117 mix.ctlunit = ""; 1118 snprintf(mix.ctlname, sizeof(mix.ctlname), 1119 "%s.%s", mixername, AudioNmute); 1120 break; 1121 case VOLUME_CONTROL: 1122 mix.type = MIX_SIGNED_16; 1123 mix.ctlunit = AudioNvolume; 1124 strlcpy(mix.ctlname, mixername, sizeof(mix.ctlname)); 1125 break; 1126 case BASS_CONTROL: 1127 mix.type = MIX_SIGNED_8; 1128 mix.ctlunit = AudioNbass; 1129 snprintf(mix.ctlname, sizeof(mix.ctlname), 1130 "%s.%s", mixername, AudioNbass); 1131 break; 1132 case MID_CONTROL: 1133 mix.type = MIX_SIGNED_8; 1134 mix.ctlunit = AudioNmid; 1135 snprintf(mix.ctlname, sizeof(mix.ctlname), 1136 "%s.%s", mixername, AudioNmid); 1137 break; 1138 case TREBLE_CONTROL: 1139 mix.type = MIX_SIGNED_8; 1140 mix.ctlunit = AudioNtreble; 1141 snprintf(mix.ctlname, sizeof(mix.ctlname), 1142 "%s.%s", mixername, AudioNtreble); 1143 break; 1144 case GRAPHIC_EQUALIZER_CONTROL: 1145 continue; /* XXX don't add anything */ 1146 break; 1147 case AGC_CONTROL: 1148 mix.type = MIX_ON_OFF; 1149 mix.ctlunit = ""; 1150 snprintf(mix.ctlname, sizeof(mix.ctlname), "%s.%s", 1151 mixername, AudioNagc); 1152 break; 1153 case DELAY_CONTROL: 1154 mix.type = MIX_UNSIGNED_16; 1155 mix.ctlunit = "4 ms"; 1156 snprintf(mix.ctlname, sizeof(mix.ctlname), 1157 "%s.%s", mixername, AudioNdelay); 1158 break; 1159 case BASS_BOOST_CONTROL: 1160 mix.type = MIX_ON_OFF; 1161 mix.ctlunit = ""; 1162 snprintf(mix.ctlname, sizeof(mix.ctlname), 1163 "%s.%s", mixername, AudioNbassboost); 1164 break; 1165 case LOUDNESS_CONTROL: 1166 mix.type = MIX_ON_OFF; 1167 mix.ctlunit = ""; 1168 snprintf(mix.ctlname, sizeof(mix.ctlname), 1169 "%s.%s", mixername, AudioNloudness); 1170 break; 1171 } 1172 uaudio_mixer_add_ctl(sc, &mix); 1173 } 1174 } 1175 1176 void 1177 uaudio_add_processing_updown(struct uaudio_softc *sc, 1178 const struct io_terminal *iot, int id) 1179 { 1180 const struct usb_audio_processing_unit *d = iot[id].d.pu; 1181 const struct usb_audio_processing_unit_1 *d1 = 1182 (const struct usb_audio_processing_unit_1 *)&d->baSourceId[d->bNrInPins]; 1183 const struct usb_audio_processing_unit_updown *ud = 1184 (const struct usb_audio_processing_unit_updown *) 1185 &d1->bmControls[d1->bControlSize]; 1186 struct mixerctl mix; 1187 int i; 1188 1189 DPRINTFN(2,("uaudio_add_processing_updown: bUnitId=%d bNrModes=%d\n", 1190 d->bUnitId, ud->bNrModes)); 1191 1192 if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) { 1193 DPRINTF(("uaudio_add_processing_updown: no mode select\n")); 1194 return; 1195 } 1196 1197 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 1198 mix.nchan = 1; 1199 mix.wValue[0] = MAKE(UD_MODE_SELECT_CONTROL, 0); 1200 uaudio_determine_class(&iot[id], &mix); 1201 mix.type = MIX_ON_OFF; /* XXX */ 1202 mix.ctlunit = ""; 1203 snprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d-mode", d->bUnitId); 1204 1205 for (i = 0; i < ud->bNrModes; i++) { 1206 DPRINTFN(2,("uaudio_add_processing_updown: i=%d bm=0x%x\n", 1207 i, UGETW(ud->waModes[i]))); 1208 /* XXX */ 1209 } 1210 uaudio_mixer_add_ctl(sc, &mix); 1211 } 1212 1213 void 1214 uaudio_add_processing(struct uaudio_softc *sc, const struct io_terminal *iot, int id) 1215 { 1216 const struct usb_audio_processing_unit *d = iot[id].d.pu; 1217 const struct usb_audio_processing_unit_1 *d1 = 1218 (const struct usb_audio_processing_unit_1 *)&d->baSourceId[d->bNrInPins]; 1219 int ptype = UGETW(d->wProcessType); 1220 struct mixerctl mix; 1221 1222 DPRINTFN(2,("uaudio_add_processing: wProcessType=%d bUnitId=%d " 1223 "bNrInPins=%d\n", ptype, d->bUnitId, d->bNrInPins)); 1224 1225 if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) { 1226 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 1227 mix.nchan = 1; 1228 mix.wValue[0] = MAKE(XX_ENABLE_CONTROL, 0); 1229 uaudio_determine_class(&iot[id], &mix); 1230 mix.type = MIX_ON_OFF; 1231 mix.ctlunit = ""; 1232 snprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d.%d-enable", 1233 d->bUnitId, ptype); 1234 uaudio_mixer_add_ctl(sc, &mix); 1235 } 1236 1237 switch(ptype) { 1238 case UPDOWNMIX_PROCESS: 1239 uaudio_add_processing_updown(sc, iot, id); 1240 break; 1241 case DOLBY_PROLOGIC_PROCESS: 1242 case P3D_STEREO_EXTENDER_PROCESS: 1243 case REVERBATION_PROCESS: 1244 case CHORUS_PROCESS: 1245 case DYN_RANGE_COMP_PROCESS: 1246 default: 1247 #ifdef UAUDIO_DEBUG 1248 printf("uaudio_add_processing: unit %d, type=%d not impl.\n", 1249 d->bUnitId, ptype); 1250 #endif 1251 break; 1252 } 1253 } 1254 1255 void 1256 uaudio_add_extension(struct uaudio_softc *sc, const struct io_terminal *iot, int id) 1257 { 1258 const struct usb_audio_extension_unit *d = iot[id].d.eu; 1259 const struct usb_audio_extension_unit_1 *d1 = 1260 (const struct usb_audio_extension_unit_1 *)&d->baSourceId[d->bNrInPins]; 1261 struct mixerctl mix; 1262 1263 DPRINTFN(2,("uaudio_add_extension: bUnitId=%d bNrInPins=%d\n", 1264 d->bUnitId, d->bNrInPins)); 1265 1266 if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_XU) 1267 return; 1268 1269 if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) { 1270 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface); 1271 mix.nchan = 1; 1272 mix.wValue[0] = MAKE(UA_EXT_ENABLE, 0); 1273 uaudio_determine_class(&iot[id], &mix); 1274 mix.type = MIX_ON_OFF; 1275 mix.ctlunit = ""; 1276 snprintf(mix.ctlname, sizeof(mix.ctlname), "ext%d-enable", 1277 d->bUnitId); 1278 uaudio_mixer_add_ctl(sc, &mix); 1279 } 1280 } 1281 1282 struct terminal_list* 1283 uaudio_merge_terminal_list(const struct io_terminal *iot) 1284 { 1285 struct terminal_list *tml; 1286 uint16_t *ptm; 1287 int i, len; 1288 1289 len = 0; 1290 if (iot->inputs == NULL) 1291 return NULL; 1292 for (i = 0; i < iot->inputs_size; i++) { 1293 if (iot->inputs[i] != NULL) 1294 len += iot->inputs[i]->size; 1295 } 1296 tml = malloc(TERMINAL_LIST_SIZE(len), M_TEMP, M_NOWAIT); 1297 if (tml == NULL) { 1298 printf("uaudio_merge_terminal_list: no memory\n"); 1299 return NULL; 1300 } 1301 tml->size = 0; 1302 ptm = tml->terminals; 1303 for (i = 0; i < iot->inputs_size; i++) { 1304 if (iot->inputs[i] == NULL) 1305 continue; 1306 if (iot->inputs[i]->size > len) 1307 break; 1308 memcpy(ptm, iot->inputs[i]->terminals, 1309 iot->inputs[i]->size * sizeof(uint16_t)); 1310 tml->size += iot->inputs[i]->size; 1311 ptm += iot->inputs[i]->size; 1312 len -= iot->inputs[i]->size; 1313 } 1314 return tml; 1315 } 1316 1317 struct terminal_list * 1318 uaudio_io_terminaltype(int outtype, struct io_terminal *iot, int id) 1319 { 1320 struct terminal_list *tml; 1321 struct io_terminal *it; 1322 int src_id, i; 1323 1324 it = &iot[id]; 1325 if (it->output != NULL) { 1326 /* already has outtype? */ 1327 for (i = 0; i < it->output->size; i++) 1328 if (it->output->terminals[i] == outtype) 1329 return uaudio_merge_terminal_list(it); 1330 tml = malloc(TERMINAL_LIST_SIZE(it->output->size + 1), 1331 M_TEMP, M_NOWAIT); 1332 if (tml == NULL) { 1333 printf("uaudio_io_terminaltype: no memory\n"); 1334 return uaudio_merge_terminal_list(it); 1335 } 1336 memcpy(tml, it->output, TERMINAL_LIST_SIZE(it->output->size)); 1337 tml->terminals[it->output->size] = outtype; 1338 tml->size++; 1339 free(it->output, M_TEMP); 1340 it->output = tml; 1341 if (it->inputs != NULL) { 1342 for (i = 0; i < it->inputs_size; i++) 1343 if (it->inputs[i] != NULL) 1344 free(it->inputs[i], M_TEMP); 1345 free(it->inputs, M_TEMP); 1346 } 1347 it->inputs_size = 0; 1348 it->inputs = NULL; 1349 } else { /* end `iot[id] != NULL' */ 1350 it->inputs_size = 0; 1351 it->inputs = NULL; 1352 it->output = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT); 1353 if (it->output == NULL) { 1354 printf("uaudio_io_terminaltype: no memory\n"); 1355 return NULL; 1356 } 1357 it->output->terminals[0] = outtype; 1358 it->output->size = 1; 1359 it->direct = FALSE; 1360 } 1361 1362 switch (it->d.desc->bDescriptorSubtype) { 1363 case UDESCSUB_AC_INPUT: 1364 it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT); 1365 if (it->inputs == NULL) { 1366 printf("uaudio_io_terminaltype: no memory\n"); 1367 return NULL; 1368 } 1369 tml = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT); 1370 if (tml == NULL) { 1371 printf("uaudio_io_terminaltype: no memory\n"); 1372 free(it->inputs, M_TEMP); 1373 it->inputs = NULL; 1374 return NULL; 1375 } 1376 it->inputs[0] = tml; 1377 tml->terminals[0] = UGETW(it->d.it->wTerminalType); 1378 tml->size = 1; 1379 it->inputs_size = 1; 1380 return uaudio_merge_terminal_list(it); 1381 case UDESCSUB_AC_FEATURE: 1382 src_id = it->d.fu->bSourceId; 1383 it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT); 1384 if (it->inputs == NULL) { 1385 printf("uaudio_io_terminaltype: no memory\n"); 1386 return uaudio_io_terminaltype(outtype, iot, src_id); 1387 } 1388 it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id); 1389 it->inputs_size = 1; 1390 return uaudio_merge_terminal_list(it); 1391 case UDESCSUB_AC_OUTPUT: 1392 it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT); 1393 if (it->inputs == NULL) { 1394 printf("uaudio_io_terminaltype: no memory\n"); 1395 return NULL; 1396 } 1397 src_id = it->d.ot->bSourceId; 1398 it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id); 1399 it->inputs_size = 1; 1400 iot[src_id].direct = TRUE; 1401 return NULL; 1402 case UDESCSUB_AC_MIXER: 1403 it->inputs_size = 0; 1404 it->inputs = malloc(sizeof(struct terminal_list *) 1405 * it->d.mu->bNrInPins, M_TEMP, M_NOWAIT); 1406 if (it->inputs == NULL) { 1407 printf("uaudio_io_terminaltype: no memory\n"); 1408 return NULL; 1409 } 1410 for (i = 0; i < it->d.mu->bNrInPins; i++) { 1411 src_id = it->d.mu->baSourceId[i]; 1412 it->inputs[i] = uaudio_io_terminaltype(outtype, iot, 1413 src_id); 1414 it->inputs_size++; 1415 } 1416 return uaudio_merge_terminal_list(it); 1417 case UDESCSUB_AC_SELECTOR: 1418 it->inputs_size = 0; 1419 it->inputs = malloc(sizeof(struct terminal_list *) 1420 * it->d.su->bNrInPins, M_TEMP, M_NOWAIT); 1421 if (it->inputs == NULL) { 1422 printf("uaudio_io_terminaltype: no memory\n"); 1423 return NULL; 1424 } 1425 for (i = 0; i < it->d.su->bNrInPins; i++) { 1426 src_id = it->d.su->baSourceId[i]; 1427 it->inputs[i] = uaudio_io_terminaltype(outtype, iot, 1428 src_id); 1429 it->inputs_size++; 1430 } 1431 return uaudio_merge_terminal_list(it); 1432 case UDESCSUB_AC_PROCESSING: 1433 it->inputs_size = 0; 1434 it->inputs = malloc(sizeof(struct terminal_list *) 1435 * it->d.pu->bNrInPins, M_TEMP, M_NOWAIT); 1436 if (it->inputs == NULL) { 1437 printf("uaudio_io_terminaltype: no memory\n"); 1438 return NULL; 1439 } 1440 for (i = 0; i < it->d.pu->bNrInPins; i++) { 1441 src_id = it->d.pu->baSourceId[i]; 1442 it->inputs[i] = uaudio_io_terminaltype(outtype, iot, 1443 src_id); 1444 it->inputs_size++; 1445 } 1446 return uaudio_merge_terminal_list(it); 1447 case UDESCSUB_AC_EXTENSION: 1448 it->inputs_size = 0; 1449 it->inputs = malloc(sizeof(struct terminal_list *) 1450 * it->d.eu->bNrInPins, M_TEMP, M_NOWAIT); 1451 if (it->inputs == NULL) { 1452 printf("uaudio_io_terminaltype: no memory\n"); 1453 return NULL; 1454 } 1455 for (i = 0; i < it->d.eu->bNrInPins; i++) { 1456 src_id = it->d.eu->baSourceId[i]; 1457 it->inputs[i] = uaudio_io_terminaltype(outtype, iot, 1458 src_id); 1459 it->inputs_size++; 1460 } 1461 return uaudio_merge_terminal_list(it); 1462 case UDESCSUB_AC_HEADER: 1463 default: 1464 return NULL; 1465 } 1466 } 1467 1468 usbd_status 1469 uaudio_identify(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc) 1470 { 1471 usbd_status err; 1472 1473 err = uaudio_identify_ac(sc, cdesc); 1474 if (err) 1475 return (err); 1476 return (uaudio_identify_as(sc, cdesc)); 1477 } 1478 1479 void 1480 uaudio_add_alt(struct uaudio_softc *sc, const struct as_info *ai) 1481 { 1482 size_t len = sizeof(*ai) * (sc->sc_nalts + 1); 1483 struct as_info *nai = (sc->sc_nalts == 0) ? 1484 malloc(len, M_USBDEV, M_NOWAIT) : 1485 realloc(sc->sc_alts, len, M_USBDEV, M_NOWAIT); 1486 1487 if (nai == NULL) { 1488 printf("uaudio_add_alt: no memory\n"); 1489 return; 1490 } 1491 1492 sc->sc_alts = nai; 1493 DPRINTFN(2,("uaudio_add_alt: adding alt=%d, enc=%d\n", 1494 ai->alt, ai->encoding)); 1495 sc->sc_alts[sc->sc_nalts++] = *ai; 1496 } 1497 1498 usbd_status 1499 uaudio_process_as(struct uaudio_softc *sc, const char *buf, int *offsp, 1500 int size, const usb_interface_descriptor_t *id) 1501 #define offs (*offsp) 1502 { 1503 const struct usb_audio_streaming_interface_descriptor *asid; 1504 const struct usb_audio_streaming_type1_descriptor *asf1d; 1505 const usb_endpoint_descriptor_audio_t *ed; 1506 const usb_endpoint_descriptor_audio_t *epdesc1; 1507 const struct usb_audio_streaming_endpoint_descriptor *sed; 1508 int format, chan, prec, enc; 1509 int dir, type, sync; 1510 struct as_info ai; 1511 const char *format_str; 1512 1513 asid = (const void *)(buf + offs); 1514 if (asid->bDescriptorType != UDESC_CS_INTERFACE || 1515 asid->bDescriptorSubtype != AS_GENERAL) 1516 return (USBD_INVAL); 1517 DPRINTF(("uaudio_process_as: asid: bTerminakLink=%d wFormatTag=%d\n", 1518 asid->bTerminalLink, UGETW(asid->wFormatTag))); 1519 offs += asid->bLength; 1520 if (offs > size) 1521 return (USBD_INVAL); 1522 1523 asf1d = (const void *)(buf + offs); 1524 if (asf1d->bDescriptorType != UDESC_CS_INTERFACE || 1525 asf1d->bDescriptorSubtype != FORMAT_TYPE) 1526 return (USBD_INVAL); 1527 offs += asf1d->bLength; 1528 if (offs > size) 1529 return (USBD_INVAL); 1530 1531 if (asf1d->bFormatType != FORMAT_TYPE_I) { 1532 printf("%s: ignored setting with type %d format\n", 1533 USBDEVNAME(sc->sc_dev), UGETW(asid->wFormatTag)); 1534 return (USBD_NORMAL_COMPLETION); 1535 } 1536 1537 ed = (const void *)(buf + offs); 1538 if (ed->bDescriptorType != UDESC_ENDPOINT) 1539 return (USBD_INVAL); 1540 DPRINTF(("uaudio_process_as: endpoint[0] bLength=%d bDescriptorType=%d " 1541 "bEndpointAddress=%d bmAttributes=0x%x wMaxPacketSize=%d " 1542 "bInterval=%d bRefresh=%d bSynchAddress=%d\n", 1543 ed->bLength, ed->bDescriptorType, ed->bEndpointAddress, 1544 ed->bmAttributes, UGETW(ed->wMaxPacketSize), 1545 ed->bInterval, ed->bRefresh, ed->bSynchAddress)); 1546 offs += ed->bLength; 1547 if (offs > size) 1548 return (USBD_INVAL); 1549 if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS) 1550 return (USBD_INVAL); 1551 1552 dir = UE_GET_DIR(ed->bEndpointAddress); 1553 type = UE_GET_ISO_TYPE(ed->bmAttributes); 1554 if ((usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_INP_ASYNC) && 1555 dir == UE_DIR_IN && type == UE_ISO_ADAPT) 1556 type = UE_ISO_ASYNC; 1557 1558 /* We can't handle endpoints that need a sync pipe yet. */ 1559 sync = FALSE; 1560 if (dir == UE_DIR_IN && type == UE_ISO_ADAPT) { 1561 sync = TRUE; 1562 #ifndef UAUDIO_MULTIPLE_ENDPOINTS 1563 printf("%s: ignored input endpoint of type adaptive\n", 1564 USBDEVNAME(sc->sc_dev)); 1565 return (USBD_NORMAL_COMPLETION); 1566 #endif 1567 } 1568 if (dir != UE_DIR_IN && type == UE_ISO_ASYNC) { 1569 sync = TRUE; 1570 #ifndef UAUDIO_MULTIPLE_ENDPOINTS 1571 printf("%s: ignored output endpoint of type async\n", 1572 USBDEVNAME(sc->sc_dev)); 1573 return (USBD_NORMAL_COMPLETION); 1574 #endif 1575 } 1576 1577 sed = (const void *)(buf + offs); 1578 if (sed->bDescriptorType != UDESC_CS_ENDPOINT || 1579 sed->bDescriptorSubtype != AS_GENERAL) 1580 return (USBD_INVAL); 1581 DPRINTF((" streadming_endpoint: offset=%d bLength=%d\n", offs, sed->bLength)); 1582 offs += sed->bLength; 1583 if (offs > size) 1584 return (USBD_INVAL); 1585 1586 if (sync && id->bNumEndpoints <= 1) { 1587 printf("%s: a sync-pipe endpoint but no other endpoint\n", 1588 USBDEVNAME(sc->sc_dev)); 1589 return USBD_INVAL; 1590 } 1591 if (!sync && id->bNumEndpoints > 1) { 1592 printf("%s: non sync-pipe endpoint but multiple endpoints\n", 1593 USBDEVNAME(sc->sc_dev)); 1594 return USBD_INVAL; 1595 } 1596 epdesc1 = NULL; 1597 if (id->bNumEndpoints > 1) { 1598 epdesc1 = (const void*)(buf + offs); 1599 if (epdesc1->bDescriptorType != UDESC_ENDPOINT) 1600 return USBD_INVAL; 1601 DPRINTF(("uaudio_process_as: endpoint[1] bLength=%d " 1602 "bDescriptorType=%d bEndpointAddress=%d " 1603 "bmAttributes=0x%x wMaxPacketSize=%d bInterval=%d " 1604 "bRefresh=%d bSynchAddress=%d\n", 1605 epdesc1->bLength, epdesc1->bDescriptorType, 1606 epdesc1->bEndpointAddress, epdesc1->bmAttributes, 1607 UGETW(epdesc1->wMaxPacketSize), epdesc1->bInterval, 1608 epdesc1->bRefresh, epdesc1->bSynchAddress)); 1609 offs += epdesc1->bLength; 1610 if (offs > size) 1611 return USBD_INVAL; 1612 if (epdesc1->bSynchAddress != 0) { 1613 printf("%s: invalid endpoint: bSynchAddress=0\n", 1614 USBDEVNAME(sc->sc_dev)); 1615 return USBD_INVAL; 1616 } 1617 if (UE_GET_XFERTYPE(epdesc1->bmAttributes) != UE_ISOCHRONOUS) { 1618 printf("%s: invalid endpoint: bmAttributes=0x%x\n", 1619 USBDEVNAME(sc->sc_dev), epdesc1->bmAttributes); 1620 return USBD_INVAL; 1621 } 1622 if (epdesc1->bEndpointAddress != ed->bSynchAddress) { 1623 printf("%s: invalid endpoint addresses: " 1624 "ep[0]->bSynchAddress=0x%x " 1625 "ep[1]->bEndpointAddress=0x%x\n", 1626 USBDEVNAME(sc->sc_dev), ed->bSynchAddress, 1627 epdesc1->bEndpointAddress); 1628 return USBD_INVAL; 1629 } 1630 /* UE_GET_ADDR(epdesc1->bEndpointAddress), and epdesc1->bRefresh */ 1631 } 1632 1633 format = UGETW(asid->wFormatTag); 1634 chan = asf1d->bNrChannels; 1635 prec = asf1d->bBitResolution; 1636 if (prec != 8 && prec != 16 && prec != 24) { 1637 printf("%s: ignored setting with precision %d\n", 1638 USBDEVNAME(sc->sc_dev), prec); 1639 return (USBD_NORMAL_COMPLETION); 1640 } 1641 switch (format) { 1642 case UA_FMT_PCM: 1643 if (prec == 8) { 1644 sc->sc_altflags |= HAS_8; 1645 } else if (prec == 16) { 1646 sc->sc_altflags |= HAS_16; 1647 } else if (prec == 24) { 1648 sc->sc_altflags |= HAS_24; 1649 } 1650 enc = AUDIO_ENCODING_SLINEAR_LE; 1651 format_str = "pcm"; 1652 break; 1653 case UA_FMT_PCM8: 1654 enc = AUDIO_ENCODING_ULINEAR_LE; 1655 sc->sc_altflags |= HAS_8U; 1656 format_str = "pcm8"; 1657 break; 1658 case UA_FMT_ALAW: 1659 enc = AUDIO_ENCODING_ALAW; 1660 sc->sc_altflags |= HAS_ALAW; 1661 format_str = "alaw"; 1662 break; 1663 case UA_FMT_MULAW: 1664 enc = AUDIO_ENCODING_ULAW; 1665 sc->sc_altflags |= HAS_MULAW; 1666 format_str = "mulaw"; 1667 break; 1668 case UA_FMT_IEEE_FLOAT: 1669 default: 1670 printf("%s: ignored setting with format %d\n", 1671 USBDEVNAME(sc->sc_dev), format); 1672 return (USBD_NORMAL_COMPLETION); 1673 } 1674 #ifdef UAUDIO_DEBUG 1675 printf("%s: %s: %dch, %d/%dbit, %s,", USBDEVNAME(sc->sc_dev), 1676 dir == UE_DIR_IN ? "recording" : "playback", 1677 chan, prec, asf1d->bSubFrameSize * 8, format_str); 1678 if (asf1d->bSamFreqType == UA_SAMP_CONTNUOUS) { 1679 printf(" %d-%dHz\n", UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d)); 1680 } else { 1681 int r; 1682 printf(" %d", UA_GETSAMP(asf1d, 0)); 1683 for (r = 1; r < asf1d->bSamFreqType; r++) 1684 printf(",%d", UA_GETSAMP(asf1d, r)); 1685 printf("Hz\n"); 1686 } 1687 #endif 1688 ai.alt = id->bAlternateSetting; 1689 ai.encoding = enc; 1690 ai.attributes = sed->bmAttributes; 1691 ai.idesc = id; 1692 ai.edesc = ed; 1693 ai.edesc1 = epdesc1; 1694 ai.asf1desc = asf1d; 1695 ai.sc_busy = 0; 1696 uaudio_add_alt(sc, &ai); 1697 #ifdef UAUDIO_DEBUG 1698 if (ai.attributes & UA_SED_FREQ_CONTROL) 1699 DPRINTFN(1, ("uaudio_process_as: FREQ_CONTROL\n")); 1700 if (ai.attributes & UA_SED_PITCH_CONTROL) 1701 DPRINTFN(1, ("uaudio_process_as: PITCH_CONTROL\n")); 1702 #endif 1703 sc->sc_mode |= (dir == UE_DIR_OUT) ? AUMODE_PLAY : AUMODE_RECORD; 1704 1705 return (USBD_NORMAL_COMPLETION); 1706 } 1707 #undef offs 1708 1709 usbd_status 1710 uaudio_identify_as(struct uaudio_softc *sc, 1711 const usb_config_descriptor_t *cdesc) 1712 { 1713 const usb_interface_descriptor_t *id; 1714 const char *buf; 1715 int size, offs; 1716 1717 size = UGETW(cdesc->wTotalLength); 1718 buf = (const char *)cdesc; 1719 1720 /* Locate the AudioStreaming interface descriptor. */ 1721 offs = 0; 1722 id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOSTREAM); 1723 if (id == NULL) 1724 return (USBD_INVAL); 1725 1726 /* Loop through all the alternate settings. */ 1727 while (offs <= size) { 1728 DPRINTFN(2, ("uaudio_identify: interface=%d offset=%d\n", 1729 id->bInterfaceNumber, offs)); 1730 switch (id->bNumEndpoints) { 1731 case 0: 1732 DPRINTFN(2, ("uaudio_identify: AS null alt=%d\n", 1733 id->bAlternateSetting)); 1734 sc->sc_nullalt = id->bAlternateSetting; 1735 break; 1736 case 1: 1737 #ifdef UAUDIO_MULTIPLE_ENDPOINTS 1738 case 2: 1739 #endif 1740 uaudio_process_as(sc, buf, &offs, size, id); 1741 break; 1742 default: 1743 printf("%s: ignored audio interface with %d " 1744 "endpoints\n", 1745 USBDEVNAME(sc->sc_dev), id->bNumEndpoints); 1746 break; 1747 } 1748 id = uaudio_find_iface(buf, size, &offs,UISUBCLASS_AUDIOSTREAM); 1749 if (id == NULL) 1750 break; 1751 } 1752 if (offs > size) 1753 return (USBD_INVAL); 1754 DPRINTF(("uaudio_identify_as: %d alts available\n", sc->sc_nalts)); 1755 1756 if (sc->sc_mode == 0) { 1757 printf("%s: no usable endpoint found\n", 1758 USBDEVNAME(sc->sc_dev)); 1759 return (USBD_INVAL); 1760 } 1761 1762 return (USBD_NORMAL_COMPLETION); 1763 } 1764 1765 usbd_status 1766 uaudio_identify_ac(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc) 1767 { 1768 struct io_terminal* iot; 1769 const usb_interface_descriptor_t *id; 1770 const struct usb_audio_control_descriptor *acdp; 1771 const usb_descriptor_t *dp; 1772 const struct usb_audio_output_terminal *pot; 1773 struct terminal_list *tml; 1774 const char *buf, *ibuf, *ibufend; 1775 int size, offs, aclen, ndps, i, j; 1776 1777 size = UGETW(cdesc->wTotalLength); 1778 buf = (char *)cdesc; 1779 1780 /* Locate the AudioControl interface descriptor. */ 1781 offs = 0; 1782 id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOCONTROL); 1783 if (id == NULL) 1784 return (USBD_INVAL); 1785 if (offs + sizeof *acdp > size) 1786 return (USBD_INVAL); 1787 sc->sc_ac_iface = id->bInterfaceNumber; 1788 DPRINTFN(2,("uaudio_identify_ac: AC interface is %d\n", sc->sc_ac_iface)); 1789 1790 /* A class-specific AC interface header should follow. */ 1791 ibuf = buf + offs; 1792 acdp = (const struct usb_audio_control_descriptor *)ibuf; 1793 if (acdp->bDescriptorType != UDESC_CS_INTERFACE || 1794 acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER) 1795 return (USBD_INVAL); 1796 aclen = UGETW(acdp->wTotalLength); 1797 if (offs + aclen > size) 1798 return (USBD_INVAL); 1799 1800 if (!(usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_BAD_ADC) && 1801 UGETW(acdp->bcdADC) != UAUDIO_VERSION) 1802 return (USBD_INVAL); 1803 1804 sc->sc_audio_rev = UGETW(acdp->bcdADC); 1805 DPRINTFN(2,("uaudio_identify_ac: found AC header, vers=%03x, len=%d\n", 1806 sc->sc_audio_rev, aclen)); 1807 1808 sc->sc_nullalt = -1; 1809 1810 /* Scan through all the AC specific descriptors */ 1811 ibufend = ibuf + aclen; 1812 dp = (const usb_descriptor_t *)ibuf; 1813 ndps = 0; 1814 iot = malloc(sizeof(struct io_terminal) * 256, M_TEMP, M_NOWAIT | M_ZERO); 1815 if (iot == NULL) { 1816 printf("%s: no memory\n", __func__); 1817 return USBD_NOMEM; 1818 } 1819 for (;;) { 1820 ibuf += dp->bLength; 1821 if (ibuf >= ibufend) 1822 break; 1823 dp = (const usb_descriptor_t *)ibuf; 1824 if (ibuf + dp->bLength > ibufend) 1825 return (USBD_INVAL); 1826 if (dp->bDescriptorType != UDESC_CS_INTERFACE) { 1827 printf("uaudio_identify_ac: skip desc type=0x%02x\n", 1828 dp->bDescriptorType); 1829 continue; 1830 } 1831 i = ((const struct usb_audio_input_terminal *)dp)->bTerminalId; 1832 iot[i].d.desc = dp; 1833 if (i > ndps) 1834 ndps = i; 1835 } 1836 ndps++; 1837 1838 /* construct io_terminal */ 1839 for (i = 0; i < ndps; i++) { 1840 dp = iot[i].d.desc; 1841 if (dp == NULL) 1842 continue; 1843 if (dp->bDescriptorSubtype != UDESCSUB_AC_OUTPUT) 1844 continue; 1845 pot = iot[i].d.ot; 1846 tml = uaudio_io_terminaltype(UGETW(pot->wTerminalType), iot, i); 1847 if (tml != NULL) 1848 free(tml, M_TEMP); 1849 } 1850 1851 #ifdef UAUDIO_DEBUG 1852 for (i = 0; i < 256; i++) { 1853 if (iot[i].d.desc == NULL) 1854 continue; 1855 printf("id %d:\t", i); 1856 switch (iot[i].d.desc->bDescriptorSubtype) { 1857 case UDESCSUB_AC_INPUT: 1858 printf("AC_INPUT type=%s\n", uaudio_get_terminal_name 1859 (UGETW(iot[i].d.it->wTerminalType))); 1860 break; 1861 case UDESCSUB_AC_OUTPUT: 1862 printf("AC_OUTPUT type=%s ", uaudio_get_terminal_name 1863 (UGETW(iot[i].d.ot->wTerminalType))); 1864 printf("src=%d\n", iot[i].d.ot->bSourceId); 1865 break; 1866 case UDESCSUB_AC_MIXER: 1867 printf("AC_MIXER src="); 1868 for (j = 0; j < iot[i].d.mu->bNrInPins; j++) 1869 printf("%d ", iot[i].d.mu->baSourceId[j]); 1870 printf("\n"); 1871 break; 1872 case UDESCSUB_AC_SELECTOR: 1873 printf("AC_SELECTOR src="); 1874 for (j = 0; j < iot[i].d.su->bNrInPins; j++) 1875 printf("%d ", iot[i].d.su->baSourceId[j]); 1876 printf("\n"); 1877 break; 1878 case UDESCSUB_AC_FEATURE: 1879 printf("AC_FEATURE src=%d\n", iot[i].d.fu->bSourceId); 1880 break; 1881 case UDESCSUB_AC_PROCESSING: 1882 printf("AC_PROCESSING src="); 1883 for (j = 0; j < iot[i].d.pu->bNrInPins; j++) 1884 printf("%d ", iot[i].d.pu->baSourceId[j]); 1885 printf("\n"); 1886 break; 1887 case UDESCSUB_AC_EXTENSION: 1888 printf("AC_EXTENSION src="); 1889 for (j = 0; j < iot[i].d.eu->bNrInPins; j++) 1890 printf("%d ", iot[i].d.eu->baSourceId[j]); 1891 printf("\n"); 1892 break; 1893 default: 1894 printf("unknown audio control (subtype=%d)\n", 1895 iot[i].d.desc->bDescriptorSubtype); 1896 } 1897 for (j = 0; j < iot[i].inputs_size; j++) { 1898 int k; 1899 printf("\tinput%d: ", j); 1900 tml = iot[i].inputs[j]; 1901 if (tml == NULL) { 1902 printf("NULL\n"); 1903 continue; 1904 } 1905 for (k = 0; k < tml->size; k++) 1906 printf("%s ", uaudio_get_terminal_name 1907 (tml->terminals[k])); 1908 printf("\n"); 1909 } 1910 printf("\toutput: "); 1911 tml = iot[i].output; 1912 for (j = 0; j < tml->size; j++) 1913 printf("%s ", uaudio_get_terminal_name(tml->terminals[j])); 1914 printf("\n"); 1915 } 1916 #endif 1917 1918 for (i = 0; i < ndps; i++) { 1919 dp = iot[i].d.desc; 1920 if (dp == NULL) 1921 continue; 1922 DPRINTF(("uaudio_identify_ac: id=%d subtype=%d\n", 1923 i, dp->bDescriptorSubtype)); 1924 switch (dp->bDescriptorSubtype) { 1925 case UDESCSUB_AC_HEADER: 1926 printf("uaudio_identify_ac: unexpected AC header\n"); 1927 break; 1928 case UDESCSUB_AC_INPUT: 1929 uaudio_add_input(sc, iot, i); 1930 break; 1931 case UDESCSUB_AC_OUTPUT: 1932 uaudio_add_output(sc, iot, i); 1933 break; 1934 case UDESCSUB_AC_MIXER: 1935 uaudio_add_mixer(sc, iot, i); 1936 break; 1937 case UDESCSUB_AC_SELECTOR: 1938 uaudio_add_selector(sc, iot, i); 1939 break; 1940 case UDESCSUB_AC_FEATURE: 1941 uaudio_add_feature(sc, iot, i); 1942 break; 1943 case UDESCSUB_AC_PROCESSING: 1944 uaudio_add_processing(sc, iot, i); 1945 break; 1946 case UDESCSUB_AC_EXTENSION: 1947 uaudio_add_extension(sc, iot, i); 1948 break; 1949 default: 1950 printf("uaudio_identify_ac: bad AC desc subtype=0x%02x\n", 1951 dp->bDescriptorSubtype); 1952 break; 1953 } 1954 } 1955 1956 /* delete io_terminal */ 1957 for (i = 0; i < 256; i++) { 1958 if (iot[i].d.desc == NULL) 1959 continue; 1960 if (iot[i].inputs != NULL) { 1961 for (j = 0; j < iot[i].inputs_size; j++) { 1962 if (iot[i].inputs[j] != NULL) 1963 free(iot[i].inputs[j], M_TEMP); 1964 } 1965 free(iot[i].inputs, M_TEMP); 1966 } 1967 if (iot[i].output != NULL) 1968 free(iot[i].output, M_TEMP); 1969 iot[i].d.desc = NULL; 1970 } 1971 free(iot, M_TEMP); 1972 1973 return (USBD_NORMAL_COMPLETION); 1974 } 1975 1976 int 1977 uaudio_query_devinfo(void *addr, mixer_devinfo_t *mi) 1978 { 1979 struct uaudio_softc *sc = addr; 1980 struct mixerctl *mc; 1981 int n, nctls, i; 1982 1983 DPRINTFN(2,("uaudio_query_devinfo: index=%d\n", mi->index)); 1984 if (sc->sc_dying) 1985 return (EIO); 1986 1987 n = mi->index; 1988 nctls = sc->sc_nctls; 1989 1990 switch (n) { 1991 case UAC_OUTPUT: 1992 mi->type = AUDIO_MIXER_CLASS; 1993 mi->mixer_class = UAC_OUTPUT; 1994 mi->next = mi->prev = AUDIO_MIXER_LAST; 1995 strlcpy(mi->label.name, AudioCoutputs, sizeof(mi->label.name)); 1996 return (0); 1997 case UAC_INPUT: 1998 mi->type = AUDIO_MIXER_CLASS; 1999 mi->mixer_class = UAC_INPUT; 2000 mi->next = mi->prev = AUDIO_MIXER_LAST; 2001 strlcpy(mi->label.name, AudioCinputs, sizeof(mi->label.name)); 2002 return (0); 2003 case UAC_EQUAL: 2004 mi->type = AUDIO_MIXER_CLASS; 2005 mi->mixer_class = UAC_EQUAL; 2006 mi->next = mi->prev = AUDIO_MIXER_LAST; 2007 strlcpy(mi->label.name, AudioCequalization, 2008 sizeof(mi->label.name)); 2009 return (0); 2010 case UAC_RECORD: 2011 mi->type = AUDIO_MIXER_CLASS; 2012 mi->mixer_class = UAC_RECORD; 2013 mi->next = mi->prev = AUDIO_MIXER_LAST; 2014 strlcpy(mi->label.name, AudioCrecord, sizeof(mi->label.name)); 2015 return 0; 2016 default: 2017 break; 2018 } 2019 2020 n -= UAC_NCLASSES; 2021 if (n < 0 || n >= nctls) 2022 return (ENXIO); 2023 2024 mc = &sc->sc_ctls[n]; 2025 strlcpy(mi->label.name, mc->ctlname, sizeof(mi->label.name)); 2026 mi->mixer_class = mc->class; 2027 mi->next = mi->prev = AUDIO_MIXER_LAST; /* XXX */ 2028 switch (mc->type) { 2029 case MIX_ON_OFF: 2030 mi->type = AUDIO_MIXER_ENUM; 2031 mi->un.e.num_mem = 2; 2032 strlcpy(mi->un.e.member[0].label.name, AudioNoff, 2033 sizeof(mi->un.e.member[0].label.name)); 2034 mi->un.e.member[0].ord = 0; 2035 strlcpy(mi->un.e.member[1].label.name, AudioNon, 2036 sizeof(mi->un.e.member[1].label.name)); 2037 mi->un.e.member[1].ord = 1; 2038 break; 2039 case MIX_SELECTOR: 2040 mi->type = AUDIO_MIXER_ENUM; 2041 mi->un.e.num_mem = mc->maxval - mc->minval + 1; 2042 for (i = 0; i <= mc->maxval - mc->minval; i++) { 2043 snprintf(mi->un.e.member[i].label.name, 2044 sizeof(mi->un.e.member[i].label.name), 2045 "%d", i + mc->minval); 2046 mi->un.e.member[i].ord = i + mc->minval; 2047 } 2048 break; 2049 default: 2050 mi->type = AUDIO_MIXER_VALUE; 2051 strncpy(mi->un.v.units.name, mc->ctlunit, MAX_AUDIO_DEV_LEN); 2052 mi->un.v.num_channels = mc->nchan; 2053 mi->un.v.delta = mc->delta; 2054 break; 2055 } 2056 return (0); 2057 } 2058 2059 int 2060 uaudio_open(void *addr, int flags) 2061 { 2062 struct uaudio_softc *sc = addr; 2063 2064 DPRINTF(("uaudio_open: sc=%p\n", sc)); 2065 if (sc->sc_dying) 2066 return (EIO); 2067 2068 if ((flags & FWRITE) && !(sc->sc_mode & AUMODE_PLAY)) 2069 return (EACCES); 2070 if ((flags & FREAD) && !(sc->sc_mode & AUMODE_RECORD)) 2071 return (EACCES); 2072 2073 return (0); 2074 } 2075 2076 /* 2077 * Close function is called at splaudio(). 2078 */ 2079 void 2080 uaudio_close(void *addr) 2081 { 2082 } 2083 2084 int 2085 uaudio_drain(void *addr) 2086 { 2087 struct uaudio_softc *sc = addr; 2088 2089 usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES); 2090 2091 return (0); 2092 } 2093 2094 int 2095 uaudio_halt_out_dma(void *addr) 2096 { 2097 struct uaudio_softc *sc = addr; 2098 2099 DPRINTF(("uaudio_halt_out_dma: enter\n")); 2100 if (sc->sc_playchan.pipe != NULL) { 2101 uaudio_chan_close(sc, &sc->sc_playchan); 2102 sc->sc_playchan.pipe = NULL; 2103 uaudio_chan_free_buffers(sc, &sc->sc_playchan); 2104 sc->sc_playchan.intr = NULL; 2105 } 2106 return (0); 2107 } 2108 2109 int 2110 uaudio_halt_in_dma(void *addr) 2111 { 2112 struct uaudio_softc *sc = addr; 2113 2114 DPRINTF(("uaudio_halt_in_dma: enter\n")); 2115 if (sc->sc_recchan.pipe != NULL) { 2116 uaudio_chan_close(sc, &sc->sc_recchan); 2117 sc->sc_recchan.pipe = NULL; 2118 uaudio_chan_free_buffers(sc, &sc->sc_recchan); 2119 sc->sc_recchan.intr = NULL; 2120 } 2121 return (0); 2122 } 2123 2124 int 2125 uaudio_getdev(void *addr, struct audio_device *retp) 2126 { 2127 struct uaudio_softc *sc = addr; 2128 2129 DPRINTF(("uaudio_mixer_getdev:\n")); 2130 if (sc->sc_dying) 2131 return (EIO); 2132 2133 *retp = uaudio_device; 2134 return (0); 2135 } 2136 2137 /* 2138 * Make sure the block size is large enough to hold all outstanding transfers. 2139 */ 2140 int 2141 uaudio_round_blocksize(void *addr, int blk) 2142 { 2143 struct uaudio_softc *sc = addr; 2144 int bpf; 2145 2146 DPRINTF(("uaudio_round_blocksize: p.bpf=%d r.bpf=%d\n", 2147 sc->sc_playchan.bytes_per_frame, 2148 sc->sc_recchan.bytes_per_frame)); 2149 if (sc->sc_playchan.bytes_per_frame > sc->sc_recchan.bytes_per_frame) { 2150 bpf = sc->sc_playchan.bytes_per_frame 2151 + sc->sc_playchan.sample_size; 2152 } else { 2153 bpf = sc->sc_recchan.bytes_per_frame 2154 + sc->sc_recchan.sample_size; 2155 } 2156 /* XXX */ 2157 bpf *= UAUDIO_NFRAMES * UAUDIO_NCHANBUFS; 2158 2159 bpf = (bpf + 15) &~ 15; 2160 2161 if (blk < bpf) 2162 blk = bpf; 2163 2164 #ifdef DIAGNOSTIC 2165 if (blk <= 0) { 2166 printf("uaudio_round_blocksize: blk=%d\n", blk); 2167 blk = 512; 2168 } 2169 #endif 2170 2171 DPRINTFN(1,("uaudio_round_blocksize: blk=%d\n", blk)); 2172 return (blk); 2173 } 2174 2175 int 2176 uaudio_get_props(void *addr) 2177 { 2178 return (AUDIO_PROP_FULLDUPLEX | AUDIO_PROP_INDEPENDENT); 2179 2180 } 2181 2182 int 2183 uaudio_get(struct uaudio_softc *sc, int which, int type, int wValue, 2184 int wIndex, int len) 2185 { 2186 usb_device_request_t req; 2187 u_int8_t data[4]; 2188 usbd_status err; 2189 int val; 2190 2191 if (wValue == -1) 2192 return (0); 2193 2194 req.bmRequestType = type; 2195 req.bRequest = which; 2196 USETW(req.wValue, wValue); 2197 USETW(req.wIndex, wIndex); 2198 USETW(req.wLength, len); 2199 DPRINTFN(2,("uaudio_get: type=0x%02x req=0x%02x wValue=0x%04x " 2200 "wIndex=0x%04x len=%d\n", 2201 type, which, wValue, wIndex, len)); 2202 err = usbd_do_request(sc->sc_udev, &req, data); 2203 if (err) { 2204 DPRINTF(("uaudio_get: err=%s\n", usbd_errstr(err))); 2205 return (-1); 2206 } 2207 switch (len) { 2208 case 1: 2209 val = data[0]; 2210 break; 2211 case 2: 2212 val = data[0] | (data[1] << 8); 2213 break; 2214 default: 2215 DPRINTF(("uaudio_get: bad length=%d\n", len)); 2216 return (-1); 2217 } 2218 DPRINTFN(2,("uaudio_get: val=%d\n", val)); 2219 return (val); 2220 } 2221 2222 void 2223 uaudio_set(struct uaudio_softc *sc, int which, int type, int wValue, 2224 int wIndex, int len, int val) 2225 { 2226 usb_device_request_t req; 2227 u_int8_t data[4]; 2228 usbd_status err; 2229 2230 if (wValue == -1) 2231 return; 2232 2233 req.bmRequestType = type; 2234 req.bRequest = which; 2235 USETW(req.wValue, wValue); 2236 USETW(req.wIndex, wIndex); 2237 USETW(req.wLength, len); 2238 switch (len) { 2239 case 1: 2240 data[0] = val; 2241 break; 2242 case 2: 2243 data[0] = val; 2244 data[1] = val >> 8; 2245 break; 2246 default: 2247 return; 2248 } 2249 DPRINTFN(2,("uaudio_set: type=0x%02x req=0x%02x wValue=0x%04x " 2250 "wIndex=0x%04x len=%d, val=%d\n", 2251 type, which, wValue, wIndex, len, val & 0xffff)); 2252 err = usbd_do_request(sc->sc_udev, &req, data); 2253 #ifdef UAUDIO_DEBUG 2254 if (err) 2255 DPRINTF(("uaudio_set: err=%d\n", err)); 2256 #endif 2257 } 2258 2259 int 2260 uaudio_signext(int type, int val) 2261 { 2262 if (!MIX_UNSIGNED(type)) { 2263 if (MIX_SIZE(type) == 2) 2264 val = (int16_t)val; 2265 else 2266 val = (int8_t)val; 2267 } 2268 return (val); 2269 } 2270 2271 int 2272 uaudio_value2bsd(struct mixerctl *mc, int val) 2273 { 2274 DPRINTFN(5, ("uaudio_value2bsd: type=%03x val=%d min=%d max=%d ", 2275 mc->type, val, mc->minval, mc->maxval)); 2276 if (mc->type == MIX_ON_OFF) { 2277 val = (val != 0); 2278 } else if (mc->type == MIX_SELECTOR) { 2279 if (val < mc->minval || val > mc->maxval) 2280 val = mc->minval; 2281 } else 2282 val = ((uaudio_signext(mc->type, val) - mc->minval) * 255 2283 + mc->mul/2) / mc->mul; 2284 DPRINTFN(5, ("val'=%d\n", val)); 2285 return (val); 2286 } 2287 2288 int 2289 uaudio_bsd2value(struct mixerctl *mc, int val) 2290 { 2291 DPRINTFN(5,("uaudio_bsd2value: type=%03x val=%d min=%d max=%d ", 2292 mc->type, val, mc->minval, mc->maxval)); 2293 if (mc->type == MIX_ON_OFF) { 2294 val = (val != 0); 2295 } else if (mc->type == MIX_SELECTOR) { 2296 if (val < mc->minval || val > mc->maxval) 2297 val = mc->minval; 2298 } else 2299 val = (val + mc->delta/2) * mc->mul / 255 + mc->minval; 2300 DPRINTFN(5, ("val'=%d\n", val)); 2301 return (val); 2302 } 2303 2304 int 2305 uaudio_ctl_get(struct uaudio_softc *sc, int which, struct mixerctl *mc, 2306 int chan) 2307 { 2308 int val; 2309 2310 DPRINTFN(5,("uaudio_ctl_get: which=%d chan=%d\n", which, chan)); 2311 val = uaudio_get(sc, which, UT_READ_CLASS_INTERFACE, mc->wValue[chan], 2312 mc->wIndex, MIX_SIZE(mc->type)); 2313 return (uaudio_value2bsd(mc, val)); 2314 } 2315 2316 void 2317 uaudio_ctl_set(struct uaudio_softc *sc, int which, struct mixerctl *mc, 2318 int chan, int val) 2319 { 2320 val = uaudio_bsd2value(mc, val); 2321 uaudio_set(sc, which, UT_WRITE_CLASS_INTERFACE, mc->wValue[chan], 2322 mc->wIndex, MIX_SIZE(mc->type), val); 2323 } 2324 2325 int 2326 uaudio_mixer_get_port(void *addr, mixer_ctrl_t *cp) 2327 { 2328 struct uaudio_softc *sc = addr; 2329 struct mixerctl *mc; 2330 int i, n, vals[MIX_MAX_CHAN], val; 2331 2332 DPRINTFN(2,("uaudio_mixer_get_port: index=%d\n", cp->dev)); 2333 2334 if (sc->sc_dying) 2335 return (EIO); 2336 2337 n = cp->dev - UAC_NCLASSES; 2338 if (n < 0 || n >= sc->sc_nctls) 2339 return (ENXIO); 2340 mc = &sc->sc_ctls[n]; 2341 2342 if (mc->type == MIX_ON_OFF) { 2343 if (cp->type != AUDIO_MIXER_ENUM) 2344 return (EINVAL); 2345 cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0); 2346 } else if (mc->type == MIX_SELECTOR) { 2347 if (cp->type != AUDIO_MIXER_ENUM) 2348 return (EINVAL); 2349 cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0); 2350 } else { 2351 if (cp->type != AUDIO_MIXER_VALUE) 2352 return (EINVAL); 2353 if (cp->un.value.num_channels != 1 && 2354 cp->un.value.num_channels != mc->nchan) 2355 return (EINVAL); 2356 for (i = 0; i < mc->nchan; i++) 2357 vals[i] = uaudio_ctl_get(sc, GET_CUR, mc, i); 2358 if (cp->un.value.num_channels == 1 && mc->nchan != 1) { 2359 for (val = 0, i = 0; i < mc->nchan; i++) 2360 val += vals[i]; 2361 vals[0] = val / mc->nchan; 2362 } 2363 for (i = 0; i < cp->un.value.num_channels; i++) 2364 cp->un.value.level[i] = vals[i]; 2365 } 2366 2367 return (0); 2368 } 2369 2370 int 2371 uaudio_mixer_set_port(void *addr, mixer_ctrl_t *cp) 2372 { 2373 struct uaudio_softc *sc = addr; 2374 struct mixerctl *mc; 2375 int i, n, vals[MIX_MAX_CHAN]; 2376 2377 DPRINTFN(2,("uaudio_mixer_set_port: index = %d\n", cp->dev)); 2378 if (sc->sc_dying) 2379 return (EIO); 2380 2381 n = cp->dev - UAC_NCLASSES; 2382 if (n < 0 || n >= sc->sc_nctls) 2383 return (ENXIO); 2384 mc = &sc->sc_ctls[n]; 2385 2386 if (mc->type == MIX_ON_OFF) { 2387 if (cp->type != AUDIO_MIXER_ENUM) 2388 return (EINVAL); 2389 uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord); 2390 } else if (mc->type == MIX_SELECTOR) { 2391 if (cp->type != AUDIO_MIXER_ENUM) 2392 return (EINVAL); 2393 uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord); 2394 } else { 2395 if (cp->type != AUDIO_MIXER_VALUE) 2396 return (EINVAL); 2397 if (cp->un.value.num_channels == 1) 2398 for (i = 0; i < mc->nchan; i++) 2399 vals[i] = cp->un.value.level[0]; 2400 else if (cp->un.value.num_channels == mc->nchan) 2401 for (i = 0; i < mc->nchan; i++) 2402 vals[i] = cp->un.value.level[i]; 2403 else 2404 return (EINVAL); 2405 for (i = 0; i < mc->nchan; i++) 2406 uaudio_ctl_set(sc, SET_CUR, mc, i, vals[i]); 2407 } 2408 return (0); 2409 } 2410 2411 int 2412 uaudio_trigger_input(void *addr, void *start, void *end, int blksize, 2413 void (*intr)(void *), void *arg, 2414 struct audio_params *param) 2415 { 2416 struct uaudio_softc *sc = addr; 2417 struct chan *ch = &sc->sc_recchan; 2418 usbd_status err; 2419 int i, s; 2420 2421 if (sc->sc_dying) 2422 return (EIO); 2423 2424 DPRINTFN(3,("uaudio_trigger_input: sc=%p start=%p end=%p " 2425 "blksize=%d\n", sc, start, end, blksize)); 2426 2427 uaudio_chan_set_param(ch, start, end, blksize); 2428 DPRINTFN(3,("uaudio_trigger_input: sample_size=%d bytes/frame=%d " 2429 "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame, 2430 ch->fraction)); 2431 2432 err = uaudio_chan_alloc_buffers(sc, ch); 2433 if (err) 2434 return (EIO); 2435 2436 err = uaudio_chan_open(sc, ch); 2437 if (err) { 2438 uaudio_chan_free_buffers(sc, ch); 2439 return (EIO); 2440 } 2441 2442 ch->intr = intr; 2443 ch->arg = arg; 2444 2445 s = splusb(); 2446 for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */ 2447 uaudio_chan_rtransfer(ch); 2448 splx(s); 2449 2450 return (0); 2451 } 2452 2453 int 2454 uaudio_trigger_output(void *addr, void *start, void *end, int blksize, 2455 void (*intr)(void *), void *arg, 2456 struct audio_params *param) 2457 { 2458 struct uaudio_softc *sc = addr; 2459 struct chan *ch = &sc->sc_playchan; 2460 usbd_status err; 2461 int i, s; 2462 2463 if (sc->sc_dying) 2464 return (EIO); 2465 2466 DPRINTFN(3,("uaudio_trigger_output: sc=%p start=%p end=%p " 2467 "blksize=%d\n", sc, start, end, blksize)); 2468 2469 uaudio_chan_set_param(ch, start, end, blksize); 2470 DPRINTFN(3,("uaudio_trigger_output: sample_size=%d bytes/frame=%d " 2471 "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame, 2472 ch->fraction)); 2473 2474 err = uaudio_chan_alloc_buffers(sc, ch); 2475 if (err) 2476 return (EIO); 2477 2478 err = uaudio_chan_open(sc, ch); 2479 if (err) { 2480 uaudio_chan_free_buffers(sc, ch); 2481 return (EIO); 2482 } 2483 2484 ch->intr = intr; 2485 ch->arg = arg; 2486 2487 s = splusb(); 2488 for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */ 2489 uaudio_chan_ptransfer(ch); 2490 splx(s); 2491 2492 return (0); 2493 } 2494 2495 /* Set up a pipe for a channel. */ 2496 usbd_status 2497 uaudio_chan_open(struct uaudio_softc *sc, struct chan *ch) 2498 { 2499 struct as_info *as = &sc->sc_alts[ch->altidx]; 2500 int endpt = as->edesc->bEndpointAddress; 2501 usbd_status err; 2502 2503 DPRINTF(("uaudio_chan_open: endpt=0x%02x, speed=%d, alt=%d\n", 2504 endpt, ch->sample_rate, as->alt)); 2505 2506 /* Set alternate interface corresponding to the mode. */ 2507 err = usbd_set_interface(as->ifaceh, as->alt); 2508 if (err) 2509 return (err); 2510 2511 /* Some devices do not support this request, so ignore errors. */ 2512 #ifdef UAUDIO_DEBUG 2513 err = uaudio_set_speed(sc, endpt, ch->sample_rate); 2514 if (err) 2515 DPRINTF(("uaudio_chan_open: set_speed failed err=%s\n", 2516 usbd_errstr(err))); 2517 #else 2518 (void)uaudio_set_speed(sc, endpt, ch->sample_rate); 2519 #endif 2520 2521 DPRINTF(("uaudio_chan_open: create pipe to 0x%02x\n", endpt)); 2522 err = usbd_open_pipe(as->ifaceh, endpt, 0, &ch->pipe); 2523 return (err); 2524 } 2525 2526 void 2527 uaudio_chan_close(struct uaudio_softc *sc, struct chan *ch) 2528 { 2529 struct as_info *as = &sc->sc_alts[ch->altidx]; 2530 2531 as->sc_busy = 0; 2532 if (sc->sc_nullalt >= 0) { 2533 DPRINTF(("uaudio_chan_close: set null alt=%d\n", 2534 sc->sc_nullalt)); 2535 usbd_set_interface(as->ifaceh, sc->sc_nullalt); 2536 } 2537 usbd_abort_pipe(ch->pipe); 2538 usbd_close_pipe(ch->pipe); 2539 } 2540 2541 usbd_status 2542 uaudio_chan_alloc_buffers(struct uaudio_softc *sc, struct chan *ch) 2543 { 2544 usbd_xfer_handle xfer; 2545 void *buf; 2546 int i, size; 2547 2548 size = (ch->bytes_per_frame + ch->sample_size) * UAUDIO_NFRAMES; 2549 for (i = 0; i < UAUDIO_NCHANBUFS; i++) { 2550 xfer = usbd_alloc_xfer(sc->sc_udev); 2551 if (xfer == 0) 2552 goto bad; 2553 ch->chanbufs[i].xfer = xfer; 2554 buf = usbd_alloc_buffer(xfer, size); 2555 if (buf == 0) { 2556 i++; 2557 goto bad; 2558 } 2559 ch->chanbufs[i].buffer = buf; 2560 ch->chanbufs[i].chan = ch; 2561 } 2562 2563 return (USBD_NORMAL_COMPLETION); 2564 2565 bad: 2566 while (--i >= 0) 2567 /* implicit buffer free */ 2568 usbd_free_xfer(ch->chanbufs[i].xfer); 2569 return (USBD_NOMEM); 2570 } 2571 2572 void 2573 uaudio_chan_free_buffers(struct uaudio_softc *sc, struct chan *ch) 2574 { 2575 int i; 2576 2577 for (i = 0; i < UAUDIO_NCHANBUFS; i++) 2578 usbd_free_xfer(ch->chanbufs[i].xfer); 2579 } 2580 2581 /* Called at splusb() */ 2582 void 2583 uaudio_chan_ptransfer(struct chan *ch) 2584 { 2585 struct chanbuf *cb; 2586 int i, n, size, residue, total; 2587 2588 if (ch->sc->sc_dying) 2589 return; 2590 2591 /* Pick the next channel buffer. */ 2592 cb = &ch->chanbufs[ch->curchanbuf]; 2593 if (++ch->curchanbuf >= UAUDIO_NCHANBUFS) 2594 ch->curchanbuf = 0; 2595 2596 /* Compute the size of each frame in the next transfer. */ 2597 residue = ch->residue; 2598 total = 0; 2599 for (i = 0; i < UAUDIO_NFRAMES; i++) { 2600 size = ch->bytes_per_frame; 2601 residue += ch->fraction; 2602 if (residue >= USB_FRAMES_PER_SECOND) { 2603 if ((ch->sc->sc_altflags & UA_NOFRAC) == 0) 2604 size += ch->sample_size; 2605 residue -= USB_FRAMES_PER_SECOND; 2606 } 2607 cb->sizes[i] = size; 2608 total += size; 2609 } 2610 ch->residue = residue; 2611 cb->size = total; 2612 2613 /* 2614 * Transfer data from upper layer buffer to channel buffer, taking 2615 * care of wrapping the upper layer buffer. 2616 */ 2617 n = min(total, ch->end - ch->cur); 2618 memcpy(cb->buffer, ch->cur, n); 2619 ch->cur += n; 2620 if (ch->cur >= ch->end) 2621 ch->cur = ch->start; 2622 if (total > n) { 2623 total -= n; 2624 memcpy(cb->buffer + n, ch->cur, total); 2625 ch->cur += total; 2626 } 2627 2628 #ifdef UAUDIO_DEBUG 2629 if (uaudiodebug > 8) { 2630 DPRINTF(("uaudio_chan_ptransfer: buffer=%p, residue=0.%03d\n", 2631 cb->buffer, ch->residue)); 2632 for (i = 0; i < UAUDIO_NFRAMES; i++) { 2633 DPRINTF((" [%d] length %d\n", i, cb->sizes[i])); 2634 } 2635 } 2636 #endif 2637 2638 DPRINTFN(5,("uaudio_chan_transfer: ptransfer xfer=%p\n", cb->xfer)); 2639 /* Fill the request */ 2640 usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes, 2641 UAUDIO_NFRAMES, USBD_NO_COPY, 2642 uaudio_chan_pintr); 2643 2644 (void)usbd_transfer(cb->xfer); 2645 } 2646 2647 void 2648 uaudio_chan_pintr(usbd_xfer_handle xfer, usbd_private_handle priv, 2649 usbd_status status) 2650 { 2651 struct chanbuf *cb = priv; 2652 struct chan *ch = cb->chan; 2653 u_int32_t count; 2654 int s; 2655 2656 /* Return if we are aborting. */ 2657 if (status == USBD_CANCELLED) 2658 return; 2659 2660 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 2661 DPRINTFN(5,("uaudio_chan_pintr: count=%d, transferred=%d\n", 2662 count, ch->transferred)); 2663 #ifdef DIAGNOSTIC 2664 if (count != cb->size) { 2665 printf("uaudio_chan_pintr: count(%d) != size(%d)\n", 2666 count, cb->size); 2667 } 2668 #endif 2669 2670 ch->transferred += cb->size; 2671 s = splaudio(); 2672 /* Call back to upper layer */ 2673 while (ch->transferred >= ch->blksize) { 2674 ch->transferred -= ch->blksize; 2675 DPRINTFN(5,("uaudio_chan_pintr: call %p(%p)\n", 2676 ch->intr, ch->arg)); 2677 ch->intr(ch->arg); 2678 } 2679 splx(s); 2680 2681 /* start next transfer */ 2682 uaudio_chan_ptransfer(ch); 2683 } 2684 2685 /* Called at splusb() */ 2686 void 2687 uaudio_chan_rtransfer(struct chan *ch) 2688 { 2689 struct chanbuf *cb; 2690 int i, size, residue, total; 2691 2692 if (ch->sc->sc_dying) 2693 return; 2694 2695 /* Pick the next channel buffer. */ 2696 cb = &ch->chanbufs[ch->curchanbuf]; 2697 if (++ch->curchanbuf >= UAUDIO_NCHANBUFS) 2698 ch->curchanbuf = 0; 2699 2700 /* Compute the size of each frame in the next transfer. */ 2701 residue = ch->residue; 2702 total = 0; 2703 for (i = 0; i < UAUDIO_NFRAMES; i++) { 2704 size = ch->bytes_per_frame; 2705 cb->sizes[i] = size; 2706 cb->offsets[i] = total; 2707 total += size; 2708 } 2709 ch->residue = residue; 2710 cb->size = total; 2711 2712 #ifdef UAUDIO_DEBUG 2713 if (uaudiodebug > 8) { 2714 DPRINTF(("uaudio_chan_rtransfer: buffer=%p, residue=0.%03d\n", 2715 cb->buffer, ch->residue)); 2716 for (i = 0; i < UAUDIO_NFRAMES; i++) { 2717 DPRINTF((" [%d] length %d\n", i, cb->sizes[i])); 2718 } 2719 } 2720 #endif 2721 2722 DPRINTFN(5,("uaudio_chan_rtransfer: transfer xfer=%p\n", cb->xfer)); 2723 /* Fill the request */ 2724 usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes, 2725 UAUDIO_NFRAMES, USBD_NO_COPY, 2726 uaudio_chan_rintr); 2727 2728 (void)usbd_transfer(cb->xfer); 2729 } 2730 2731 void 2732 uaudio_chan_rintr(usbd_xfer_handle xfer, usbd_private_handle priv, 2733 usbd_status status) 2734 { 2735 struct chanbuf *cb = priv; 2736 struct chan *ch = cb->chan; 2737 u_int32_t count; 2738 int s, i, n, frsize; 2739 2740 /* Return if we are aborting. */ 2741 if (status == USBD_CANCELLED) 2742 return; 2743 2744 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 2745 DPRINTFN(5,("uaudio_chan_rintr: count=%d, transferred=%d\n", 2746 count, ch->transferred)); 2747 2748 /* count < cb->size is normal for asynchronous source */ 2749 #ifdef DIAGNOSTIC 2750 if (count > cb->size) { 2751 printf("uaudio_chan_rintr: count(%d) > size(%d)\n", 2752 count, cb->size); 2753 } 2754 #endif 2755 2756 /* 2757 * Transfer data from channel buffer to upper layer buffer, taking 2758 * care of wrapping the upper layer buffer. 2759 */ 2760 for(i = 0; i < UAUDIO_NFRAMES; i++) { 2761 frsize = cb->sizes[i]; 2762 n = min(frsize, ch->end - ch->cur); 2763 memcpy(ch->cur, cb->buffer + cb->offsets[i], n); 2764 ch->cur += n; 2765 if (ch->cur >= ch->end) 2766 ch->cur = ch->start; 2767 if (frsize > n) { 2768 memcpy(ch->cur, cb->buffer + cb->offsets[i] + n, 2769 frsize - n); 2770 ch->cur += frsize - n; 2771 } 2772 } 2773 2774 /* Call back to upper layer */ 2775 ch->transferred += count; 2776 s = splaudio(); 2777 while (ch->transferred >= ch->blksize) { 2778 ch->transferred -= ch->blksize; 2779 DPRINTFN(5,("uaudio_chan_rintr: call %p(%p)\n", 2780 ch->intr, ch->arg)); 2781 ch->intr(ch->arg); 2782 } 2783 splx(s); 2784 2785 /* start next transfer */ 2786 uaudio_chan_rtransfer(ch); 2787 } 2788 2789 void 2790 uaudio_chan_init(struct chan *ch, int altidx, const struct audio_params *param, 2791 int maxpktsize) 2792 { 2793 int samples_per_frame, sample_size; 2794 2795 ch->altidx = altidx; 2796 sample_size = param->precision * param->factor * param->hw_channels / 8; 2797 samples_per_frame = param->hw_sample_rate / USB_FRAMES_PER_SECOND; 2798 ch->sample_size = sample_size; 2799 ch->sample_rate = param->hw_sample_rate; 2800 if (maxpktsize == 0) { 2801 ch->fraction = param->hw_sample_rate % USB_FRAMES_PER_SECOND; 2802 ch->bytes_per_frame = samples_per_frame * sample_size; 2803 } else { 2804 ch->fraction = 0; 2805 ch->bytes_per_frame = maxpktsize; 2806 } 2807 ch->residue = 0; 2808 } 2809 2810 void 2811 uaudio_chan_set_param(struct chan *ch, u_char *start, u_char *end, int blksize) 2812 { 2813 ch->start = start; 2814 ch->end = end; 2815 ch->cur = start; 2816 ch->blksize = blksize; 2817 ch->transferred = 0; 2818 2819 ch->curchanbuf = 0; 2820 } 2821 2822 void 2823 uaudio_get_minmax_rates(int nalts, const struct as_info *alts, 2824 const struct audio_params *p, int mode, 2825 u_long *min, u_long *max) 2826 { 2827 const struct usb_audio_streaming_type1_descriptor *a1d; 2828 int i, j; 2829 2830 *min = ULONG_MAX; 2831 *max = 0; 2832 for (i = 0; i < nalts; i++) { 2833 a1d = alts[i].asf1desc; 2834 if (alts[i].sc_busy) 2835 continue; 2836 if (p->hw_channels != a1d->bNrChannels) 2837 continue; 2838 if (p->hw_precision != a1d->bBitResolution) 2839 continue; 2840 if (p->hw_encoding != alts[i].encoding) 2841 continue; 2842 if (mode != UE_GET_DIR(alts[i].edesc->bEndpointAddress)) 2843 continue; 2844 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) { 2845 DPRINTFN(2,("uaudio_get_minmax_rates: cont %d-%d\n", 2846 UA_SAMP_LO(a1d), UA_SAMP_HI(a1d))); 2847 if (UA_SAMP_LO(a1d) < *min) 2848 *min = UA_SAMP_LO(a1d); 2849 if (UA_SAMP_HI(a1d) > *max) 2850 *max = UA_SAMP_HI(a1d); 2851 } else { 2852 for (j = 0; j < a1d->bSamFreqType; j++) { 2853 DPRINTFN(2,("uaudio_get_minmax_rates: disc #%d: %d\n", 2854 j, UA_GETSAMP(a1d, j))); 2855 if (UA_GETSAMP(a1d, j) < *min) 2856 *min = UA_GETSAMP(a1d, j); 2857 if (UA_GETSAMP(a1d, j) > *max) 2858 *max = UA_GETSAMP(a1d, j); 2859 } 2860 } 2861 } 2862 } 2863 2864 int 2865 uaudio_match_alt_sub(int nalts, const struct as_info *alts, 2866 const struct audio_params *p, int mode, u_long rate) 2867 { 2868 const struct usb_audio_streaming_type1_descriptor *a1d; 2869 int i, j; 2870 2871 DPRINTF(("uaudio_match_alt_sub: search for %luHz %dch\n", 2872 rate, p->hw_channels)); 2873 for (i = 0; i < nalts; i++) { 2874 a1d = alts[i].asf1desc; 2875 if (alts[i].sc_busy) 2876 continue; 2877 if (p->hw_channels != a1d->bNrChannels) 2878 continue; 2879 if (p->hw_precision != a1d->bBitResolution) 2880 continue; 2881 if (p->hw_encoding != alts[i].encoding) 2882 continue; 2883 if (mode != UE_GET_DIR(alts[i].edesc->bEndpointAddress)) 2884 continue; 2885 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) { 2886 DPRINTFN(3,("uaudio_match_alt_sub: cont %d-%d\n", 2887 UA_SAMP_LO(a1d), UA_SAMP_HI(a1d))); 2888 if (UA_SAMP_LO(a1d) <= rate && rate <= UA_SAMP_HI(a1d)) 2889 return i; 2890 } else { 2891 for (j = 0; j < a1d->bSamFreqType; j++) { 2892 DPRINTFN(3,("uaudio_match_alt_sub: disc #%d: %d\n", 2893 j, UA_GETSAMP(a1d, j))); 2894 /* XXX allow for some slack */ 2895 if (UA_GETSAMP(a1d, j) == rate) 2896 return i; 2897 } 2898 } 2899 } 2900 return -1; 2901 } 2902 2903 int 2904 uaudio_match_alt_chan(int nalts, const struct as_info *alts, 2905 struct audio_params *p, int mode) 2906 { 2907 int i, n; 2908 u_long min, max; 2909 u_long rate; 2910 2911 /* Exact match */ 2912 DPRINTF(("uaudio_match_alt_chan: examine %ldHz %dch %dbit.\n", 2913 p->sample_rate, p->hw_channels, p->hw_precision)); 2914 i = uaudio_match_alt_sub(nalts, alts, p, mode, p->sample_rate); 2915 if (i >= 0) 2916 return i; 2917 2918 uaudio_get_minmax_rates(nalts, alts, p, mode, &min, &max); 2919 DPRINTF(("uaudio_match_alt_chan: min=%lu max=%lu\n", min, max)); 2920 if (max <= 0) 2921 return -1; 2922 /* Search for biggers */ 2923 n = 2; 2924 while ((rate = p->sample_rate * n++) <= max) { 2925 i = uaudio_match_alt_sub(nalts, alts, p, mode, rate); 2926 if (i >= 0) { 2927 p->hw_sample_rate = rate; 2928 return i; 2929 } 2930 } 2931 if (p->sample_rate >= min) { 2932 i = uaudio_match_alt_sub(nalts, alts, p, mode, max); 2933 if (i >= 0) { 2934 p->hw_sample_rate = max; 2935 return i; 2936 } 2937 } else { 2938 i = uaudio_match_alt_sub(nalts, alts, p, mode, min); 2939 if (i >= 0) { 2940 p->hw_sample_rate = min; 2941 return i; 2942 } 2943 } 2944 return -1; 2945 } 2946 2947 int 2948 uaudio_match_alt(int nalts, const struct as_info *alts, 2949 struct audio_params *p, int mode) 2950 { 2951 int i, n; 2952 2953 mode = mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN; 2954 i = uaudio_match_alt_chan(nalts, alts, p, mode); 2955 if (i >= 0) 2956 return i; 2957 2958 for (n = p->channels + 1; n <= AUDIO_MAX_CHANNELS; n++) { 2959 p->hw_channels = n; 2960 i = uaudio_match_alt_chan(nalts, alts, p, mode); 2961 if (i >= 0) 2962 return i; 2963 } 2964 2965 if (p->channels != 2) 2966 return -1; 2967 p->hw_channels = 1; 2968 return uaudio_match_alt_chan(nalts, alts, p, mode); 2969 } 2970 2971 int 2972 uaudio_set_params(void *addr, int setmode, int usemode, 2973 struct audio_params *play, struct audio_params *rec) 2974 { 2975 struct uaudio_softc *sc = addr; 2976 int flags = sc->sc_altflags; 2977 int factor; 2978 int enc, i; 2979 int paltidx=-1, raltidx=-1; 2980 void (*swcode)(void *, u_char *buf, int cnt); 2981 struct audio_params *p; 2982 int mode; 2983 2984 if (sc->sc_dying) 2985 return (EIO); 2986 2987 if (((usemode & AUMODE_PLAY) && sc->sc_playchan.pipe != NULL) || 2988 ((usemode & AUMODE_RECORD) && sc->sc_recchan.pipe != NULL)) 2989 return (EBUSY); 2990 2991 if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1) 2992 sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 0; 2993 if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1) 2994 sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 0; 2995 2996 /* Some uaudio devices are unidirectional. Don't try to find a 2997 matching mode for the unsupported direction. */ 2998 setmode &= sc->sc_mode; 2999 3000 for (mode = AUMODE_RECORD; mode != -1; 3001 mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) { 3002 if ((setmode & mode) == 0) 3003 continue; 3004 3005 p = (mode == AUMODE_PLAY) ? play : rec; 3006 3007 factor = 1; 3008 swcode = 0; 3009 enc = p->encoding; 3010 switch (enc) { 3011 case AUDIO_ENCODING_SLINEAR_BE: 3012 /* FALLTHROUGH */ 3013 case AUDIO_ENCODING_SLINEAR_LE: 3014 if (enc == AUDIO_ENCODING_SLINEAR_BE 3015 && p->precision == 16 && (flags & HAS_16)) { 3016 swcode = swap_bytes; 3017 enc = AUDIO_ENCODING_SLINEAR_LE; 3018 } else if (p->precision == 8) { 3019 if (flags & HAS_8) { 3020 /* No conversion */ 3021 } else if (flags & HAS_8U) { 3022 swcode = change_sign8; 3023 enc = AUDIO_ENCODING_ULINEAR_LE; 3024 } else if (flags & HAS_16) { 3025 factor = 2; 3026 p->hw_precision = 16; 3027 if (mode == AUMODE_PLAY) 3028 swcode = linear8_to_linear16_le; 3029 else 3030 swcode = linear16_to_linear8_le; 3031 } 3032 } 3033 break; 3034 case AUDIO_ENCODING_ULINEAR_BE: 3035 /* FALLTHROUGH */ 3036 case AUDIO_ENCODING_ULINEAR_LE: 3037 if (p->precision == 16) { 3038 if (enc == AUDIO_ENCODING_ULINEAR_LE) 3039 swcode = change_sign16_le; 3040 else if (mode == AUMODE_PLAY) 3041 swcode = swap_bytes_change_sign16_le; 3042 else 3043 swcode = change_sign16_swap_bytes_le; 3044 enc = AUDIO_ENCODING_SLINEAR_LE; 3045 } else if (p->precision == 8) { 3046 if (flags & HAS_8U) { 3047 /* No conversion */ 3048 } else if (flags & HAS_8) { 3049 swcode = change_sign8; 3050 enc = AUDIO_ENCODING_SLINEAR_LE; 3051 } else if (flags & HAS_16) { 3052 factor = 2; 3053 p->hw_precision = 16; 3054 enc = AUDIO_ENCODING_SLINEAR_LE; 3055 if (mode == AUMODE_PLAY) 3056 swcode = ulinear8_to_slinear16_le; 3057 else 3058 swcode = slinear16_to_ulinear8_le; 3059 } 3060 } 3061 break; 3062 case AUDIO_ENCODING_ULAW: 3063 if (flags & HAS_MULAW) 3064 break; 3065 if (flags & HAS_16) { 3066 if (mode == AUMODE_PLAY) 3067 swcode = mulaw_to_slinear16_le; 3068 else 3069 swcode = slinear16_to_mulaw_le; 3070 factor = 2; 3071 enc = AUDIO_ENCODING_SLINEAR_LE; 3072 p->hw_precision = 16; 3073 } else if (flags & HAS_8U) { 3074 if (mode == AUMODE_PLAY) 3075 swcode = mulaw_to_ulinear8; 3076 else 3077 swcode = ulinear8_to_mulaw; 3078 enc = AUDIO_ENCODING_ULINEAR_LE; 3079 } else if (flags & HAS_8) { 3080 if (mode == AUMODE_PLAY) 3081 swcode = mulaw_to_slinear8; 3082 else 3083 swcode = slinear8_to_mulaw; 3084 enc = AUDIO_ENCODING_SLINEAR_LE; 3085 } else 3086 return (EINVAL); 3087 break; 3088 case AUDIO_ENCODING_ALAW: 3089 if (flags & HAS_ALAW) 3090 break; 3091 if (mode == AUMODE_PLAY && (flags & HAS_16)) { 3092 swcode = alaw_to_slinear16_le; 3093 factor = 2; 3094 enc = AUDIO_ENCODING_SLINEAR_LE; 3095 p->hw_precision = 16; 3096 } else if (flags & HAS_8U) { 3097 if (mode == AUMODE_PLAY) 3098 swcode = alaw_to_ulinear8; 3099 else 3100 swcode = ulinear8_to_alaw; 3101 enc = AUDIO_ENCODING_ULINEAR_LE; 3102 } else if (flags & HAS_8) { 3103 if (mode == AUMODE_PLAY) 3104 swcode = alaw_to_slinear8; 3105 else 3106 swcode = slinear8_to_alaw; 3107 enc = AUDIO_ENCODING_SLINEAR_LE; 3108 } else 3109 return (EINVAL); 3110 break; 3111 default: 3112 return (EINVAL); 3113 } 3114 /* XXX do some other conversions... */ 3115 3116 DPRINTF(("uaudio_set_params: chan=%d prec=%d enc=%d rate=%ld\n", 3117 p->channels, p->hw_precision, enc, p->sample_rate)); 3118 3119 p->hw_encoding = enc; 3120 i = uaudio_match_alt(sc->sc_nalts, sc->sc_alts, p, mode); 3121 if (i < 0) 3122 return (EINVAL); 3123 3124 p->sw_code = swcode; 3125 p->factor = factor; 3126 3127 if (mode == AUMODE_PLAY) 3128 paltidx = i; 3129 else 3130 raltidx = i; 3131 } 3132 3133 if ((setmode & AUMODE_PLAY)) { 3134 /* XXX abort transfer if currently happening? */ 3135 uaudio_chan_init(&sc->sc_playchan, paltidx, play, 0); 3136 } 3137 if ((setmode & AUMODE_RECORD)) { 3138 /* XXX abort transfer if currently happening? */ 3139 uaudio_chan_init(&sc->sc_recchan, raltidx, rec, 3140 UGETW(sc->sc_alts[raltidx].edesc->wMaxPacketSize)); 3141 } 3142 3143 if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1) 3144 sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 1; 3145 if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1) 3146 sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 1; 3147 3148 DPRINTF(("uaudio_set_params: use altidx=p%d/r%d, altno=p%d/r%d\n", 3149 sc->sc_playchan.altidx, sc->sc_recchan.altidx, 3150 (sc->sc_playchan.altidx >= 0) 3151 ?sc->sc_alts[sc->sc_playchan.altidx].idesc->bAlternateSetting 3152 : -1, 3153 (sc->sc_recchan.altidx >= 0) 3154 ? sc->sc_alts[sc->sc_recchan.altidx].idesc->bAlternateSetting 3155 : -1)); 3156 3157 return (0); 3158 } 3159 3160 usbd_status 3161 uaudio_set_speed(struct uaudio_softc *sc, int endpt, u_int speed) 3162 { 3163 usb_device_request_t req; 3164 u_int8_t data[3]; 3165 3166 DPRINTFN(5,("uaudio_set_speed: endpt=%d speed=%u\n", endpt, speed)); 3167 req.bmRequestType = UT_WRITE_CLASS_ENDPOINT; 3168 req.bRequest = SET_CUR; 3169 USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0); 3170 USETW(req.wIndex, endpt); 3171 USETW(req.wLength, 3); 3172 data[0] = speed; 3173 data[1] = speed >> 8; 3174 data[2] = speed >> 16; 3175 3176 return (usbd_do_request(sc->sc_udev, &req, data)); 3177 } 3178
Indexes created Fri Sep 26 08:10:20 GMT 2025