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