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