1 /* $NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $ */ 2 /* $FreeBSD$ */ 3 4 /*- 5 * Copyright (c) 1999 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Lennart Augustsson (lennart@augustsson.net) at 10 * Carlstedt Research & Technology. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 /* 38 * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf 39 * http://www.usb.org/developers/devclass_docs/frmts10.pdf 40 * http://www.usb.org/developers/devclass_docs/termt10.pdf 41 */ 42 43 /* 44 * Also merged: 45 * $NetBSD: uaudio.c,v 1.94 2005/01/15 15:19:53 kent Exp $ 46 * $NetBSD: uaudio.c,v 1.95 2005/01/16 06:02:19 dsainty Exp $ 47 * $NetBSD: uaudio.c,v 1.96 2005/01/16 12:46:00 kent Exp $ 48 * $NetBSD: uaudio.c,v 1.97 2005/02/24 08:19:38 martin Exp $ 49 */ 50 51 #include <sys/stdint.h> 52 #include <sys/stddef.h> 53 #include <sys/param.h> 54 #include <sys/queue.h> 55 #include <sys/types.h> 56 #include <sys/systm.h> 57 #include <sys/kernel.h> 58 #include <sys/bus.h> 59 #include <sys/module.h> 60 #include <sys/lock.h> 61 #include <sys/mutex.h> 62 #include <sys/condvar.h> 63 #include <sys/sysctl.h> 64 #include <sys/sx.h> 65 #include <sys/unistd.h> 66 #include <sys/callout.h> 67 #include <sys/malloc.h> 68 #include <sys/priv.h> 69 70 #include "usbdevs.h" 71 #include <dev/usb/usb.h> 72 #include <dev/usb/usbdi.h> 73 #include <dev/usb/usbdi_util.h> 74 75 #define USB_DEBUG_VAR uaudio_debug 76 #include <dev/usb/usb_debug.h> 77 78 #include <dev/usb/quirk/usb_quirk.h> 79 80 #include <sys/reboot.h> /* for bootverbose */ 81 82 #ifdef HAVE_KERNEL_OPTION_HEADERS 83 #include "opt_snd.h" 84 #endif 85 86 #include <dev/sound/pcm/sound.h> 87 #include <dev/sound/usb/uaudioreg.h> 88 #include <dev/sound/usb/uaudio.h> 89 #include <dev/sound/chip.h> 90 #include "feeder_if.h" 91 92 static int uaudio_default_rate = 0; /* use rate list */ 93 static int uaudio_default_bits = 32; 94 static int uaudio_default_channels = 0; /* use default */ 95 96 #ifdef USB_DEBUG 97 static int uaudio_debug = 0; 98 99 static SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW, 0, "USB uaudio"); 100 101 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RW, 102 &uaudio_debug, 0, "uaudio debug level"); 103 104 TUNABLE_INT("hw.usb.uaudio.default_rate", &uaudio_default_rate); 105 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_rate, CTLFLAG_RW, 106 &uaudio_default_rate, 0, "uaudio default sample rate"); 107 108 TUNABLE_INT("hw.usb.uaudio.default_bits", &uaudio_default_bits); 109 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_bits, CTLFLAG_RW, 110 &uaudio_default_bits, 0, "uaudio default sample bits"); 111 112 TUNABLE_INT("hw.usb.uaudio.default_channels", &uaudio_default_channels); 113 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_channels, CTLFLAG_RW, 114 &uaudio_default_channels, 0, "uaudio default sample channels"); 115 #endif 116 117 #define UAUDIO_NFRAMES 64 /* must be factor of 8 due HS-USB */ 118 #define UAUDIO_NCHANBUFS 2 /* number of outstanding request */ 119 #define UAUDIO_RECURSE_LIMIT 24 /* rounds */ 120 121 #define MAKE_WORD(h,l) (((h) << 8) | (l)) 122 #define BIT_TEST(bm,bno) (((bm)[(bno) / 8] >> (7 - ((bno) % 8))) & 1) 123 #define UAUDIO_MAX_CHAN(x) (x) 124 125 struct uaudio_mixer_node { 126 int32_t minval; 127 int32_t maxval; 128 #define MIX_MAX_CHAN 8 129 int32_t wValue[MIX_MAX_CHAN]; /* using nchan */ 130 uint32_t mul; 131 uint32_t ctl; 132 133 uint16_t wData[MIX_MAX_CHAN]; /* using nchan */ 134 uint16_t wIndex; 135 136 uint8_t update[(MIX_MAX_CHAN + 7) / 8]; 137 uint8_t nchan; 138 uint8_t type; 139 #define MIX_ON_OFF 1 140 #define MIX_SIGNED_16 2 141 #define MIX_UNSIGNED_16 3 142 #define MIX_SIGNED_8 4 143 #define MIX_SELECTOR 5 144 #define MIX_UNKNOWN 6 145 #define MIX_SIZE(n) ((((n) == MIX_SIGNED_16) || \ 146 ((n) == MIX_UNSIGNED_16)) ? 2 : 1) 147 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16) 148 149 #define MAX_SELECTOR_INPUT_PIN 256 150 uint8_t slctrtype[MAX_SELECTOR_INPUT_PIN]; 151 uint8_t class; 152 153 struct uaudio_mixer_node *next; 154 }; 155 156 struct uaudio_chan { 157 struct pcmchan_caps pcm_cap; /* capabilities */ 158 159 struct snd_dbuf *pcm_buf; 160 const struct usb_config *usb_cfg; 161 struct mtx *pcm_mtx; /* lock protecting this structure */ 162 struct uaudio_softc *priv_sc; 163 struct pcm_channel *pcm_ch; 164 struct usb_xfer *xfer[UAUDIO_NCHANBUFS]; 165 const struct usb_audio_streaming_interface_descriptor *p_asid; 166 const struct usb_audio_streaming_type1_descriptor *p_asf1d; 167 const struct usb_audio_streaming_endpoint_descriptor *p_sed; 168 const usb_endpoint_descriptor_audio_t *p_ed1; 169 const usb_endpoint_descriptor_audio_t *p_ed2; 170 const struct uaudio_format *p_fmt; 171 172 uint8_t *buf; /* pointer to buffer */ 173 uint8_t *start; /* upper layer buffer start */ 174 uint8_t *end; /* upper layer buffer end */ 175 uint8_t *cur; /* current position in upper layer 176 * buffer */ 177 178 uint32_t intr_size; /* in bytes */ 179 uint32_t intr_frames; /* in units */ 180 uint32_t sample_rate; 181 uint32_t frames_per_second; 182 uint32_t sample_rem; 183 uint32_t sample_curr; 184 185 uint32_t format; 186 uint32_t pcm_format[2]; 187 188 uint16_t bytes_per_frame[2]; 189 190 uint16_t sample_size; 191 192 uint8_t valid; 193 uint8_t iface_index; 194 uint8_t iface_alt_index; 195 }; 196 197 #define UMIDI_CABLES_MAX 16 /* units */ 198 #define UMIDI_TX_FRAMES 256 /* units */ 199 #define UMIDI_TX_BUFFER (UMIDI_TX_FRAMES * 4) /* bytes */ 200 201 enum { 202 UMIDI_TX_TRANSFER, 203 UMIDI_RX_TRANSFER, 204 UMIDI_N_TRANSFER, 205 }; 206 207 struct umidi_sub_chan { 208 struct usb_fifo_sc fifo; 209 uint8_t *temp_cmd; 210 uint8_t temp_0[4]; 211 uint8_t temp_1[4]; 212 uint8_t state; 213 #define UMIDI_ST_UNKNOWN 0 /* scan for command */ 214 #define UMIDI_ST_1PARAM 1 215 #define UMIDI_ST_2PARAM_1 2 216 #define UMIDI_ST_2PARAM_2 3 217 #define UMIDI_ST_SYSEX_0 4 218 #define UMIDI_ST_SYSEX_1 5 219 #define UMIDI_ST_SYSEX_2 6 220 221 uint8_t read_open:1; 222 uint8_t write_open:1; 223 uint8_t unused:6; 224 }; 225 226 struct umidi_chan { 227 228 struct umidi_sub_chan sub[UMIDI_CABLES_MAX]; 229 struct mtx mtx; 230 231 struct usb_xfer *xfer[UMIDI_N_TRANSFER]; 232 233 uint8_t iface_index; 234 uint8_t iface_alt_index; 235 236 uint8_t read_open_refcount; 237 uint8_t write_open_refcount; 238 239 uint8_t curr_cable; 240 uint8_t max_cable; 241 uint8_t valid; 242 uint8_t single_command; 243 }; 244 245 struct uaudio_softc { 246 struct sbuf sc_sndstat; 247 struct sndcard_func sc_sndcard_func; 248 struct uaudio_chan sc_rec_chan; 249 struct uaudio_chan sc_play_chan; 250 struct umidi_chan sc_midi_chan; 251 252 struct usb_device *sc_udev; 253 struct usb_xfer *sc_mixer_xfer[1]; 254 struct uaudio_mixer_node *sc_mixer_root; 255 struct uaudio_mixer_node *sc_mixer_curr; 256 257 uint32_t sc_mix_info; 258 uint32_t sc_recsrc_info; 259 260 uint16_t sc_audio_rev; 261 uint16_t sc_mixer_count; 262 263 uint8_t sc_sndstat_valid; 264 uint8_t sc_mixer_iface_index; 265 uint8_t sc_mixer_iface_no; 266 uint8_t sc_mixer_chan; 267 uint8_t sc_pcm_registered:1; 268 uint8_t sc_mixer_init:1; 269 uint8_t sc_uq_audio_swap_lr:1; 270 uint8_t sc_uq_au_inp_async:1; 271 uint8_t sc_uq_au_no_xu:1; 272 uint8_t sc_uq_bad_adc:1; 273 uint8_t sc_uq_au_vendor_class:1; 274 }; 275 276 struct uaudio_search_result { 277 uint8_t bit_input[(256 + 7) / 8]; 278 uint8_t bit_output[(256 + 7) / 8]; 279 uint8_t bit_visited[(256 + 7) / 8]; 280 uint8_t recurse_level; 281 uint8_t id_max; 282 }; 283 284 struct uaudio_terminal_node { 285 union { 286 const struct usb_descriptor *desc; 287 const struct usb_audio_input_terminal *it; 288 const struct usb_audio_output_terminal *ot; 289 const struct usb_audio_mixer_unit_0 *mu; 290 const struct usb_audio_selector_unit *su; 291 const struct usb_audio_feature_unit *fu; 292 const struct usb_audio_processing_unit_0 *pu; 293 const struct usb_audio_extension_unit_0 *eu; 294 } u; 295 struct uaudio_search_result usr; 296 struct uaudio_terminal_node *root; 297 }; 298 299 struct uaudio_format { 300 uint16_t wFormat; 301 uint8_t bPrecision; 302 uint32_t freebsd_fmt; 303 const char *description; 304 }; 305 306 static const struct uaudio_format uaudio_formats[] = { 307 308 {UA_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"}, 309 {UA_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"}, 310 {UA_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"}, 311 {UA_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"}, 312 313 {UA_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"}, 314 {UA_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"}, 315 {UA_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"}, 316 {UA_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"}, 317 318 {UA_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"}, 319 {UA_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"}, 320 321 {0, 0, 0, NULL} 322 }; 323 324 #define UAC_OUTPUT 0 325 #define UAC_INPUT 1 326 #define UAC_EQUAL 2 327 #define UAC_RECORD 3 328 #define UAC_NCLASSES 4 329 330 #ifdef USB_DEBUG 331 static const char *uac_names[] = { 332 "outputs", "inputs", "equalization", "record" 333 }; 334 335 #endif 336 337 /* prototypes */ 338 339 static device_probe_t uaudio_probe; 340 static device_attach_t uaudio_attach; 341 static device_detach_t uaudio_detach; 342 343 static usb_callback_t uaudio_chan_play_callback; 344 static usb_callback_t uaudio_chan_record_callback; 345 static usb_callback_t uaudio_mixer_write_cfg_callback; 346 static usb_callback_t umidi_bulk_read_callback; 347 static usb_callback_t umidi_bulk_write_callback; 348 349 static void uaudio_chan_fill_info_sub(struct uaudio_softc *, 350 struct usb_device *, uint32_t, uint8_t, uint8_t); 351 static void uaudio_chan_fill_info(struct uaudio_softc *, 352 struct usb_device *); 353 static void uaudio_mixer_add_ctl_sub(struct uaudio_softc *, 354 struct uaudio_mixer_node *); 355 static void uaudio_mixer_add_ctl(struct uaudio_softc *, 356 struct uaudio_mixer_node *); 357 static void uaudio_mixer_add_input(struct uaudio_softc *, 358 const struct uaudio_terminal_node *, int); 359 static void uaudio_mixer_add_output(struct uaudio_softc *, 360 const struct uaudio_terminal_node *, int); 361 static void uaudio_mixer_add_mixer(struct uaudio_softc *, 362 const struct uaudio_terminal_node *, int); 363 static void uaudio_mixer_add_selector(struct uaudio_softc *, 364 const struct uaudio_terminal_node *, int); 365 static uint32_t uaudio_mixer_feature_get_bmaControls( 366 const struct usb_audio_feature_unit *, uint8_t); 367 static void uaudio_mixer_add_feature(struct uaudio_softc *, 368 const struct uaudio_terminal_node *, int); 369 static void uaudio_mixer_add_processing_updown(struct uaudio_softc *, 370 const struct uaudio_terminal_node *, int); 371 static void uaudio_mixer_add_processing(struct uaudio_softc *, 372 const struct uaudio_terminal_node *, int); 373 static void uaudio_mixer_add_extension(struct uaudio_softc *, 374 const struct uaudio_terminal_node *, int); 375 static struct usb_audio_cluster uaudio_mixer_get_cluster(uint8_t, 376 const struct uaudio_terminal_node *); 377 static uint16_t uaudio_mixer_determine_class(const struct uaudio_terminal_node *, 378 struct uaudio_mixer_node *); 379 static uint16_t uaudio_mixer_feature_name(const struct uaudio_terminal_node *, 380 struct uaudio_mixer_node *); 381 static const struct uaudio_terminal_node *uaudio_mixer_get_input( 382 const struct uaudio_terminal_node *, uint8_t); 383 static const struct uaudio_terminal_node *uaudio_mixer_get_output( 384 const struct uaudio_terminal_node *, uint8_t); 385 static void uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *, 386 const uint8_t *, uint8_t, struct uaudio_search_result *); 387 static void uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *, 388 uint8_t, uint8_t, struct uaudio_search_result *); 389 static void uaudio_mixer_fill_info(struct uaudio_softc *, 390 struct usb_device *, void *); 391 static uint16_t uaudio_mixer_get(struct usb_device *, uint8_t, 392 struct uaudio_mixer_node *); 393 static void uaudio_mixer_ctl_set(struct uaudio_softc *, 394 struct uaudio_mixer_node *, uint8_t, int32_t val); 395 static usb_error_t uaudio_set_speed(struct usb_device *, uint8_t, uint32_t); 396 static int uaudio_mixer_signext(uint8_t, int); 397 static int uaudio_mixer_bsd2value(struct uaudio_mixer_node *, int32_t val); 398 static const void *uaudio_mixer_verify_desc(const void *, uint32_t); 399 static void uaudio_mixer_init(struct uaudio_softc *); 400 static uint8_t umidi_convert_to_usb(struct umidi_sub_chan *, uint8_t, uint8_t); 401 static struct umidi_sub_chan *umidi_sub_by_fifo(struct usb_fifo *); 402 static void umidi_start_read(struct usb_fifo *); 403 static void umidi_stop_read(struct usb_fifo *); 404 static void umidi_start_write(struct usb_fifo *); 405 static void umidi_stop_write(struct usb_fifo *); 406 static int umidi_open(struct usb_fifo *, int); 407 static int umidi_ioctl(struct usb_fifo *, u_long cmd, void *, int); 408 static void umidi_close(struct usb_fifo *, int); 409 static void umidi_init(device_t dev); 410 static int umidi_probe(device_t dev); 411 static int umidi_detach(device_t dev); 412 413 #ifdef USB_DEBUG 414 static void uaudio_chan_dump_ep_desc( 415 const usb_endpoint_descriptor_audio_t *); 416 static void uaudio_mixer_dump_cluster(uint8_t, 417 const struct uaudio_terminal_node *); 418 static const char *uaudio_mixer_get_terminal_name(uint16_t); 419 #endif 420 421 static const struct usb_config 422 uaudio_cfg_record[UAUDIO_NCHANBUFS] = { 423 [0] = { 424 .type = UE_ISOCHRONOUS, 425 .endpoint = UE_ADDR_ANY, 426 .direction = UE_DIR_IN, 427 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 428 .frames = UAUDIO_NFRAMES, 429 .flags = {.short_xfer_ok = 1,}, 430 .callback = &uaudio_chan_record_callback, 431 }, 432 433 [1] = { 434 .type = UE_ISOCHRONOUS, 435 .endpoint = UE_ADDR_ANY, 436 .direction = UE_DIR_IN, 437 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 438 .frames = UAUDIO_NFRAMES, 439 .flags = {.short_xfer_ok = 1,}, 440 .callback = &uaudio_chan_record_callback, 441 }, 442 }; 443 444 static const struct usb_config 445 uaudio_cfg_play[UAUDIO_NCHANBUFS] = { 446 [0] = { 447 .type = UE_ISOCHRONOUS, 448 .endpoint = UE_ADDR_ANY, 449 .direction = UE_DIR_OUT, 450 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 451 .frames = UAUDIO_NFRAMES, 452 .flags = {.short_xfer_ok = 1,}, 453 .callback = &uaudio_chan_play_callback, 454 }, 455 456 [1] = { 457 .type = UE_ISOCHRONOUS, 458 .endpoint = UE_ADDR_ANY, 459 .direction = UE_DIR_OUT, 460 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 461 .frames = UAUDIO_NFRAMES, 462 .flags = {.short_xfer_ok = 1,}, 463 .callback = &uaudio_chan_play_callback, 464 }, 465 }; 466 467 static const struct usb_config 468 uaudio_mixer_config[1] = { 469 [0] = { 470 .type = UE_CONTROL, 471 .endpoint = 0x00, /* Control pipe */ 472 .direction = UE_DIR_ANY, 473 .bufsize = (sizeof(struct usb_device_request) + 4), 474 .callback = &uaudio_mixer_write_cfg_callback, 475 .timeout = 1000, /* 1 second */ 476 }, 477 }; 478 479 static const 480 uint8_t umidi_cmd_to_len[16] = { 481 [0x0] = 0, /* reserved */ 482 [0x1] = 0, /* reserved */ 483 [0x2] = 2, /* bytes */ 484 [0x3] = 3, /* bytes */ 485 [0x4] = 3, /* bytes */ 486 [0x5] = 1, /* bytes */ 487 [0x6] = 2, /* bytes */ 488 [0x7] = 3, /* bytes */ 489 [0x8] = 3, /* bytes */ 490 [0x9] = 3, /* bytes */ 491 [0xA] = 3, /* bytes */ 492 [0xB] = 3, /* bytes */ 493 [0xC] = 2, /* bytes */ 494 [0xD] = 2, /* bytes */ 495 [0xE] = 3, /* bytes */ 496 [0xF] = 1, /* bytes */ 497 }; 498 499 static const struct usb_config 500 umidi_config[UMIDI_N_TRANSFER] = { 501 [UMIDI_TX_TRANSFER] = { 502 .type = UE_BULK, 503 .endpoint = UE_ADDR_ANY, 504 .direction = UE_DIR_OUT, 505 .bufsize = UMIDI_TX_BUFFER, 506 .callback = &umidi_bulk_write_callback, 507 }, 508 509 [UMIDI_RX_TRANSFER] = { 510 .type = UE_BULK, 511 .endpoint = UE_ADDR_ANY, 512 .direction = UE_DIR_IN, 513 .bufsize = 4, /* bytes */ 514 .flags = {.short_xfer_ok = 1,.proxy_buffer = 1,}, 515 .callback = &umidi_bulk_read_callback, 516 }, 517 }; 518 519 static devclass_t uaudio_devclass; 520 521 static device_method_t uaudio_methods[] = { 522 DEVMETHOD(device_probe, uaudio_probe), 523 DEVMETHOD(device_attach, uaudio_attach), 524 DEVMETHOD(device_detach, uaudio_detach), 525 DEVMETHOD(device_suspend, bus_generic_suspend), 526 DEVMETHOD(device_resume, bus_generic_resume), 527 DEVMETHOD(device_shutdown, bus_generic_shutdown), 528 529 DEVMETHOD_END 530 }; 531 532 static driver_t uaudio_driver = { 533 .name = "uaudio", 534 .methods = uaudio_methods, 535 .size = sizeof(struct uaudio_softc), 536 }; 537 538 static const STRUCT_USB_HOST_ID __used uaudio_devs[] = { 539 /* Generic USB audio class match */ 540 {USB_IFACE_CLASS(UICLASS_AUDIO), 541 USB_IFACE_SUBCLASS(UISUBCLASS_AUDIOCONTROL),}, 542 /* Generic USB MIDI class match */ 543 {USB_IFACE_CLASS(UICLASS_AUDIO), 544 USB_IFACE_SUBCLASS(UISUBCLASS_MIDISTREAM),}, 545 }; 546 547 static int 548 uaudio_probe(device_t dev) 549 { 550 struct usb_attach_arg *uaa = device_get_ivars(dev); 551 552 if (uaa->usb_mode != USB_MODE_HOST) 553 return (ENXIO); 554 555 /* lookup non-standard device */ 556 557 if (uaa->info.bInterfaceClass != UICLASS_AUDIO) { 558 if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS) == 0) 559 return (ENXIO); 560 } 561 562 /* check for AUDIO control interface */ 563 564 if (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL) { 565 if (usb_test_quirk(uaa, UQ_BAD_AUDIO)) 566 return (ENXIO); 567 else 568 return (BUS_PROBE_GENERIC); 569 } 570 571 /* check for MIDI stream */ 572 573 if (uaa->info.bInterfaceSubClass == UISUBCLASS_MIDISTREAM) { 574 if (usb_test_quirk(uaa, UQ_BAD_MIDI)) 575 return (ENXIO); 576 else 577 return (BUS_PROBE_GENERIC); 578 } 579 return (ENXIO); 580 } 581 582 static int 583 uaudio_attach(device_t dev) 584 { 585 struct usb_attach_arg *uaa = device_get_ivars(dev); 586 struct uaudio_softc *sc = device_get_softc(dev); 587 struct usb_interface_descriptor *id; 588 device_t child; 589 590 sc->sc_play_chan.priv_sc = sc; 591 sc->sc_rec_chan.priv_sc = sc; 592 sc->sc_udev = uaa->device; 593 sc->sc_mixer_iface_index = uaa->info.bIfaceIndex; 594 sc->sc_mixer_iface_no = uaa->info.bIfaceNum; 595 596 if (usb_test_quirk(uaa, UQ_AUDIO_SWAP_LR)) 597 sc->sc_uq_audio_swap_lr = 1; 598 599 if (usb_test_quirk(uaa, UQ_AU_INP_ASYNC)) 600 sc->sc_uq_au_inp_async = 1; 601 602 if (usb_test_quirk(uaa, UQ_AU_NO_XU)) 603 sc->sc_uq_au_no_xu = 1; 604 605 if (usb_test_quirk(uaa, UQ_BAD_ADC)) 606 sc->sc_uq_bad_adc = 1; 607 608 if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS)) 609 sc->sc_uq_au_vendor_class = 1; 610 611 umidi_init(dev); 612 613 device_set_usb_desc(dev); 614 615 id = usbd_get_interface_descriptor(uaa->iface); 616 617 uaudio_chan_fill_info(sc, uaa->device); 618 619 uaudio_mixer_fill_info(sc, uaa->device, id); 620 621 DPRINTF("audio rev %d.%02x\n", 622 sc->sc_audio_rev >> 8, 623 sc->sc_audio_rev & 0xff); 624 625 DPRINTF("%d mixer controls\n", 626 sc->sc_mixer_count); 627 628 if (sc->sc_play_chan.valid) { 629 device_printf(dev, "Play: %d Hz, %d ch, %s format.\n", 630 sc->sc_play_chan.sample_rate, 631 sc->sc_play_chan.p_asf1d->bNrChannels, 632 sc->sc_play_chan.p_fmt->description); 633 } else { 634 device_printf(dev, "No playback.\n"); 635 } 636 637 if (sc->sc_rec_chan.valid) { 638 device_printf(dev, "Record: %d Hz, %d ch, %s format.\n", 639 sc->sc_rec_chan.sample_rate, 640 sc->sc_rec_chan.p_asf1d->bNrChannels, 641 sc->sc_rec_chan.p_fmt->description); 642 } else { 643 device_printf(dev, "No recording.\n"); 644 } 645 646 if (sc->sc_midi_chan.valid) { 647 648 if (umidi_probe(dev)) { 649 goto detach; 650 } 651 device_printf(dev, "MIDI sequencer.\n"); 652 } else { 653 device_printf(dev, "No midi sequencer.\n"); 654 } 655 656 DPRINTF("doing child attach\n"); 657 658 /* attach the children */ 659 660 sc->sc_sndcard_func.func = SCF_PCM; 661 662 /* 663 * Only attach a PCM device if we have a playback, recording 664 * or mixer device present: 665 */ 666 if (sc->sc_play_chan.valid || 667 sc->sc_rec_chan.valid || 668 sc->sc_mix_info) { 669 child = device_add_child(dev, "pcm", -1); 670 671 if (child == NULL) { 672 DPRINTF("out of memory\n"); 673 goto detach; 674 } 675 device_set_ivars(child, &sc->sc_sndcard_func); 676 } 677 678 if (bus_generic_attach(dev)) { 679 DPRINTF("child attach failed\n"); 680 goto detach; 681 } 682 return (0); /* success */ 683 684 detach: 685 uaudio_detach(dev); 686 return (ENXIO); 687 } 688 689 static void 690 uaudio_pcm_setflags(device_t dev, uint32_t flags) 691 { 692 pcm_setflags(dev, pcm_getflags(dev) | flags); 693 } 694 695 int 696 uaudio_attach_sub(device_t dev, kobj_class_t mixer_class, kobj_class_t chan_class) 697 { 698 struct uaudio_softc *sc = device_get_softc(device_get_parent(dev)); 699 char status[SND_STATUSLEN]; 700 701 uaudio_mixer_init(sc); 702 703 if (sc->sc_uq_audio_swap_lr) { 704 DPRINTF("hardware has swapped left and right\n"); 705 /* uaudio_pcm_setflags(dev, SD_F_PSWAPLR); */ 706 } 707 if (!(sc->sc_mix_info & SOUND_MASK_PCM)) { 708 709 DPRINTF("emulating master volume\n"); 710 711 /* 712 * Emulate missing pcm mixer controller 713 * through FEEDER_VOLUME 714 */ 715 uaudio_pcm_setflags(dev, SD_F_SOFTPCMVOL); 716 } 717 if (mixer_init(dev, mixer_class, sc)) { 718 goto detach; 719 } 720 sc->sc_mixer_init = 1; 721 722 snprintf(status, sizeof(status), "at ? %s", PCM_KLDSTRING(snd_uaudio)); 723 724 if (pcm_register(dev, sc, 725 sc->sc_play_chan.valid ? 1 : 0, 726 sc->sc_rec_chan.valid ? 1 : 0)) { 727 goto detach; 728 } 729 730 uaudio_pcm_setflags(dev, SD_F_MPSAFE); 731 sc->sc_pcm_registered = 1; 732 733 if (sc->sc_play_chan.valid) { 734 pcm_addchan(dev, PCMDIR_PLAY, chan_class, sc); 735 } 736 if (sc->sc_rec_chan.valid) { 737 pcm_addchan(dev, PCMDIR_REC, chan_class, sc); 738 } 739 pcm_setstatus(dev, status); 740 741 return (0); /* success */ 742 743 detach: 744 uaudio_detach_sub(dev); 745 return (ENXIO); 746 } 747 748 int 749 uaudio_detach_sub(device_t dev) 750 { 751 struct uaudio_softc *sc = device_get_softc(device_get_parent(dev)); 752 int error = 0; 753 754 repeat: 755 if (sc->sc_pcm_registered) { 756 error = pcm_unregister(dev); 757 } else { 758 if (sc->sc_mixer_init) { 759 error = mixer_uninit(dev); 760 } 761 } 762 763 if (error) { 764 device_printf(dev, "Waiting for sound application to exit!\n"); 765 usb_pause_mtx(NULL, 2 * hz); 766 goto repeat; /* try again */ 767 } 768 return (0); /* success */ 769 } 770 771 static int 772 uaudio_detach(device_t dev) 773 { 774 struct uaudio_softc *sc = device_get_softc(dev); 775 776 /* 777 * Stop USB transfers early so that any audio applications 778 * will time out and close opened /dev/dspX.Y device(s), if 779 * any. 780 */ 781 if (sc->sc_play_chan.valid) 782 usbd_transfer_unsetup(sc->sc_play_chan.xfer, UAUDIO_NCHANBUFS); 783 if (sc->sc_rec_chan.valid) 784 usbd_transfer_unsetup(sc->sc_rec_chan.xfer, UAUDIO_NCHANBUFS); 785 786 if (bus_generic_detach(dev) != 0) { 787 DPRINTF("detach failed!\n"); 788 } 789 sbuf_delete(&sc->sc_sndstat); 790 sc->sc_sndstat_valid = 0; 791 792 umidi_detach(dev); 793 794 return (0); 795 } 796 797 /*========================================================================* 798 * AS - Audio Stream - routines 799 *========================================================================*/ 800 801 #ifdef USB_DEBUG 802 static void 803 uaudio_chan_dump_ep_desc(const usb_endpoint_descriptor_audio_t *ed) 804 { 805 if (ed) { 806 DPRINTF("endpoint=%p bLength=%d bDescriptorType=%d \n" 807 "bEndpointAddress=%d bmAttributes=0x%x \n" 808 "wMaxPacketSize=%d bInterval=%d \n" 809 "bRefresh=%d bSynchAddress=%d\n", 810 ed, ed->bLength, ed->bDescriptorType, 811 ed->bEndpointAddress, ed->bmAttributes, 812 UGETW(ed->wMaxPacketSize), ed->bInterval, 813 UEP_HAS_REFRESH(ed) ? ed->bRefresh : 0, 814 UEP_HAS_SYNCADDR(ed) ? ed->bSynchAddress : 0); 815 } 816 } 817 818 #endif 819 820 /* 821 * The following is a workaround for broken no-name USB audio devices 822 * sold by dealextreme called "3D sound". The problem is that the 823 * manufacturer computed wMaxPacketSize is too small to hold the 824 * actual data sent. In other words the device sometimes sends more 825 * data than it actually reports it can send in a single isochronous 826 * packet. 827 */ 828 static void 829 uaudio_record_fix_fs(usb_endpoint_descriptor_audio_t *ep, 830 uint32_t xps, uint32_t add) 831 { 832 uint32_t mps; 833 834 mps = UGETW(ep->wMaxPacketSize); 835 836 /* 837 * If the device indicates it can send more data than what the 838 * sample rate indicates, we apply the workaround. 839 */ 840 if (mps > xps) { 841 842 /* allow additional data */ 843 xps += add; 844 845 /* check against the maximum USB 1.x length */ 846 if (xps > 1023) 847 xps = 1023; 848 849 /* check if we should do an update */ 850 if (mps < xps) { 851 /* simply update the wMaxPacketSize field */ 852 USETW(ep->wMaxPacketSize, xps); 853 DPRINTF("Workaround: Updated wMaxPacketSize " 854 "from %d to %d bytes.\n", 855 (int)mps, (int)xps); 856 } 857 } 858 } 859 860 static void 861 uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev, 862 uint32_t rate, uint8_t channels, uint8_t bit_resolution) 863 { 864 struct usb_descriptor *desc = NULL; 865 const struct usb_audio_streaming_interface_descriptor *asid = NULL; 866 const struct usb_audio_streaming_type1_descriptor *asf1d = NULL; 867 const struct usb_audio_streaming_endpoint_descriptor *sed = NULL; 868 usb_endpoint_descriptor_audio_t *ed1 = NULL; 869 const usb_endpoint_descriptor_audio_t *ed2 = NULL; 870 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); 871 struct usb_interface_descriptor *id; 872 const struct uaudio_format *p_fmt; 873 struct uaudio_chan *chan; 874 uint16_t curidx = 0xFFFF; 875 uint16_t lastidx = 0xFFFF; 876 uint16_t alt_index = 0; 877 uint16_t wFormat; 878 uint8_t ep_dir; 879 uint8_t bChannels; 880 uint8_t bBitResolution; 881 uint8_t x; 882 uint8_t audio_if = 0; 883 uint8_t uma_if_class; 884 885 while ((desc = usb_desc_foreach(cd, desc))) { 886 887 if ((desc->bDescriptorType == UDESC_INTERFACE) && 888 (desc->bLength >= sizeof(*id))) { 889 890 id = (void *)desc; 891 892 if (id->bInterfaceNumber != lastidx) { 893 lastidx = id->bInterfaceNumber; 894 curidx++; 895 alt_index = 0; 896 897 } else { 898 alt_index++; 899 } 900 901 uma_if_class = 902 ((id->bInterfaceClass == UICLASS_AUDIO) || 903 ((id->bInterfaceClass == UICLASS_VENDOR) && 904 (sc->sc_uq_au_vendor_class != 0))); 905 906 if ((uma_if_class != 0) && (id->bInterfaceSubClass == UISUBCLASS_AUDIOSTREAM)) { 907 audio_if = 1; 908 } else { 909 audio_if = 0; 910 } 911 912 if ((uma_if_class != 0) && 913 (id->bInterfaceSubClass == UISUBCLASS_MIDISTREAM)) { 914 915 /* 916 * XXX could allow multiple MIDI interfaces 917 */ 918 919 if ((sc->sc_midi_chan.valid == 0) && 920 usbd_get_iface(udev, curidx)) { 921 sc->sc_midi_chan.iface_index = curidx; 922 sc->sc_midi_chan.iface_alt_index = alt_index; 923 sc->sc_midi_chan.valid = 1; 924 } 925 } 926 asid = NULL; 927 asf1d = NULL; 928 ed1 = NULL; 929 ed2 = NULL; 930 sed = NULL; 931 } 932 if ((desc->bDescriptorType == UDESC_CS_INTERFACE) && 933 (desc->bDescriptorSubtype == AS_GENERAL) && 934 (desc->bLength >= sizeof(*asid))) { 935 if (asid == NULL) { 936 asid = (void *)desc; 937 } 938 } 939 if ((desc->bDescriptorType == UDESC_CS_INTERFACE) && 940 (desc->bDescriptorSubtype == FORMAT_TYPE) && 941 (desc->bLength >= sizeof(*asf1d))) { 942 if (asf1d == NULL) { 943 asf1d = (void *)desc; 944 if (asf1d->bFormatType != FORMAT_TYPE_I) { 945 DPRINTFN(11, "ignored bFormatType = %d\n", 946 asf1d->bFormatType); 947 asf1d = NULL; 948 continue; 949 } 950 if (asf1d->bLength < (sizeof(*asf1d) + 951 ((asf1d->bSamFreqType == 0) ? 6 : 952 (asf1d->bSamFreqType * 3)))) { 953 DPRINTFN(11, "'asf1d' descriptor is too short\n"); 954 asf1d = NULL; 955 continue; 956 } 957 } 958 } 959 if ((desc->bDescriptorType == UDESC_ENDPOINT) && 960 (desc->bLength >= UEP_MINSIZE)) { 961 if (ed1 == NULL) { 962 ed1 = (void *)desc; 963 if (UE_GET_XFERTYPE(ed1->bmAttributes) != UE_ISOCHRONOUS) { 964 ed1 = NULL; 965 } 966 } 967 } 968 if ((desc->bDescriptorType == UDESC_CS_ENDPOINT) && 969 (desc->bDescriptorSubtype == AS_GENERAL) && 970 (desc->bLength >= sizeof(*sed))) { 971 if (sed == NULL) { 972 sed = (void *)desc; 973 } 974 } 975 if (audio_if && asid && asf1d && ed1 && sed) { 976 977 ep_dir = UE_GET_DIR(ed1->bEndpointAddress); 978 979 /* We ignore sync endpoint information until further. */ 980 981 wFormat = UGETW(asid->wFormatTag); 982 bChannels = UAUDIO_MAX_CHAN(asf1d->bNrChannels); 983 bBitResolution = asf1d->bBitResolution; 984 985 if (asf1d->bSamFreqType == 0) { 986 DPRINTFN(16, "Sample rate: %d-%dHz\n", 987 UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d)); 988 989 if ((rate >= UA_SAMP_LO(asf1d)) && 990 (rate <= UA_SAMP_HI(asf1d))) { 991 goto found_rate; 992 } 993 } else { 994 995 for (x = 0; x < asf1d->bSamFreqType; x++) { 996 DPRINTFN(16, "Sample rate = %dHz\n", 997 UA_GETSAMP(asf1d, x)); 998 999 if (rate == UA_GETSAMP(asf1d, x)) { 1000 goto found_rate; 1001 } 1002 } 1003 } 1004 1005 audio_if = 0; 1006 continue; 1007 1008 found_rate: 1009 1010 for (p_fmt = uaudio_formats; 1011 p_fmt->wFormat; 1012 p_fmt++) { 1013 if ((p_fmt->wFormat == wFormat) && 1014 (p_fmt->bPrecision == bBitResolution)) { 1015 goto found_format; 1016 } 1017 } 1018 1019 audio_if = 0; 1020 continue; 1021 1022 found_format: 1023 1024 if ((bChannels == channels) && 1025 (bBitResolution == bit_resolution)) { 1026 1027 chan = (ep_dir == UE_DIR_IN) ? 1028 &sc->sc_rec_chan : 1029 &sc->sc_play_chan; 1030 1031 if ((chan->valid == 0) && usbd_get_iface(udev, curidx)) { 1032 1033 chan->valid = 1; 1034 #ifdef USB_DEBUG 1035 uaudio_chan_dump_ep_desc(ed1); 1036 uaudio_chan_dump_ep_desc(ed2); 1037 1038 if (sed->bmAttributes & UA_SED_FREQ_CONTROL) { 1039 DPRINTFN(2, "FREQ_CONTROL\n"); 1040 } 1041 if (sed->bmAttributes & UA_SED_PITCH_CONTROL) { 1042 DPRINTFN(2, "PITCH_CONTROL\n"); 1043 } 1044 #endif 1045 DPRINTF("Sample rate = %dHz, channels = %d, " 1046 "bits = %d, format = %s\n", rate, channels, 1047 bit_resolution, p_fmt->description); 1048 1049 chan->sample_rate = rate; 1050 chan->p_asid = asid; 1051 chan->p_asf1d = asf1d; 1052 chan->p_ed1 = ed1; 1053 chan->p_ed2 = ed2; 1054 chan->p_fmt = p_fmt; 1055 chan->p_sed = sed; 1056 chan->iface_index = curidx; 1057 chan->iface_alt_index = alt_index; 1058 1059 if (ep_dir == UE_DIR_IN) 1060 chan->usb_cfg = 1061 uaudio_cfg_record; 1062 else 1063 chan->usb_cfg = 1064 uaudio_cfg_play; 1065 1066 chan->sample_size = (( 1067 UAUDIO_MAX_CHAN(chan->p_asf1d->bNrChannels) * 1068 chan->p_asf1d->bBitResolution) / 8); 1069 1070 if (ep_dir == UE_DIR_IN && 1071 usbd_get_speed(udev) == USB_SPEED_FULL) { 1072 uaudio_record_fix_fs(ed1, 1073 chan->sample_size * (rate / 1000), 1074 chan->sample_size * (rate / 4000)); 1075 } 1076 1077 if (sc->sc_sndstat_valid) { 1078 sbuf_printf(&sc->sc_sndstat, "\n\t" 1079 "mode %d.%d:(%s) %dch, %d/%dbit, %s, %dHz", 1080 curidx, alt_index, 1081 (ep_dir == UE_DIR_IN) ? "input" : "output", 1082 asf1d->bNrChannels, asf1d->bBitResolution, 1083 asf1d->bSubFrameSize * 8, 1084 p_fmt->description, rate); 1085 } 1086 } 1087 } 1088 audio_if = 0; 1089 continue; 1090 } 1091 } 1092 } 1093 1094 /* This structure defines all the supported rates. */ 1095 1096 static const uint32_t uaudio_rate_list[] = { 1097 96000, 1098 88000, 1099 80000, 1100 72000, 1101 64000, 1102 56000, 1103 48000, 1104 44100, 1105 40000, 1106 32000, 1107 24000, 1108 22050, 1109 16000, 1110 11025, 1111 8000, 1112 0 1113 }; 1114 1115 static void 1116 uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev) 1117 { 1118 uint32_t rate = uaudio_default_rate; 1119 uint8_t z; 1120 uint8_t bits = uaudio_default_bits; 1121 uint8_t y; 1122 uint8_t channels = uaudio_default_channels; 1123 uint8_t x; 1124 1125 bits -= (bits % 8); 1126 if ((bits == 0) || (bits > 32)) { 1127 /* set a valid value */ 1128 bits = 32; 1129 } 1130 if (channels == 0) { 1131 switch (usbd_get_speed(udev)) { 1132 case USB_SPEED_LOW: 1133 case USB_SPEED_FULL: 1134 /* 1135 * Due to high bandwidth usage and problems 1136 * with HIGH-speed split transactions we 1137 * disable surround setups on FULL-speed USB 1138 * by default 1139 */ 1140 channels = 2; 1141 break; 1142 default: 1143 channels = 16; 1144 break; 1145 } 1146 } else if (channels > 16) { 1147 channels = 16; 1148 } 1149 if (sbuf_new(&sc->sc_sndstat, NULL, 4096, SBUF_AUTOEXTEND)) { 1150 sc->sc_sndstat_valid = 1; 1151 } 1152 /* try to search for a valid config */ 1153 1154 for (x = channels; x; x--) { 1155 for (y = bits; y; y -= 8) { 1156 1157 /* try user defined rate, if any */ 1158 if (rate != 0) 1159 uaudio_chan_fill_info_sub(sc, udev, rate, x, y); 1160 1161 /* try find a matching rate, if any */ 1162 for (z = 0; uaudio_rate_list[z]; z++) { 1163 uaudio_chan_fill_info_sub(sc, udev, uaudio_rate_list[z], x, y); 1164 1165 if (sc->sc_rec_chan.valid && 1166 sc->sc_play_chan.valid) { 1167 goto done; 1168 } 1169 } 1170 } 1171 } 1172 1173 done: 1174 if (sc->sc_sndstat_valid) { 1175 sbuf_finish(&sc->sc_sndstat); 1176 } 1177 } 1178 1179 static void 1180 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error) 1181 { 1182 struct uaudio_chan *ch = usbd_xfer_softc(xfer); 1183 struct usb_page_cache *pc; 1184 uint32_t total; 1185 uint32_t blockcount; 1186 uint32_t n; 1187 uint32_t offset; 1188 int actlen; 1189 int sumlen; 1190 1191 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 1192 1193 if (ch->end == ch->start) { 1194 DPRINTF("no buffer!\n"); 1195 return; 1196 } 1197 1198 switch (USB_GET_STATE(xfer)) { 1199 case USB_ST_TRANSFERRED: 1200 tr_transferred: 1201 if (actlen < sumlen) { 1202 DPRINTF("short transfer, " 1203 "%d of %d bytes\n", actlen, sumlen); 1204 } 1205 chn_intr(ch->pcm_ch); 1206 1207 case USB_ST_SETUP: 1208 if (ch->bytes_per_frame[1] > usbd_xfer_max_framelen(xfer)) { 1209 DPRINTF("bytes per transfer, %d, " 1210 "exceeds maximum, %d!\n", 1211 ch->bytes_per_frame[1], 1212 usbd_xfer_max_framelen(xfer)); 1213 break; 1214 } 1215 1216 blockcount = ch->intr_frames; 1217 1218 /* setup number of frames */ 1219 usbd_xfer_set_frames(xfer, blockcount); 1220 1221 /* reset total length */ 1222 total = 0; 1223 1224 /* setup frame lengths */ 1225 for (n = 0; n != blockcount; n++) { 1226 ch->sample_curr += ch->sample_rem; 1227 if (ch->sample_curr >= ch->frames_per_second) { 1228 ch->sample_curr -= ch->frames_per_second; 1229 usbd_xfer_set_frame_len(xfer, n, ch->bytes_per_frame[1]); 1230 total += ch->bytes_per_frame[1]; 1231 } else { 1232 usbd_xfer_set_frame_len(xfer, n, ch->bytes_per_frame[0]); 1233 total += ch->bytes_per_frame[0]; 1234 } 1235 } 1236 1237 DPRINTFN(6, "transfer %d bytes\n", total); 1238 1239 offset = 0; 1240 1241 pc = usbd_xfer_get_frame(xfer, 0); 1242 while (total > 0) { 1243 1244 n = (ch->end - ch->cur); 1245 if (n > total) { 1246 n = total; 1247 } 1248 usbd_copy_in(pc, offset, ch->cur, n); 1249 1250 total -= n; 1251 ch->cur += n; 1252 offset += n; 1253 1254 if (ch->cur >= ch->end) { 1255 ch->cur = ch->start; 1256 } 1257 } 1258 1259 usbd_transfer_submit(xfer); 1260 break; 1261 1262 default: /* Error */ 1263 if (error == USB_ERR_CANCELLED) { 1264 break; 1265 } 1266 goto tr_transferred; 1267 } 1268 } 1269 1270 static void 1271 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error) 1272 { 1273 struct uaudio_chan *ch = usbd_xfer_softc(xfer); 1274 struct usb_page_cache *pc; 1275 uint32_t n; 1276 uint32_t m; 1277 uint32_t blockcount; 1278 uint32_t offset0; 1279 uint32_t offset1; 1280 uint32_t mfl; 1281 int len; 1282 int actlen; 1283 int nframes; 1284 1285 usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes); 1286 mfl = usbd_xfer_max_framelen(xfer); 1287 1288 if (ch->end == ch->start) { 1289 DPRINTF("no buffer!\n"); 1290 return; 1291 } 1292 1293 switch (USB_GET_STATE(xfer)) { 1294 case USB_ST_TRANSFERRED: 1295 1296 DPRINTFN(6, "transferred %d bytes\n", actlen); 1297 1298 offset0 = 0; 1299 pc = usbd_xfer_get_frame(xfer, 0); 1300 1301 for (n = 0; n != nframes; n++) { 1302 1303 offset1 = offset0; 1304 len = usbd_xfer_frame_len(xfer, n); 1305 1306 while (len > 0) { 1307 1308 m = (ch->end - ch->cur); 1309 1310 if (m > len) { 1311 m = len; 1312 } 1313 usbd_copy_out(pc, offset1, ch->cur, m); 1314 1315 len -= m; 1316 offset1 += m; 1317 ch->cur += m; 1318 1319 if (ch->cur >= ch->end) { 1320 ch->cur = ch->start; 1321 } 1322 } 1323 1324 offset0 += mfl; 1325 } 1326 1327 chn_intr(ch->pcm_ch); 1328 1329 case USB_ST_SETUP: 1330 tr_setup: 1331 blockcount = ch->intr_frames; 1332 1333 usbd_xfer_set_frames(xfer, blockcount); 1334 for (n = 0; n < blockcount; n++) { 1335 usbd_xfer_set_frame_len(xfer, n, mfl); 1336 } 1337 1338 usbd_transfer_submit(xfer); 1339 break; 1340 1341 default: /* Error */ 1342 if (error == USB_ERR_CANCELLED) { 1343 break; 1344 } 1345 goto tr_setup; 1346 } 1347 } 1348 1349 void * 1350 uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b, 1351 struct pcm_channel *c, int dir) 1352 { 1353 struct uaudio_chan *ch = ((dir == PCMDIR_PLAY) ? 1354 &sc->sc_play_chan : &sc->sc_rec_chan); 1355 uint32_t buf_size; 1356 uint32_t frames; 1357 uint32_t format; 1358 uint16_t fps; 1359 uint8_t endpoint; 1360 uint8_t blocks; 1361 uint8_t iface_index; 1362 uint8_t alt_index; 1363 uint8_t fps_shift; 1364 usb_error_t err; 1365 1366 fps = usbd_get_isoc_fps(sc->sc_udev); 1367 1368 if (fps < 8000) { 1369 /* FULL speed USB */ 1370 frames = 8; 1371 } else { 1372 /* HIGH speed USB */ 1373 frames = UAUDIO_NFRAMES; 1374 } 1375 1376 /* setup play/record format */ 1377 1378 ch->pcm_cap.fmtlist = ch->pcm_format; 1379 1380 ch->pcm_format[0] = 0; 1381 ch->pcm_format[1] = 0; 1382 1383 ch->pcm_cap.minspeed = ch->sample_rate; 1384 ch->pcm_cap.maxspeed = ch->sample_rate; 1385 1386 /* setup mutex and PCM channel */ 1387 1388 ch->pcm_ch = c; 1389 ch->pcm_mtx = c->lock; 1390 1391 format = ch->p_fmt->freebsd_fmt; 1392 1393 switch (ch->p_asf1d->bNrChannels) { 1394 case 2: 1395 /* stereo */ 1396 format = SND_FORMAT(format, 2, 0); 1397 break; 1398 case 1: 1399 /* mono */ 1400 format = SND_FORMAT(format, 1, 0); 1401 break; 1402 default: 1403 /* surround and more */ 1404 format = feeder_matrix_default_format( 1405 SND_FORMAT(format, ch->p_asf1d->bNrChannels, 0)); 1406 break; 1407 } 1408 1409 ch->pcm_cap.fmtlist[0] = format; 1410 ch->pcm_cap.fmtlist[1] = 0; 1411 1412 /* check if format is not supported */ 1413 1414 if (format == 0) { 1415 DPRINTF("The selected audio format is not supported\n"); 1416 goto error; 1417 } 1418 1419 /* set alternate interface corresponding to the mode */ 1420 1421 endpoint = ch->p_ed1->bEndpointAddress; 1422 iface_index = ch->iface_index; 1423 alt_index = ch->iface_alt_index; 1424 1425 DPRINTF("endpoint=0x%02x, speed=%d, iface=%d alt=%d\n", 1426 endpoint, ch->sample_rate, iface_index, alt_index); 1427 1428 err = usbd_set_alt_interface_index(sc->sc_udev, iface_index, alt_index); 1429 if (err) { 1430 DPRINTF("setting of alternate index failed: %s!\n", 1431 usbd_errstr(err)); 1432 goto error; 1433 } 1434 usbd_set_parent_iface(sc->sc_udev, iface_index, 1435 sc->sc_mixer_iface_index); 1436 1437 /* 1438 * Only set the sample rate if the channel reports that it 1439 * supports the frequency control. 1440 */ 1441 if (ch->p_sed->bmAttributes & UA_SED_FREQ_CONTROL) { 1442 if (uaudio_set_speed(sc->sc_udev, endpoint, ch->sample_rate)) { 1443 /* 1444 * If the endpoint is adaptive setting the speed may 1445 * fail. 1446 */ 1447 DPRINTF("setting of sample rate failed! (continuing anyway)\n"); 1448 } 1449 } 1450 if (usbd_transfer_setup(sc->sc_udev, &iface_index, ch->xfer, 1451 ch->usb_cfg, UAUDIO_NCHANBUFS, ch, ch->pcm_mtx)) { 1452 DPRINTF("could not allocate USB transfers!\n"); 1453 goto error; 1454 } 1455 1456 fps_shift = usbd_xfer_get_fps_shift(ch->xfer[0]); 1457 1458 /* down shift number of frames per second, if any */ 1459 fps >>= fps_shift; 1460 frames >>= fps_shift; 1461 1462 /* bytes per frame should not be zero */ 1463 ch->bytes_per_frame[0] = ((ch->sample_rate / fps) * ch->sample_size); 1464 ch->bytes_per_frame[1] = (((ch->sample_rate + fps - 1) / fps) * ch->sample_size); 1465 1466 /* setup data rate dithering, if any */ 1467 ch->frames_per_second = fps; 1468 ch->sample_rem = ch->sample_rate % fps; 1469 ch->sample_curr = 0; 1470 ch->frames_per_second = fps; 1471 1472 /* compute required buffer size */ 1473 buf_size = (ch->bytes_per_frame[1] * frames); 1474 1475 ch->intr_size = buf_size; 1476 ch->intr_frames = frames; 1477 1478 DPRINTF("fps=%d sample_rem=%d\n", fps, ch->sample_rem); 1479 1480 if (ch->intr_frames == 0) { 1481 DPRINTF("frame shift is too high!\n"); 1482 goto error; 1483 } 1484 1485 /* setup double buffering */ 1486 buf_size *= 2; 1487 blocks = 2; 1488 1489 ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO); 1490 if (ch->buf == NULL) 1491 goto error; 1492 if (sndbuf_setup(b, ch->buf, buf_size) != 0) 1493 goto error; 1494 if (sndbuf_resize(b, blocks, ch->intr_size)) 1495 goto error; 1496 1497 ch->start = ch->buf; 1498 ch->end = ch->buf + buf_size; 1499 ch->cur = ch->buf; 1500 ch->pcm_buf = b; 1501 1502 if (ch->pcm_mtx == NULL) { 1503 DPRINTF("ERROR: PCM channels does not have a mutex!\n"); 1504 goto error; 1505 } 1506 1507 return (ch); 1508 1509 error: 1510 uaudio_chan_free(ch); 1511 return (NULL); 1512 } 1513 1514 int 1515 uaudio_chan_free(struct uaudio_chan *ch) 1516 { 1517 if (ch->buf != NULL) { 1518 free(ch->buf, M_DEVBUF); 1519 ch->buf = NULL; 1520 } 1521 usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS); 1522 1523 ch->valid = 0; 1524 1525 return (0); 1526 } 1527 1528 int 1529 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize) 1530 { 1531 return (ch->intr_size); 1532 } 1533 1534 int 1535 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize, 1536 uint32_t blockcount) 1537 { 1538 return (1); 1539 } 1540 1541 int 1542 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed) 1543 { 1544 if (speed != ch->sample_rate) { 1545 DPRINTF("rate conversion required\n"); 1546 } 1547 return (ch->sample_rate); 1548 } 1549 1550 int 1551 uaudio_chan_getptr(struct uaudio_chan *ch) 1552 { 1553 return (ch->cur - ch->start); 1554 } 1555 1556 struct pcmchan_caps * 1557 uaudio_chan_getcaps(struct uaudio_chan *ch) 1558 { 1559 return (&ch->pcm_cap); 1560 } 1561 1562 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = { 1563 .id = SND_CHN_MATRIX_DRV, 1564 .channels = 2, 1565 .ext = 0, 1566 .map = { 1567 /* Right */ 1568 [0] = { 1569 .type = SND_CHN_T_FR, 1570 .members = 1571 SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC | 1572 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR | 1573 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR 1574 }, 1575 /* Left */ 1576 [1] = { 1577 .type = SND_CHN_T_FL, 1578 .members = 1579 SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC | 1580 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL | 1581 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL 1582 }, 1583 [2] = { 1584 .type = SND_CHN_T_MAX, 1585 .members = 0 1586 } 1587 }, 1588 .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL, 1589 .offset = { 1, 0, -1, -1, -1, -1, -1, -1, -1, 1590 -1, -1, -1, -1, -1, -1, -1, -1, -1 } 1591 }; 1592 1593 struct pcmchan_matrix * 1594 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format) 1595 { 1596 struct uaudio_softc *sc; 1597 1598 sc = ch->priv_sc; 1599 1600 if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 && 1601 AFMT_CHANNEL(format) == 2) 1602 return (&uaudio_chan_matrix_swap_2_0); 1603 1604 return (feeder_matrix_format_map(format)); 1605 } 1606 1607 int 1608 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format) 1609 { 1610 ch->format = format; 1611 return (0); 1612 } 1613 1614 int 1615 uaudio_chan_start(struct uaudio_chan *ch) 1616 { 1617 ch->cur = ch->start; 1618 1619 #if (UAUDIO_NCHANBUFS != 2) 1620 #error "please update code" 1621 #endif 1622 if (ch->xfer[0]) { 1623 usbd_transfer_start(ch->xfer[0]); 1624 } 1625 if (ch->xfer[1]) { 1626 usbd_transfer_start(ch->xfer[1]); 1627 } 1628 return (0); 1629 } 1630 1631 int 1632 uaudio_chan_stop(struct uaudio_chan *ch) 1633 { 1634 #if (UAUDIO_NCHANBUFS != 2) 1635 #error "please update code" 1636 #endif 1637 usbd_transfer_stop(ch->xfer[0]); 1638 usbd_transfer_stop(ch->xfer[1]); 1639 return (0); 1640 } 1641 1642 /*========================================================================* 1643 * AC - Audio Controller - routines 1644 *========================================================================*/ 1645 1646 static void 1647 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc) 1648 { 1649 struct uaudio_mixer_node *p_mc_new = 1650 malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK); 1651 1652 if (p_mc_new != NULL) { 1653 memcpy(p_mc_new, mc, sizeof(*p_mc_new)); 1654 p_mc_new->next = sc->sc_mixer_root; 1655 sc->sc_mixer_root = p_mc_new; 1656 sc->sc_mixer_count++; 1657 } else { 1658 DPRINTF("out of memory\n"); 1659 } 1660 } 1661 1662 static void 1663 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc) 1664 { 1665 int32_t res; 1666 1667 if (mc->class < UAC_NCLASSES) { 1668 DPRINTF("adding %s.%d\n", 1669 uac_names[mc->class], mc->ctl); 1670 } else { 1671 DPRINTF("adding %d\n", mc->ctl); 1672 } 1673 1674 if (mc->type == MIX_ON_OFF) { 1675 mc->minval = 0; 1676 mc->maxval = 1; 1677 } else if (mc->type == MIX_SELECTOR) { 1678 } else { 1679 1680 /* determine min and max values */ 1681 1682 mc->minval = uaudio_mixer_get(sc->sc_udev, GET_MIN, mc); 1683 1684 mc->minval = uaudio_mixer_signext(mc->type, mc->minval); 1685 1686 mc->maxval = uaudio_mixer_get(sc->sc_udev, GET_MAX, mc); 1687 1688 mc->maxval = uaudio_mixer_signext(mc->type, mc->maxval); 1689 1690 /* check if max and min was swapped */ 1691 1692 if (mc->maxval < mc->minval) { 1693 res = mc->maxval; 1694 mc->maxval = mc->minval; 1695 mc->minval = res; 1696 } 1697 1698 /* compute value range */ 1699 mc->mul = mc->maxval - mc->minval; 1700 if (mc->mul == 0) 1701 mc->mul = 1; 1702 1703 /* compute value alignment */ 1704 res = uaudio_mixer_get(sc->sc_udev, GET_RES, mc); 1705 1706 DPRINTF("Resolution = %d\n", (int)res); 1707 } 1708 1709 uaudio_mixer_add_ctl_sub(sc, mc); 1710 1711 #ifdef USB_DEBUG 1712 if (uaudio_debug > 2) { 1713 uint8_t i; 1714 1715 for (i = 0; i < mc->nchan; i++) { 1716 DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]); 1717 } 1718 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' " 1719 "min=%d max=%d\n", 1720 mc->wIndex, mc->type, mc->ctl, 1721 mc->minval, mc->maxval); 1722 } 1723 #endif 1724 } 1725 1726 static void 1727 uaudio_mixer_add_input(struct uaudio_softc *sc, 1728 const struct uaudio_terminal_node *iot, int id) 1729 { 1730 #ifdef USB_DEBUG 1731 const struct usb_audio_input_terminal *d = iot[id].u.it; 1732 1733 DPRINTFN(3, "bTerminalId=%d wTerminalType=0x%04x " 1734 "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d " 1735 "iChannelNames=%d\n", 1736 d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal, 1737 d->bNrChannels, UGETW(d->wChannelConfig), 1738 d->iChannelNames); 1739 #endif 1740 } 1741 1742 static void 1743 uaudio_mixer_add_output(struct uaudio_softc *sc, 1744 const struct uaudio_terminal_node *iot, int id) 1745 { 1746 #ifdef USB_DEBUG 1747 const struct usb_audio_output_terminal *d = iot[id].u.ot; 1748 1749 DPRINTFN(3, "bTerminalId=%d wTerminalType=0x%04x " 1750 "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n", 1751 d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal, 1752 d->bSourceId, d->iTerminal); 1753 #endif 1754 } 1755 1756 static void 1757 uaudio_mixer_add_mixer(struct uaudio_softc *sc, 1758 const struct uaudio_terminal_node *iot, int id) 1759 { 1760 struct uaudio_mixer_node mix; 1761 1762 const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu; 1763 const struct usb_audio_mixer_unit_1 *d1; 1764 1765 uint32_t bno; /* bit number */ 1766 uint32_t p; /* bit number accumulator */ 1767 uint32_t mo; /* matching outputs */ 1768 uint32_t mc; /* matching channels */ 1769 uint32_t ichs; /* input channels */ 1770 uint32_t ochs; /* output channels */ 1771 uint32_t c; 1772 uint32_t chs; /* channels */ 1773 uint32_t i; 1774 uint32_t o; 1775 1776 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 1777 d0->bUnitId, d0->bNrInPins); 1778 1779 /* compute the number of input channels */ 1780 1781 ichs = 0; 1782 for (i = 0; i < d0->bNrInPins; i++) { 1783 ichs += (uaudio_mixer_get_cluster(d0->baSourceId[i], iot) 1784 .bNrChannels); 1785 } 1786 1787 d1 = (const void *)(d0->baSourceId + d0->bNrInPins); 1788 1789 /* and the number of output channels */ 1790 1791 ochs = d1->bNrChannels; 1792 1793 DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs); 1794 1795 memset(&mix, 0, sizeof(mix)); 1796 1797 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 1798 uaudio_mixer_determine_class(&iot[id], &mix); 1799 mix.type = MIX_SIGNED_16; 1800 1801 if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL) { 1802 return; 1803 } 1804 for (p = i = 0; i < d0->bNrInPins; i++) { 1805 chs = uaudio_mixer_get_cluster(d0->baSourceId[i], iot).bNrChannels; 1806 mc = 0; 1807 for (c = 0; c < chs; c++) { 1808 mo = 0; 1809 for (o = 0; o < ochs; o++) { 1810 bno = ((p + c) * ochs) + o; 1811 if (BIT_TEST(d1->bmControls, bno)) { 1812 mo++; 1813 } 1814 } 1815 if (mo == 1) { 1816 mc++; 1817 } 1818 } 1819 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) { 1820 1821 /* repeat bit-scan */ 1822 1823 mc = 0; 1824 for (c = 0; c < chs; c++) { 1825 for (o = 0; o < ochs; o++) { 1826 bno = ((p + c) * ochs) + o; 1827 if (BIT_TEST(d1->bmControls, bno)) { 1828 mix.wValue[mc++] = MAKE_WORD(p + c + 1, o + 1); 1829 } 1830 } 1831 } 1832 mix.nchan = chs; 1833 uaudio_mixer_add_ctl(sc, &mix); 1834 } else { 1835 /* XXX */ 1836 } 1837 p += chs; 1838 } 1839 } 1840 1841 static void 1842 uaudio_mixer_add_selector(struct uaudio_softc *sc, 1843 const struct uaudio_terminal_node *iot, int id) 1844 { 1845 const struct usb_audio_selector_unit *d = iot[id].u.su; 1846 struct uaudio_mixer_node mix; 1847 uint16_t i; 1848 1849 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 1850 d->bUnitId, d->bNrInPins); 1851 1852 if (d->bNrInPins == 0) { 1853 return; 1854 } 1855 memset(&mix, 0, sizeof(mix)); 1856 1857 mix.wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 1858 mix.wValue[0] = MAKE_WORD(0, 0); 1859 uaudio_mixer_determine_class(&iot[id], &mix); 1860 mix.nchan = 1; 1861 mix.type = MIX_SELECTOR; 1862 1863 mix.ctl = SOUND_MIXER_NRDEVICES; 1864 mix.minval = 1; 1865 mix.maxval = d->bNrInPins; 1866 1867 if (mix.maxval > MAX_SELECTOR_INPUT_PIN) { 1868 mix.maxval = MAX_SELECTOR_INPUT_PIN; 1869 } 1870 mix.mul = (mix.maxval - mix.minval); 1871 for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) { 1872 mix.slctrtype[i] = SOUND_MIXER_NRDEVICES; 1873 } 1874 1875 for (i = 0; i < mix.maxval; i++) { 1876 mix.slctrtype[i] = uaudio_mixer_feature_name 1877 (&iot[d->baSourceId[i]], &mix); 1878 } 1879 1880 mix.class = 0; /* not used */ 1881 1882 uaudio_mixer_add_ctl(sc, &mix); 1883 } 1884 1885 static uint32_t 1886 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d, 1887 uint8_t index) 1888 { 1889 uint32_t temp = 0; 1890 uint32_t offset = (index * d->bControlSize); 1891 1892 if (d->bControlSize > 0) { 1893 temp |= d->bmaControls[offset]; 1894 if (d->bControlSize > 1) { 1895 temp |= d->bmaControls[offset + 1] << 8; 1896 if (d->bControlSize > 2) { 1897 temp |= d->bmaControls[offset + 2] << 16; 1898 if (d->bControlSize > 3) { 1899 temp |= d->bmaControls[offset + 3] << 24; 1900 } 1901 } 1902 } 1903 } 1904 return (temp); 1905 } 1906 1907 static void 1908 uaudio_mixer_add_feature(struct uaudio_softc *sc, 1909 const struct uaudio_terminal_node *iot, int id) 1910 { 1911 const struct usb_audio_feature_unit *d = iot[id].u.fu; 1912 struct uaudio_mixer_node mix; 1913 uint32_t fumask; 1914 uint32_t mmask; 1915 uint32_t cmask; 1916 uint16_t mixernumber; 1917 uint8_t nchan; 1918 uint8_t chan; 1919 uint8_t ctl; 1920 uint8_t i; 1921 1922 if (d->bControlSize == 0) { 1923 return; 1924 } 1925 memset(&mix, 0, sizeof(mix)); 1926 1927 nchan = (d->bLength - 7) / d->bControlSize; 1928 mmask = uaudio_mixer_feature_get_bmaControls(d, 0); 1929 cmask = 0; 1930 1931 if (nchan == 0) { 1932 return; 1933 } 1934 /* figure out what we can control */ 1935 1936 for (chan = 1; chan < nchan; chan++) { 1937 DPRINTFN(10, "chan=%d mask=%x\n", 1938 chan, uaudio_mixer_feature_get_bmaControls(d, chan)); 1939 1940 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan); 1941 } 1942 1943 if (nchan > MIX_MAX_CHAN) { 1944 nchan = MIX_MAX_CHAN; 1945 } 1946 mix.wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 1947 1948 for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) { 1949 1950 fumask = FU_MASK(ctl); 1951 1952 DPRINTFN(5, "ctl=%d fumask=0x%04x\n", 1953 ctl, fumask); 1954 1955 if (mmask & fumask) { 1956 mix.nchan = 1; 1957 mix.wValue[0] = MAKE_WORD(ctl, 0); 1958 } else if (cmask & fumask) { 1959 mix.nchan = nchan - 1; 1960 for (i = 1; i < nchan; i++) { 1961 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask) 1962 mix.wValue[i - 1] = MAKE_WORD(ctl, i); 1963 else 1964 mix.wValue[i - 1] = -1; 1965 } 1966 } else { 1967 continue; 1968 } 1969 1970 mixernumber = uaudio_mixer_feature_name(&iot[id], &mix); 1971 1972 switch (ctl) { 1973 case MUTE_CONTROL: 1974 mix.type = MIX_ON_OFF; 1975 mix.ctl = SOUND_MIXER_NRDEVICES; 1976 break; 1977 1978 case VOLUME_CONTROL: 1979 mix.type = MIX_SIGNED_16; 1980 mix.ctl = mixernumber; 1981 break; 1982 1983 case BASS_CONTROL: 1984 mix.type = MIX_SIGNED_8; 1985 mix.ctl = SOUND_MIXER_BASS; 1986 break; 1987 1988 case MID_CONTROL: 1989 mix.type = MIX_SIGNED_8; 1990 mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 1991 break; 1992 1993 case TREBLE_CONTROL: 1994 mix.type = MIX_SIGNED_8; 1995 mix.ctl = SOUND_MIXER_TREBLE; 1996 break; 1997 1998 case GRAPHIC_EQUALIZER_CONTROL: 1999 continue; /* XXX don't add anything */ 2000 break; 2001 2002 case AGC_CONTROL: 2003 mix.type = MIX_ON_OFF; 2004 mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 2005 break; 2006 2007 case DELAY_CONTROL: 2008 mix.type = MIX_UNSIGNED_16; 2009 mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 2010 break; 2011 2012 case BASS_BOOST_CONTROL: 2013 mix.type = MIX_ON_OFF; 2014 mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 2015 break; 2016 2017 case LOUDNESS_CONTROL: 2018 mix.type = MIX_ON_OFF; 2019 mix.ctl = SOUND_MIXER_LOUD; /* Is this correct ? */ 2020 break; 2021 2022 default: 2023 mix.type = MIX_UNKNOWN; 2024 break; 2025 } 2026 2027 if (mix.type != MIX_UNKNOWN) { 2028 uaudio_mixer_add_ctl(sc, &mix); 2029 } 2030 } 2031 } 2032 2033 static void 2034 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc, 2035 const struct uaudio_terminal_node *iot, int id) 2036 { 2037 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu; 2038 const struct usb_audio_processing_unit_1 *d1 = 2039 (const void *)(d0->baSourceId + d0->bNrInPins); 2040 const struct usb_audio_processing_unit_updown *ud = 2041 (const void *)(d1->bmControls + d1->bControlSize); 2042 struct uaudio_mixer_node mix; 2043 uint8_t i; 2044 2045 if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) { 2046 return; 2047 } 2048 if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes)) 2049 == NULL) { 2050 return; 2051 } 2052 DPRINTFN(3, "bUnitId=%d bNrModes=%d\n", 2053 d0->bUnitId, ud->bNrModes); 2054 2055 if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) { 2056 DPRINTF("no mode select\n"); 2057 return; 2058 } 2059 memset(&mix, 0, sizeof(mix)); 2060 2061 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 2062 mix.nchan = 1; 2063 mix.wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0); 2064 uaudio_mixer_determine_class(&iot[id], &mix); 2065 mix.type = MIX_ON_OFF; /* XXX */ 2066 2067 for (i = 0; i < ud->bNrModes; i++) { 2068 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i])); 2069 /* XXX */ 2070 } 2071 2072 uaudio_mixer_add_ctl(sc, &mix); 2073 } 2074 2075 static void 2076 uaudio_mixer_add_processing(struct uaudio_softc *sc, 2077 const struct uaudio_terminal_node *iot, int id) 2078 { 2079 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu; 2080 const struct usb_audio_processing_unit_1 *d1 = 2081 (const void *)(d0->baSourceId + d0->bNrInPins); 2082 struct uaudio_mixer_node mix; 2083 uint16_t ptype; 2084 2085 memset(&mix, 0, sizeof(mix)); 2086 2087 ptype = UGETW(d0->wProcessType); 2088 2089 DPRINTFN(3, "wProcessType=%d bUnitId=%d " 2090 "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins); 2091 2092 if (d1->bControlSize == 0) { 2093 return; 2094 } 2095 if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) { 2096 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 2097 mix.nchan = 1; 2098 mix.wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0); 2099 uaudio_mixer_determine_class(&iot[id], &mix); 2100 mix.type = MIX_ON_OFF; 2101 uaudio_mixer_add_ctl(sc, &mix); 2102 } 2103 switch (ptype) { 2104 case UPDOWNMIX_PROCESS: 2105 uaudio_mixer_add_processing_updown(sc, iot, id); 2106 break; 2107 2108 case DOLBY_PROLOGIC_PROCESS: 2109 case P3D_STEREO_EXTENDER_PROCESS: 2110 case REVERBATION_PROCESS: 2111 case CHORUS_PROCESS: 2112 case DYN_RANGE_COMP_PROCESS: 2113 default: 2114 DPRINTF("unit %d, type=%d is not implemented\n", 2115 d0->bUnitId, ptype); 2116 break; 2117 } 2118 } 2119 2120 static void 2121 uaudio_mixer_add_extension(struct uaudio_softc *sc, 2122 const struct uaudio_terminal_node *iot, int id) 2123 { 2124 const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu; 2125 const struct usb_audio_extension_unit_1 *d1 = 2126 (const void *)(d0->baSourceId + d0->bNrInPins); 2127 struct uaudio_mixer_node mix; 2128 2129 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 2130 d0->bUnitId, d0->bNrInPins); 2131 2132 if (sc->sc_uq_au_no_xu) { 2133 return; 2134 } 2135 if (d1->bControlSize == 0) { 2136 return; 2137 } 2138 if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) { 2139 2140 memset(&mix, 0, sizeof(mix)); 2141 2142 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 2143 mix.nchan = 1; 2144 mix.wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0); 2145 uaudio_mixer_determine_class(&iot[id], &mix); 2146 mix.type = MIX_ON_OFF; 2147 2148 uaudio_mixer_add_ctl(sc, &mix); 2149 } 2150 } 2151 2152 static const void * 2153 uaudio_mixer_verify_desc(const void *arg, uint32_t len) 2154 { 2155 const struct usb_audio_mixer_unit_1 *d1; 2156 const struct usb_audio_extension_unit_1 *e1; 2157 const struct usb_audio_processing_unit_1 *u1; 2158 2159 union { 2160 const struct usb_descriptor *desc; 2161 const struct usb_audio_input_terminal *it; 2162 const struct usb_audio_output_terminal *ot; 2163 const struct usb_audio_mixer_unit_0 *mu; 2164 const struct usb_audio_selector_unit *su; 2165 const struct usb_audio_feature_unit *fu; 2166 const struct usb_audio_processing_unit_0 *pu; 2167 const struct usb_audio_extension_unit_0 *eu; 2168 } u; 2169 2170 u.desc = arg; 2171 2172 if (u.desc == NULL) { 2173 goto error; 2174 } 2175 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) { 2176 goto error; 2177 } 2178 switch (u.desc->bDescriptorSubtype) { 2179 case UDESCSUB_AC_INPUT: 2180 len += sizeof(*u.it); 2181 break; 2182 2183 case UDESCSUB_AC_OUTPUT: 2184 len += sizeof(*u.ot); 2185 break; 2186 2187 case UDESCSUB_AC_MIXER: 2188 len += sizeof(*u.mu); 2189 2190 if (u.desc->bLength < len) { 2191 goto error; 2192 } 2193 len += u.mu->bNrInPins; 2194 2195 if (u.desc->bLength < len) { 2196 goto error; 2197 } 2198 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins); 2199 2200 len += sizeof(*d1); 2201 break; 2202 2203 case UDESCSUB_AC_SELECTOR: 2204 len += sizeof(*u.su); 2205 2206 if (u.desc->bLength < len) { 2207 goto error; 2208 } 2209 len += u.su->bNrInPins; 2210 break; 2211 2212 case UDESCSUB_AC_FEATURE: 2213 len += (sizeof(*u.fu) + 1); 2214 break; 2215 2216 case UDESCSUB_AC_PROCESSING: 2217 len += sizeof(*u.pu); 2218 2219 if (u.desc->bLength < len) { 2220 goto error; 2221 } 2222 len += u.pu->bNrInPins; 2223 2224 if (u.desc->bLength < len) { 2225 goto error; 2226 } 2227 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins); 2228 2229 len += sizeof(*u1); 2230 2231 if (u.desc->bLength < len) { 2232 goto error; 2233 } 2234 len += u1->bControlSize; 2235 2236 break; 2237 2238 case UDESCSUB_AC_EXTENSION: 2239 len += sizeof(*u.eu); 2240 2241 if (u.desc->bLength < len) { 2242 goto error; 2243 } 2244 len += u.eu->bNrInPins; 2245 2246 if (u.desc->bLength < len) { 2247 goto error; 2248 } 2249 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins); 2250 2251 len += sizeof(*e1); 2252 2253 if (u.desc->bLength < len) { 2254 goto error; 2255 } 2256 len += e1->bControlSize; 2257 break; 2258 2259 default: 2260 goto error; 2261 } 2262 2263 if (u.desc->bLength < len) { 2264 goto error; 2265 } 2266 return (u.desc); 2267 2268 error: 2269 if (u.desc) { 2270 DPRINTF("invalid descriptor, type=%d, " 2271 "sub_type=%d, len=%d of %d bytes\n", 2272 u.desc->bDescriptorType, 2273 u.desc->bDescriptorSubtype, 2274 u.desc->bLength, len); 2275 } 2276 return (NULL); 2277 } 2278 2279 #ifdef USB_DEBUG 2280 static void 2281 uaudio_mixer_dump_cluster(uint8_t id, const struct uaudio_terminal_node *iot) 2282 { 2283 static const char *channel_names[16] = { 2284 "LEFT", "RIGHT", "CENTER", "LFE", 2285 "LEFT_SURROUND", "RIGHT_SURROUND", "LEFT_CENTER", "RIGHT_CENTER", 2286 "SURROUND", "LEFT_SIDE", "RIGHT_SIDE", "TOP", 2287 "RESERVED12", "RESERVED13", "RESERVED14", "RESERVED15", 2288 }; 2289 uint16_t cc; 2290 uint8_t i; 2291 const struct usb_audio_cluster cl = uaudio_mixer_get_cluster(id, iot); 2292 2293 cc = UGETW(cl.wChannelConfig); 2294 2295 DPRINTF("cluster: bNrChannels=%u iChannelNames=%u wChannelConfig=" 2296 "0x%04x:\n", cl.iChannelNames, cl.bNrChannels, cc); 2297 2298 for (i = 0; cc; i++) { 2299 if (cc & 1) { 2300 DPRINTF(" - %s\n", channel_names[i]); 2301 } 2302 cc >>= 1; 2303 } 2304 } 2305 2306 #endif 2307 2308 static struct usb_audio_cluster 2309 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot) 2310 { 2311 struct usb_audio_cluster r; 2312 const struct usb_descriptor *dp; 2313 uint8_t i; 2314 2315 for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) { /* avoid infinite loops */ 2316 dp = iot[id].u.desc; 2317 if (dp == NULL) { 2318 goto error; 2319 } 2320 switch (dp->bDescriptorSubtype) { 2321 case UDESCSUB_AC_INPUT: 2322 r.bNrChannels = iot[id].u.it->bNrChannels; 2323 r.wChannelConfig[0] = iot[id].u.it->wChannelConfig[0]; 2324 r.wChannelConfig[1] = iot[id].u.it->wChannelConfig[1]; 2325 r.iChannelNames = iot[id].u.it->iChannelNames; 2326 goto done; 2327 2328 case UDESCSUB_AC_OUTPUT: 2329 id = iot[id].u.ot->bSourceId; 2330 break; 2331 2332 case UDESCSUB_AC_MIXER: 2333 r = *(const struct usb_audio_cluster *) 2334 &iot[id].u.mu->baSourceId[iot[id].u.mu-> 2335 bNrInPins]; 2336 goto done; 2337 2338 case UDESCSUB_AC_SELECTOR: 2339 if (iot[id].u.su->bNrInPins > 0) { 2340 /* XXX This is not really right */ 2341 id = iot[id].u.su->baSourceId[0]; 2342 } 2343 break; 2344 2345 case UDESCSUB_AC_FEATURE: 2346 id = iot[id].u.fu->bSourceId; 2347 break; 2348 2349 case UDESCSUB_AC_PROCESSING: 2350 r = *((const struct usb_audio_cluster *) 2351 &iot[id].u.pu->baSourceId[iot[id].u.pu-> 2352 bNrInPins]); 2353 goto done; 2354 2355 case UDESCSUB_AC_EXTENSION: 2356 r = *((const struct usb_audio_cluster *) 2357 &iot[id].u.eu->baSourceId[iot[id].u.eu-> 2358 bNrInPins]); 2359 goto done; 2360 2361 default: 2362 goto error; 2363 } 2364 } 2365 error: 2366 DPRINTF("bad data\n"); 2367 memset(&r, 0, sizeof(r)); 2368 done: 2369 return (r); 2370 } 2371 2372 #ifdef USB_DEBUG 2373 2374 struct uaudio_tt_to_string { 2375 uint16_t terminal_type; 2376 const char *desc; 2377 }; 2378 2379 static const struct uaudio_tt_to_string uaudio_tt_to_string[] = { 2380 2381 /* USB terminal types */ 2382 {UAT_UNDEFINED, "UAT_UNDEFINED"}, 2383 {UAT_STREAM, "UAT_STREAM"}, 2384 {UAT_VENDOR, "UAT_VENDOR"}, 2385 2386 /* input terminal types */ 2387 {UATI_UNDEFINED, "UATI_UNDEFINED"}, 2388 {UATI_MICROPHONE, "UATI_MICROPHONE"}, 2389 {UATI_DESKMICROPHONE, "UATI_DESKMICROPHONE"}, 2390 {UATI_PERSONALMICROPHONE, "UATI_PERSONALMICROPHONE"}, 2391 {UATI_OMNIMICROPHONE, "UATI_OMNIMICROPHONE"}, 2392 {UATI_MICROPHONEARRAY, "UATI_MICROPHONEARRAY"}, 2393 {UATI_PROCMICROPHONEARR, "UATI_PROCMICROPHONEARR"}, 2394 2395 /* output terminal types */ 2396 {UATO_UNDEFINED, "UATO_UNDEFINED"}, 2397 {UATO_SPEAKER, "UATO_SPEAKER"}, 2398 {UATO_HEADPHONES, "UATO_HEADPHONES"}, 2399 {UATO_DISPLAYAUDIO, "UATO_DISPLAYAUDIO"}, 2400 {UATO_DESKTOPSPEAKER, "UATO_DESKTOPSPEAKER"}, 2401 {UATO_ROOMSPEAKER, "UATO_ROOMSPEAKER"}, 2402 {UATO_COMMSPEAKER, "UATO_COMMSPEAKER"}, 2403 {UATO_SUBWOOFER, "UATO_SUBWOOFER"}, 2404 2405 /* bidir terminal types */ 2406 {UATB_UNDEFINED, "UATB_UNDEFINED"}, 2407 {UATB_HANDSET, "UATB_HANDSET"}, 2408 {UATB_HEADSET, "UATB_HEADSET"}, 2409 {UATB_SPEAKERPHONE, "UATB_SPEAKERPHONE"}, 2410 {UATB_SPEAKERPHONEESUP, "UATB_SPEAKERPHONEESUP"}, 2411 {UATB_SPEAKERPHONEECANC, "UATB_SPEAKERPHONEECANC"}, 2412 2413 /* telephony terminal types */ 2414 {UATT_UNDEFINED, "UATT_UNDEFINED"}, 2415 {UATT_PHONELINE, "UATT_PHONELINE"}, 2416 {UATT_TELEPHONE, "UATT_TELEPHONE"}, 2417 {UATT_DOWNLINEPHONE, "UATT_DOWNLINEPHONE"}, 2418 2419 /* external terminal types */ 2420 {UATE_UNDEFINED, "UATE_UNDEFINED"}, 2421 {UATE_ANALOGCONN, "UATE_ANALOGCONN"}, 2422 {UATE_LINECONN, "UATE_LINECONN"}, 2423 {UATE_LEGACYCONN, "UATE_LEGACYCONN"}, 2424 {UATE_DIGITALAUIFC, "UATE_DIGITALAUIFC"}, 2425 {UATE_SPDIF, "UATE_SPDIF"}, 2426 {UATE_1394DA, "UATE_1394DA"}, 2427 {UATE_1394DV, "UATE_1394DV"}, 2428 2429 /* embedded function terminal types */ 2430 {UATF_UNDEFINED, "UATF_UNDEFINED"}, 2431 {UATF_CALIBNOISE, "UATF_CALIBNOISE"}, 2432 {UATF_EQUNOISE, "UATF_EQUNOISE"}, 2433 {UATF_CDPLAYER, "UATF_CDPLAYER"}, 2434 {UATF_DAT, "UATF_DAT"}, 2435 {UATF_DCC, "UATF_DCC"}, 2436 {UATF_MINIDISK, "UATF_MINIDISK"}, 2437 {UATF_ANALOGTAPE, "UATF_ANALOGTAPE"}, 2438 {UATF_PHONOGRAPH, "UATF_PHONOGRAPH"}, 2439 {UATF_VCRAUDIO, "UATF_VCRAUDIO"}, 2440 {UATF_VIDEODISCAUDIO, "UATF_VIDEODISCAUDIO"}, 2441 {UATF_DVDAUDIO, "UATF_DVDAUDIO"}, 2442 {UATF_TVTUNERAUDIO, "UATF_TVTUNERAUDIO"}, 2443 {UATF_SATELLITE, "UATF_SATELLITE"}, 2444 {UATF_CABLETUNER, "UATF_CABLETUNER"}, 2445 {UATF_DSS, "UATF_DSS"}, 2446 {UATF_RADIORECV, "UATF_RADIORECV"}, 2447 {UATF_RADIOXMIT, "UATF_RADIOXMIT"}, 2448 {UATF_MULTITRACK, "UATF_MULTITRACK"}, 2449 {UATF_SYNTHESIZER, "UATF_SYNTHESIZER"}, 2450 2451 /* unknown */ 2452 {0x0000, "UNKNOWN"}, 2453 }; 2454 2455 static const char * 2456 uaudio_mixer_get_terminal_name(uint16_t terminal_type) 2457 { 2458 const struct uaudio_tt_to_string *uat = uaudio_tt_to_string; 2459 2460 while (uat->terminal_type) { 2461 if (uat->terminal_type == terminal_type) { 2462 break; 2463 } 2464 uat++; 2465 } 2466 if (uat->terminal_type == 0) { 2467 DPRINTF("unknown terminal type (0x%04x)", terminal_type); 2468 } 2469 return (uat->desc); 2470 } 2471 2472 #endif 2473 2474 static uint16_t 2475 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot, 2476 struct uaudio_mixer_node *mix) 2477 { 2478 uint16_t terminal_type = 0x0000; 2479 const struct uaudio_terminal_node *input[2]; 2480 const struct uaudio_terminal_node *output[2]; 2481 2482 input[0] = uaudio_mixer_get_input(iot, 0); 2483 input[1] = uaudio_mixer_get_input(iot, 1); 2484 2485 output[0] = uaudio_mixer_get_output(iot, 0); 2486 output[1] = uaudio_mixer_get_output(iot, 1); 2487 2488 /* 2489 * check if there is only 2490 * one output terminal: 2491 */ 2492 if (output[0] && (!output[1])) { 2493 terminal_type = UGETW(output[0]->u.ot->wTerminalType); 2494 } 2495 /* 2496 * If the only output terminal is USB, 2497 * the class is UAC_RECORD. 2498 */ 2499 if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) { 2500 2501 mix->class = UAC_RECORD; 2502 if (input[0] && (!input[1])) { 2503 terminal_type = UGETW(input[0]->u.it->wTerminalType); 2504 } else { 2505 terminal_type = 0; 2506 } 2507 goto done; 2508 } 2509 /* 2510 * if the unit is connected to just 2511 * one input terminal, the 2512 * class is UAC_INPUT: 2513 */ 2514 if (input[0] && (!input[1])) { 2515 mix->class = UAC_INPUT; 2516 terminal_type = UGETW(input[0]->u.it->wTerminalType); 2517 goto done; 2518 } 2519 /* 2520 * Otherwise, the class is UAC_OUTPUT. 2521 */ 2522 mix->class = UAC_OUTPUT; 2523 done: 2524 return (terminal_type); 2525 } 2526 2527 struct uaudio_tt_to_feature { 2528 uint16_t terminal_type; 2529 uint16_t feature; 2530 }; 2531 2532 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = { 2533 2534 {UAT_STREAM, SOUND_MIXER_PCM}, 2535 2536 {UATI_MICROPHONE, SOUND_MIXER_MIC}, 2537 {UATI_DESKMICROPHONE, SOUND_MIXER_MIC}, 2538 {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC}, 2539 {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC}, 2540 {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC}, 2541 {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC}, 2542 2543 {UATO_SPEAKER, SOUND_MIXER_SPEAKER}, 2544 {UATO_DESKTOPSPEAKER, SOUND_MIXER_SPEAKER}, 2545 {UATO_ROOMSPEAKER, SOUND_MIXER_SPEAKER}, 2546 {UATO_COMMSPEAKER, SOUND_MIXER_SPEAKER}, 2547 2548 {UATE_ANALOGCONN, SOUND_MIXER_LINE}, 2549 {UATE_LINECONN, SOUND_MIXER_LINE}, 2550 {UATE_LEGACYCONN, SOUND_MIXER_LINE}, 2551 2552 {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM}, 2553 {UATE_SPDIF, SOUND_MIXER_ALTPCM}, 2554 {UATE_1394DA, SOUND_MIXER_ALTPCM}, 2555 {UATE_1394DV, SOUND_MIXER_ALTPCM}, 2556 2557 {UATF_CDPLAYER, SOUND_MIXER_CD}, 2558 2559 {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH}, 2560 2561 {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO}, 2562 {UATF_DVDAUDIO, SOUND_MIXER_VIDEO}, 2563 {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO}, 2564 2565 /* telephony terminal types */ 2566 {UATT_UNDEFINED, SOUND_MIXER_PHONEIN}, /* SOUND_MIXER_PHONEOUT */ 2567 {UATT_PHONELINE, SOUND_MIXER_PHONEIN}, /* SOUND_MIXER_PHONEOUT */ 2568 {UATT_TELEPHONE, SOUND_MIXER_PHONEIN}, /* SOUND_MIXER_PHONEOUT */ 2569 {UATT_DOWNLINEPHONE, SOUND_MIXER_PHONEIN}, /* SOUND_MIXER_PHONEOUT */ 2570 2571 {UATF_RADIORECV, SOUND_MIXER_RADIO}, 2572 {UATF_RADIOXMIT, SOUND_MIXER_RADIO}, 2573 2574 {UAT_UNDEFINED, SOUND_MIXER_VOLUME}, 2575 {UAT_VENDOR, SOUND_MIXER_VOLUME}, 2576 {UATI_UNDEFINED, SOUND_MIXER_VOLUME}, 2577 2578 /* output terminal types */ 2579 {UATO_UNDEFINED, SOUND_MIXER_VOLUME}, 2580 {UATO_DISPLAYAUDIO, SOUND_MIXER_VOLUME}, 2581 {UATO_SUBWOOFER, SOUND_MIXER_VOLUME}, 2582 {UATO_HEADPHONES, SOUND_MIXER_VOLUME}, 2583 2584 /* bidir terminal types */ 2585 {UATB_UNDEFINED, SOUND_MIXER_VOLUME}, 2586 {UATB_HANDSET, SOUND_MIXER_VOLUME}, 2587 {UATB_HEADSET, SOUND_MIXER_VOLUME}, 2588 {UATB_SPEAKERPHONE, SOUND_MIXER_VOLUME}, 2589 {UATB_SPEAKERPHONEESUP, SOUND_MIXER_VOLUME}, 2590 {UATB_SPEAKERPHONEECANC, SOUND_MIXER_VOLUME}, 2591 2592 /* external terminal types */ 2593 {UATE_UNDEFINED, SOUND_MIXER_VOLUME}, 2594 2595 /* embedded function terminal types */ 2596 {UATF_UNDEFINED, SOUND_MIXER_VOLUME}, 2597 {UATF_CALIBNOISE, SOUND_MIXER_VOLUME}, 2598 {UATF_EQUNOISE, SOUND_MIXER_VOLUME}, 2599 {UATF_DAT, SOUND_MIXER_VOLUME}, 2600 {UATF_DCC, SOUND_MIXER_VOLUME}, 2601 {UATF_MINIDISK, SOUND_MIXER_VOLUME}, 2602 {UATF_ANALOGTAPE, SOUND_MIXER_VOLUME}, 2603 {UATF_PHONOGRAPH, SOUND_MIXER_VOLUME}, 2604 {UATF_VCRAUDIO, SOUND_MIXER_VOLUME}, 2605 {UATF_SATELLITE, SOUND_MIXER_VOLUME}, 2606 {UATF_CABLETUNER, SOUND_MIXER_VOLUME}, 2607 {UATF_DSS, SOUND_MIXER_VOLUME}, 2608 {UATF_MULTITRACK, SOUND_MIXER_VOLUME}, 2609 {0xffff, SOUND_MIXER_VOLUME}, 2610 2611 /* default */ 2612 {0x0000, SOUND_MIXER_VOLUME}, 2613 }; 2614 2615 static uint16_t 2616 uaudio_mixer_feature_name(const struct uaudio_terminal_node *iot, 2617 struct uaudio_mixer_node *mix) 2618 { 2619 const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature; 2620 uint16_t terminal_type = uaudio_mixer_determine_class(iot, mix); 2621 2622 if ((mix->class == UAC_RECORD) && (terminal_type == 0)) { 2623 return (SOUND_MIXER_IMIX); 2624 } 2625 while (uat->terminal_type) { 2626 if (uat->terminal_type == terminal_type) { 2627 break; 2628 } 2629 uat++; 2630 } 2631 2632 DPRINTF("terminal_type=%s (0x%04x) -> %d\n", 2633 uaudio_mixer_get_terminal_name(terminal_type), 2634 terminal_type, uat->feature); 2635 2636 return (uat->feature); 2637 } 2638 2639 const static struct uaudio_terminal_node * 2640 uaudio_mixer_get_input(const struct uaudio_terminal_node *iot, uint8_t index) 2641 { 2642 struct uaudio_terminal_node *root = iot->root; 2643 uint8_t n; 2644 2645 n = iot->usr.id_max; 2646 do { 2647 if (iot->usr.bit_input[n / 8] & (1 << (n % 8))) { 2648 if (!index--) { 2649 return (root + n); 2650 } 2651 } 2652 } while (n--); 2653 2654 return (NULL); 2655 } 2656 2657 const static struct uaudio_terminal_node * 2658 uaudio_mixer_get_output(const struct uaudio_terminal_node *iot, uint8_t index) 2659 { 2660 struct uaudio_terminal_node *root = iot->root; 2661 uint8_t n; 2662 2663 n = iot->usr.id_max; 2664 do { 2665 if (iot->usr.bit_output[n / 8] & (1 << (n % 8))) { 2666 if (!index--) { 2667 return (root + n); 2668 } 2669 } 2670 } while (n--); 2671 2672 return (NULL); 2673 } 2674 2675 static void 2676 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root, 2677 const uint8_t *p_id, uint8_t n_id, 2678 struct uaudio_search_result *info) 2679 { 2680 struct uaudio_terminal_node *iot; 2681 uint8_t n; 2682 uint8_t i; 2683 2684 if (info->recurse_level >= UAUDIO_RECURSE_LIMIT) { 2685 return; 2686 } 2687 info->recurse_level++; 2688 2689 for (n = 0; n < n_id; n++) { 2690 2691 i = p_id[n]; 2692 2693 if (info->bit_visited[i / 8] & (1 << (i % 8))) { 2694 /* don't go into a circle */ 2695 DPRINTF("avoided going into a circle at id=%d!\n", i); 2696 continue; 2697 } else { 2698 info->bit_visited[i / 8] |= (1 << (i % 8)); 2699 } 2700 2701 iot = (root + i); 2702 2703 if (iot->u.desc == NULL) { 2704 continue; 2705 } 2706 switch (iot->u.desc->bDescriptorSubtype) { 2707 case UDESCSUB_AC_INPUT: 2708 info->bit_input[i / 8] |= (1 << (i % 8)); 2709 break; 2710 2711 case UDESCSUB_AC_FEATURE: 2712 uaudio_mixer_find_inputs_sub 2713 (root, &iot->u.fu->bSourceId, 1, info); 2714 break; 2715 2716 case UDESCSUB_AC_OUTPUT: 2717 uaudio_mixer_find_inputs_sub 2718 (root, &iot->u.ot->bSourceId, 1, info); 2719 break; 2720 2721 case UDESCSUB_AC_MIXER: 2722 uaudio_mixer_find_inputs_sub 2723 (root, iot->u.mu->baSourceId, 2724 iot->u.mu->bNrInPins, info); 2725 break; 2726 2727 case UDESCSUB_AC_SELECTOR: 2728 uaudio_mixer_find_inputs_sub 2729 (root, iot->u.su->baSourceId, 2730 iot->u.su->bNrInPins, info); 2731 break; 2732 2733 case UDESCSUB_AC_PROCESSING: 2734 uaudio_mixer_find_inputs_sub 2735 (root, iot->u.pu->baSourceId, 2736 iot->u.pu->bNrInPins, info); 2737 break; 2738 2739 case UDESCSUB_AC_EXTENSION: 2740 uaudio_mixer_find_inputs_sub 2741 (root, iot->u.eu->baSourceId, 2742 iot->u.eu->bNrInPins, info); 2743 break; 2744 2745 case UDESCSUB_AC_HEADER: 2746 default: 2747 break; 2748 } 2749 } 2750 info->recurse_level--; 2751 } 2752 2753 static void 2754 uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *root, uint8_t id, 2755 uint8_t n_id, struct uaudio_search_result *info) 2756 { 2757 struct uaudio_terminal_node *iot = (root + id); 2758 uint8_t j; 2759 2760 j = n_id; 2761 do { 2762 if ((j != id) && ((root + j)->u.desc) && 2763 ((root + j)->u.desc->bDescriptorSubtype == UDESCSUB_AC_OUTPUT)) { 2764 2765 /* 2766 * "j" (output) <--- virtual wire <--- "id" (input) 2767 * 2768 * if "j" has "id" on the input, then "id" have "j" on 2769 * the output, because they are connected: 2770 */ 2771 if ((root + j)->usr.bit_input[id / 8] & (1 << (id % 8))) { 2772 iot->usr.bit_output[j / 8] |= (1 << (j % 8)); 2773 } 2774 } 2775 } while (j--); 2776 } 2777 2778 static void 2779 uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev, 2780 void *desc) 2781 { 2782 const struct usb_audio_control_descriptor *acdp; 2783 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); 2784 const struct usb_descriptor *dp; 2785 const struct usb_audio_unit *au; 2786 struct uaudio_terminal_node *iot = NULL; 2787 uint16_t wTotalLen; 2788 uint8_t ID_max = 0; /* inclusive */ 2789 uint8_t i; 2790 2791 desc = usb_desc_foreach(cd, desc); 2792 2793 if (desc == NULL) { 2794 DPRINTF("no Audio Control header\n"); 2795 goto done; 2796 } 2797 acdp = desc; 2798 2799 if ((acdp->bLength < sizeof(*acdp)) || 2800 (acdp->bDescriptorType != UDESC_CS_INTERFACE) || 2801 (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) { 2802 DPRINTF("invalid Audio Control header\n"); 2803 goto done; 2804 } 2805 /* "wTotalLen" is allowed to be corrupt */ 2806 wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength; 2807 2808 /* get USB audio revision */ 2809 sc->sc_audio_rev = UGETW(acdp->bcdADC); 2810 2811 DPRINTFN(3, "found AC header, vers=%03x, len=%d\n", 2812 sc->sc_audio_rev, wTotalLen); 2813 2814 if (sc->sc_audio_rev != UAUDIO_VERSION) { 2815 2816 if (sc->sc_uq_bad_adc) { 2817 2818 } else { 2819 DPRINTF("invalid audio version\n"); 2820 goto done; 2821 } 2822 } 2823 iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP, 2824 M_WAITOK | M_ZERO); 2825 2826 if (iot == NULL) { 2827 DPRINTF("no memory!\n"); 2828 goto done; 2829 } 2830 while ((desc = usb_desc_foreach(cd, desc))) { 2831 2832 dp = desc; 2833 2834 if (dp->bLength > wTotalLen) { 2835 break; 2836 } else { 2837 wTotalLen -= dp->bLength; 2838 } 2839 2840 au = uaudio_mixer_verify_desc(dp, 0); 2841 2842 if (au) { 2843 iot[au->bUnitId].u.desc = (const void *)au; 2844 if (au->bUnitId > ID_max) { 2845 ID_max = au->bUnitId; 2846 } 2847 } 2848 } 2849 2850 DPRINTF("Maximum ID=%d\n", ID_max); 2851 2852 /* 2853 * determine sourcing inputs for 2854 * all nodes in the tree: 2855 */ 2856 i = ID_max; 2857 do { 2858 uaudio_mixer_find_inputs_sub(iot, &i, 1, &((iot + i)->usr)); 2859 } while (i--); 2860 2861 /* 2862 * determine outputs for 2863 * all nodes in the tree: 2864 */ 2865 i = ID_max; 2866 do { 2867 uaudio_mixer_find_outputs_sub(iot, i, ID_max, &((iot + i)->usr)); 2868 } while (i--); 2869 2870 /* set "id_max" and "root" */ 2871 2872 i = ID_max; 2873 do { 2874 (iot + i)->usr.id_max = ID_max; 2875 (iot + i)->root = iot; 2876 } while (i--); 2877 2878 #ifdef USB_DEBUG 2879 i = ID_max; 2880 do { 2881 uint8_t j; 2882 2883 if (iot[i].u.desc == NULL) { 2884 continue; 2885 } 2886 DPRINTF("id %d:\n", i); 2887 2888 switch (iot[i].u.desc->bDescriptorSubtype) { 2889 case UDESCSUB_AC_INPUT: 2890 DPRINTF(" - AC_INPUT type=%s\n", 2891 uaudio_mixer_get_terminal_name 2892 (UGETW(iot[i].u.it->wTerminalType))); 2893 uaudio_mixer_dump_cluster(i, iot); 2894 break; 2895 2896 case UDESCSUB_AC_OUTPUT: 2897 DPRINTF(" - AC_OUTPUT type=%s " 2898 "src=%d\n", uaudio_mixer_get_terminal_name 2899 (UGETW(iot[i].u.ot->wTerminalType)), 2900 iot[i].u.ot->bSourceId); 2901 break; 2902 2903 case UDESCSUB_AC_MIXER: 2904 DPRINTF(" - AC_MIXER src:\n"); 2905 for (j = 0; j < iot[i].u.mu->bNrInPins; j++) { 2906 DPRINTF(" - %d\n", iot[i].u.mu->baSourceId[j]); 2907 } 2908 uaudio_mixer_dump_cluster(i, iot); 2909 break; 2910 2911 case UDESCSUB_AC_SELECTOR: 2912 DPRINTF(" - AC_SELECTOR src:\n"); 2913 for (j = 0; j < iot[i].u.su->bNrInPins; j++) { 2914 DPRINTF(" - %d\n", iot[i].u.su->baSourceId[j]); 2915 } 2916 break; 2917 2918 case UDESCSUB_AC_FEATURE: 2919 DPRINTF(" - AC_FEATURE src=%d\n", iot[i].u.fu->bSourceId); 2920 break; 2921 2922 case UDESCSUB_AC_PROCESSING: 2923 DPRINTF(" - AC_PROCESSING src:\n"); 2924 for (j = 0; j < iot[i].u.pu->bNrInPins; j++) { 2925 DPRINTF(" - %d\n", iot[i].u.pu->baSourceId[j]); 2926 } 2927 uaudio_mixer_dump_cluster(i, iot); 2928 break; 2929 2930 case UDESCSUB_AC_EXTENSION: 2931 DPRINTF(" - AC_EXTENSION src:\n"); 2932 for (j = 0; j < iot[i].u.eu->bNrInPins; j++) { 2933 DPRINTF("%d ", iot[i].u.eu->baSourceId[j]); 2934 } 2935 uaudio_mixer_dump_cluster(i, iot); 2936 break; 2937 2938 default: 2939 DPRINTF("unknown audio control (subtype=%d)\n", 2940 iot[i].u.desc->bDescriptorSubtype); 2941 } 2942 2943 DPRINTF("Inputs to this ID are:\n"); 2944 2945 j = ID_max; 2946 do { 2947 if (iot[i].usr.bit_input[j / 8] & (1 << (j % 8))) { 2948 DPRINTF(" -- ID=%d\n", j); 2949 } 2950 } while (j--); 2951 2952 DPRINTF("Outputs from this ID are:\n"); 2953 2954 j = ID_max; 2955 do { 2956 if (iot[i].usr.bit_output[j / 8] & (1 << (j % 8))) { 2957 DPRINTF(" -- ID=%d\n", j); 2958 } 2959 } while (j--); 2960 2961 } while (i--); 2962 #endif 2963 2964 /* 2965 * scan the config to create a linked 2966 * list of "mixer" nodes: 2967 */ 2968 2969 i = ID_max; 2970 do { 2971 dp = iot[i].u.desc; 2972 2973 if (dp == NULL) { 2974 continue; 2975 } 2976 DPRINTFN(11, "id=%d subtype=%d\n", 2977 i, dp->bDescriptorSubtype); 2978 2979 switch (dp->bDescriptorSubtype) { 2980 case UDESCSUB_AC_HEADER: 2981 DPRINTF("unexpected AC header\n"); 2982 break; 2983 2984 case UDESCSUB_AC_INPUT: 2985 uaudio_mixer_add_input(sc, iot, i); 2986 break; 2987 2988 case UDESCSUB_AC_OUTPUT: 2989 uaudio_mixer_add_output(sc, iot, i); 2990 break; 2991 2992 case UDESCSUB_AC_MIXER: 2993 uaudio_mixer_add_mixer(sc, iot, i); 2994 break; 2995 2996 case UDESCSUB_AC_SELECTOR: 2997 uaudio_mixer_add_selector(sc, iot, i); 2998 break; 2999 3000 case UDESCSUB_AC_FEATURE: 3001 uaudio_mixer_add_feature(sc, iot, i); 3002 break; 3003 3004 case UDESCSUB_AC_PROCESSING: 3005 uaudio_mixer_add_processing(sc, iot, i); 3006 break; 3007 3008 case UDESCSUB_AC_EXTENSION: 3009 uaudio_mixer_add_extension(sc, iot, i); 3010 break; 3011 3012 default: 3013 DPRINTF("bad AC desc subtype=0x%02x\n", 3014 dp->bDescriptorSubtype); 3015 break; 3016 } 3017 3018 } while (i--); 3019 3020 done: 3021 if (iot) { 3022 free(iot, M_TEMP); 3023 } 3024 } 3025 3026 static uint16_t 3027 uaudio_mixer_get(struct usb_device *udev, uint8_t what, 3028 struct uaudio_mixer_node *mc) 3029 { 3030 struct usb_device_request req; 3031 uint16_t val; 3032 uint16_t len = MIX_SIZE(mc->type); 3033 uint8_t data[4]; 3034 usb_error_t err; 3035 3036 if (mc->wValue[0] == -1) { 3037 return (0); 3038 } 3039 req.bmRequestType = UT_READ_CLASS_INTERFACE; 3040 req.bRequest = what; 3041 USETW(req.wValue, mc->wValue[0]); 3042 USETW(req.wIndex, mc->wIndex); 3043 USETW(req.wLength, len); 3044 3045 err = usbd_do_request(udev, NULL, &req, data); 3046 if (err) { 3047 DPRINTF("err=%s\n", usbd_errstr(err)); 3048 return (0); 3049 } 3050 if (len < 1) { 3051 data[0] = 0; 3052 } 3053 if (len < 2) { 3054 data[1] = 0; 3055 } 3056 val = (data[0] | (data[1] << 8)); 3057 3058 DPRINTFN(3, "val=%d\n", val); 3059 3060 return (val); 3061 } 3062 3063 static void 3064 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error) 3065 { 3066 struct usb_device_request req; 3067 struct uaudio_softc *sc = usbd_xfer_softc(xfer); 3068 struct uaudio_mixer_node *mc = sc->sc_mixer_curr; 3069 struct usb_page_cache *pc; 3070 uint16_t len; 3071 uint8_t repeat = 1; 3072 uint8_t update; 3073 uint8_t chan; 3074 uint8_t buf[2]; 3075 3076 DPRINTF("\n"); 3077 3078 switch (USB_GET_STATE(xfer)) { 3079 case USB_ST_TRANSFERRED: 3080 tr_transferred: 3081 case USB_ST_SETUP: 3082 tr_setup: 3083 3084 if (mc == NULL) { 3085 mc = sc->sc_mixer_root; 3086 sc->sc_mixer_curr = mc; 3087 sc->sc_mixer_chan = 0; 3088 repeat = 0; 3089 } 3090 while (mc) { 3091 while (sc->sc_mixer_chan < mc->nchan) { 3092 3093 len = MIX_SIZE(mc->type); 3094 3095 chan = sc->sc_mixer_chan; 3096 3097 sc->sc_mixer_chan++; 3098 3099 update = ((mc->update[chan / 8] & (1 << (chan % 8))) && 3100 (mc->wValue[chan] != -1)); 3101 3102 mc->update[chan / 8] &= ~(1 << (chan % 8)); 3103 3104 if (update) { 3105 3106 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 3107 req.bRequest = SET_CUR; 3108 USETW(req.wValue, mc->wValue[chan]); 3109 USETW(req.wIndex, mc->wIndex); 3110 USETW(req.wLength, len); 3111 3112 if (len > 0) { 3113 buf[0] = (mc->wData[chan] & 0xFF); 3114 } 3115 if (len > 1) { 3116 buf[1] = (mc->wData[chan] >> 8) & 0xFF; 3117 } 3118 pc = usbd_xfer_get_frame(xfer, 0); 3119 usbd_copy_in(pc, 0, &req, sizeof(req)); 3120 pc = usbd_xfer_get_frame(xfer, 1); 3121 usbd_copy_in(pc, 0, buf, len); 3122 3123 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 3124 usbd_xfer_set_frame_len(xfer, 1, len); 3125 usbd_xfer_set_frames(xfer, len ? 2 : 1); 3126 usbd_transfer_submit(xfer); 3127 return; 3128 } 3129 } 3130 3131 mc = mc->next; 3132 sc->sc_mixer_curr = mc; 3133 sc->sc_mixer_chan = 0; 3134 } 3135 3136 if (repeat) { 3137 goto tr_setup; 3138 } 3139 break; 3140 3141 default: /* Error */ 3142 DPRINTF("error=%s\n", usbd_errstr(error)); 3143 if (error == USB_ERR_CANCELLED) { 3144 /* do nothing - we are detaching */ 3145 break; 3146 } 3147 goto tr_transferred; 3148 } 3149 } 3150 3151 static usb_error_t 3152 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed) 3153 { 3154 struct usb_device_request req; 3155 uint8_t data[3]; 3156 3157 DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed); 3158 3159 req.bmRequestType = UT_WRITE_CLASS_ENDPOINT; 3160 req.bRequest = SET_CUR; 3161 USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0); 3162 USETW(req.wIndex, endpt); 3163 USETW(req.wLength, 3); 3164 data[0] = speed; 3165 data[1] = speed >> 8; 3166 data[2] = speed >> 16; 3167 3168 return (usbd_do_request(udev, NULL, &req, data)); 3169 } 3170 3171 static int 3172 uaudio_mixer_signext(uint8_t type, int val) 3173 { 3174 if (!MIX_UNSIGNED(type)) { 3175 if (MIX_SIZE(type) == 2) { 3176 val = (int16_t)val; 3177 } else { 3178 val = (int8_t)val; 3179 } 3180 } 3181 return (val); 3182 } 3183 3184 static int 3185 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int32_t val) 3186 { 3187 if (mc->type == MIX_ON_OFF) { 3188 val = (val != 0); 3189 } else if (mc->type == MIX_SELECTOR) { 3190 if ((val < mc->minval) || 3191 (val > mc->maxval)) { 3192 val = mc->minval; 3193 } 3194 } else { 3195 3196 /* compute actual volume */ 3197 val = (val * mc->mul) / 255; 3198 3199 /* add lower offset */ 3200 val = val + mc->minval; 3201 3202 /* make sure we don't write a value out of range */ 3203 if (val > mc->maxval) 3204 val = mc->maxval; 3205 else if (val < mc->minval) 3206 val = mc->minval; 3207 } 3208 3209 DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n", 3210 mc->type, val, mc->minval, mc->maxval, val); 3211 return (val); 3212 } 3213 3214 static void 3215 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc, 3216 uint8_t chan, int32_t val) 3217 { 3218 val = uaudio_mixer_bsd2value(mc, val); 3219 3220 mc->update[chan / 8] |= (1 << (chan % 8)); 3221 mc->wData[chan] = val; 3222 3223 /* start the transfer, if not already started */ 3224 3225 usbd_transfer_start(sc->sc_mixer_xfer[0]); 3226 } 3227 3228 static void 3229 uaudio_mixer_init(struct uaudio_softc *sc) 3230 { 3231 struct uaudio_mixer_node *mc; 3232 int32_t i; 3233 3234 for (mc = sc->sc_mixer_root; mc; 3235 mc = mc->next) { 3236 3237 if (mc->ctl != SOUND_MIXER_NRDEVICES) { 3238 /* 3239 * Set device mask bits. See 3240 * /usr/include/machine/soundcard.h 3241 */ 3242 sc->sc_mix_info |= (1 << mc->ctl); 3243 } 3244 if ((mc->ctl == SOUND_MIXER_NRDEVICES) && 3245 (mc->type == MIX_SELECTOR)) { 3246 3247 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 3248 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES) { 3249 continue; 3250 } 3251 sc->sc_recsrc_info |= 1 << mc->slctrtype[i - 1]; 3252 } 3253 } 3254 } 3255 } 3256 3257 int 3258 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m) 3259 { 3260 DPRINTF("\n"); 3261 3262 if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index, 3263 sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc, 3264 mixer_get_lock(m))) { 3265 DPRINTFN(0, "could not allocate USB " 3266 "transfer for audio mixer!\n"); 3267 return (ENOMEM); 3268 } 3269 if (!(sc->sc_mix_info & SOUND_MASK_VOLUME)) { 3270 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM); 3271 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE); 3272 } 3273 mix_setdevs(m, sc->sc_mix_info); 3274 mix_setrecdevs(m, sc->sc_recsrc_info); 3275 return (0); 3276 } 3277 3278 int 3279 uaudio_mixer_uninit_sub(struct uaudio_softc *sc) 3280 { 3281 DPRINTF("\n"); 3282 3283 usbd_transfer_unsetup(sc->sc_mixer_xfer, 1); 3284 3285 return (0); 3286 } 3287 3288 void 3289 uaudio_mixer_set(struct uaudio_softc *sc, unsigned type, 3290 unsigned left, unsigned right) 3291 { 3292 struct uaudio_mixer_node *mc; 3293 3294 for (mc = sc->sc_mixer_root; mc; 3295 mc = mc->next) { 3296 3297 if (mc->ctl == type) { 3298 if (mc->nchan == 2) { 3299 /* set Right */ 3300 uaudio_mixer_ctl_set(sc, mc, 1, (int)(right * 255) / 100); 3301 } 3302 /* set Left or Mono */ 3303 uaudio_mixer_ctl_set(sc, mc, 0, (int)(left * 255) / 100); 3304 } 3305 } 3306 } 3307 3308 uint32_t 3309 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, uint32_t src) 3310 { 3311 struct uaudio_mixer_node *mc; 3312 uint32_t mask; 3313 uint32_t temp; 3314 int32_t i; 3315 3316 for (mc = sc->sc_mixer_root; mc; 3317 mc = mc->next) { 3318 3319 if ((mc->ctl == SOUND_MIXER_NRDEVICES) && 3320 (mc->type == MIX_SELECTOR)) { 3321 3322 /* compute selector mask */ 3323 3324 mask = 0; 3325 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 3326 mask |= (1 << mc->slctrtype[i - 1]); 3327 } 3328 3329 temp = mask & src; 3330 if (temp == 0) { 3331 continue; 3332 } 3333 /* find the first set bit */ 3334 temp = (-temp) & temp; 3335 3336 /* update "src" */ 3337 src &= ~mask; 3338 src |= temp; 3339 3340 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 3341 if (temp != (1 << mc->slctrtype[i - 1])) { 3342 continue; 3343 } 3344 uaudio_mixer_ctl_set(sc, mc, 0, i); 3345 break; 3346 } 3347 } 3348 } 3349 return (src); 3350 } 3351 3352 /*========================================================================* 3353 * MIDI support routines 3354 *========================================================================*/ 3355 3356 static void 3357 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 3358 { 3359 struct umidi_chan *chan = usbd_xfer_softc(xfer); 3360 struct umidi_sub_chan *sub; 3361 struct usb_page_cache *pc; 3362 uint8_t buf[4]; 3363 uint8_t cmd_len; 3364 uint8_t cn; 3365 uint16_t pos; 3366 int actlen; 3367 3368 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 3369 3370 switch (USB_GET_STATE(xfer)) { 3371 case USB_ST_TRANSFERRED: 3372 3373 DPRINTF("actlen=%d bytes\n", actlen); 3374 3375 pos = 0; 3376 pc = usbd_xfer_get_frame(xfer, 0); 3377 3378 while (actlen >= 4) { 3379 3380 /* copy out the MIDI data */ 3381 usbd_copy_out(pc, pos, buf, 4); 3382 /* command length */ 3383 cmd_len = umidi_cmd_to_len[buf[0] & 0xF]; 3384 /* cable number */ 3385 cn = buf[0] >> 4; 3386 /* 3387 * Lookup sub-channel. The index is range 3388 * checked below. 3389 */ 3390 sub = &chan->sub[cn]; 3391 3392 if ((cmd_len != 0) && 3393 (cn < chan->max_cable) && 3394 (sub->read_open != 0)) { 3395 3396 /* Send data to the application */ 3397 usb_fifo_put_data_linear( 3398 sub->fifo.fp[USB_FIFO_RX], 3399 buf + 1, cmd_len, 1); 3400 } 3401 actlen -= 4; 3402 pos += 4; 3403 } 3404 3405 case USB_ST_SETUP: 3406 DPRINTF("start\n"); 3407 tr_setup: 3408 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 3409 usbd_transfer_submit(xfer); 3410 break; 3411 3412 default: 3413 DPRINTF("error=%s\n", usbd_errstr(error)); 3414 3415 if (error != USB_ERR_CANCELLED) { 3416 /* try to clear stall first */ 3417 usbd_xfer_set_stall(xfer); 3418 goto tr_setup; 3419 } 3420 break; 3421 } 3422 } 3423 3424 /* 3425 * The following statemachine, that converts MIDI commands to 3426 * USB MIDI packets, derives from Linux's usbmidi.c, which 3427 * was written by "Clemens Ladisch": 3428 * 3429 * Returns: 3430 * 0: No command 3431 * Else: Command is complete 3432 */ 3433 static uint8_t 3434 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b) 3435 { 3436 uint8_t p0 = (cn << 4); 3437 3438 if (b >= 0xf8) { 3439 sub->temp_0[0] = p0 | 0x0f; 3440 sub->temp_0[1] = b; 3441 sub->temp_0[2] = 0; 3442 sub->temp_0[3] = 0; 3443 sub->temp_cmd = sub->temp_0; 3444 return (1); 3445 3446 } else if (b >= 0xf0) { 3447 switch (b) { 3448 case 0xf0: /* system exclusive begin */ 3449 sub->temp_1[1] = b; 3450 sub->state = UMIDI_ST_SYSEX_1; 3451 break; 3452 case 0xf1: /* MIDI time code */ 3453 case 0xf3: /* song select */ 3454 sub->temp_1[1] = b; 3455 sub->state = UMIDI_ST_1PARAM; 3456 break; 3457 case 0xf2: /* song position pointer */ 3458 sub->temp_1[1] = b; 3459 sub->state = UMIDI_ST_2PARAM_1; 3460 break; 3461 case 0xf4: /* unknown */ 3462 case 0xf5: /* unknown */ 3463 sub->state = UMIDI_ST_UNKNOWN; 3464 break; 3465 case 0xf6: /* tune request */ 3466 sub->temp_1[0] = p0 | 0x05; 3467 sub->temp_1[1] = 0xf6; 3468 sub->temp_1[2] = 0; 3469 sub->temp_1[3] = 0; 3470 sub->temp_cmd = sub->temp_1; 3471 sub->state = UMIDI_ST_UNKNOWN; 3472 return (1); 3473 3474 case 0xf7: /* system exclusive end */ 3475 switch (sub->state) { 3476 case UMIDI_ST_SYSEX_0: 3477 sub->temp_1[0] = p0 | 0x05; 3478 sub->temp_1[1] = 0xf7; 3479 sub->temp_1[2] = 0; 3480 sub->temp_1[3] = 0; 3481 sub->temp_cmd = sub->temp_1; 3482 sub->state = UMIDI_ST_UNKNOWN; 3483 return (1); 3484 case UMIDI_ST_SYSEX_1: 3485 sub->temp_1[0] = p0 | 0x06; 3486 sub->temp_1[2] = 0xf7; 3487 sub->temp_1[3] = 0; 3488 sub->temp_cmd = sub->temp_1; 3489 sub->state = UMIDI_ST_UNKNOWN; 3490 return (1); 3491 case UMIDI_ST_SYSEX_2: 3492 sub->temp_1[0] = p0 | 0x07; 3493 sub->temp_1[3] = 0xf7; 3494 sub->temp_cmd = sub->temp_1; 3495 sub->state = UMIDI_ST_UNKNOWN; 3496 return (1); 3497 } 3498 sub->state = UMIDI_ST_UNKNOWN; 3499 break; 3500 } 3501 } else if (b >= 0x80) { 3502 sub->temp_1[1] = b; 3503 if ((b >= 0xc0) && (b <= 0xdf)) { 3504 sub->state = UMIDI_ST_1PARAM; 3505 } else { 3506 sub->state = UMIDI_ST_2PARAM_1; 3507 } 3508 } else { /* b < 0x80 */ 3509 switch (sub->state) { 3510 case UMIDI_ST_1PARAM: 3511 if (sub->temp_1[1] < 0xf0) { 3512 p0 |= sub->temp_1[1] >> 4; 3513 } else { 3514 p0 |= 0x02; 3515 sub->state = UMIDI_ST_UNKNOWN; 3516 } 3517 sub->temp_1[0] = p0; 3518 sub->temp_1[2] = b; 3519 sub->temp_1[3] = 0; 3520 sub->temp_cmd = sub->temp_1; 3521 return (1); 3522 case UMIDI_ST_2PARAM_1: 3523 sub->temp_1[2] = b; 3524 sub->state = UMIDI_ST_2PARAM_2; 3525 break; 3526 case UMIDI_ST_2PARAM_2: 3527 if (sub->temp_1[1] < 0xf0) { 3528 p0 |= sub->temp_1[1] >> 4; 3529 sub->state = UMIDI_ST_2PARAM_1; 3530 } else { 3531 p0 |= 0x03; 3532 sub->state = UMIDI_ST_UNKNOWN; 3533 } 3534 sub->temp_1[0] = p0; 3535 sub->temp_1[3] = b; 3536 sub->temp_cmd = sub->temp_1; 3537 return (1); 3538 case UMIDI_ST_SYSEX_0: 3539 sub->temp_1[1] = b; 3540 sub->state = UMIDI_ST_SYSEX_1; 3541 break; 3542 case UMIDI_ST_SYSEX_1: 3543 sub->temp_1[2] = b; 3544 sub->state = UMIDI_ST_SYSEX_2; 3545 break; 3546 case UMIDI_ST_SYSEX_2: 3547 sub->temp_1[0] = p0 | 0x04; 3548 sub->temp_1[3] = b; 3549 sub->temp_cmd = sub->temp_1; 3550 sub->state = UMIDI_ST_SYSEX_0; 3551 return (1); 3552 default: 3553 break; 3554 } 3555 } 3556 return (0); 3557 } 3558 3559 static void 3560 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 3561 { 3562 struct umidi_chan *chan = usbd_xfer_softc(xfer); 3563 struct umidi_sub_chan *sub; 3564 struct usb_page_cache *pc; 3565 uint32_t actlen; 3566 uint16_t nframes; 3567 uint8_t buf; 3568 uint8_t start_cable; 3569 uint8_t tr_any; 3570 int len; 3571 3572 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 3573 3574 /* 3575 * NOTE: Some MIDI devices only accept 4 bytes of data per 3576 * short terminated USB transfer. 3577 */ 3578 switch (USB_GET_STATE(xfer)) { 3579 case USB_ST_TRANSFERRED: 3580 DPRINTF("actlen=%d bytes\n", len); 3581 3582 case USB_ST_SETUP: 3583 tr_setup: 3584 DPRINTF("start\n"); 3585 3586 nframes = 0; /* reset */ 3587 start_cable = chan->curr_cable; 3588 tr_any = 0; 3589 pc = usbd_xfer_get_frame(xfer, 0); 3590 3591 while (1) { 3592 3593 /* round robin de-queueing */ 3594 3595 sub = &chan->sub[chan->curr_cable]; 3596 3597 if (sub->write_open) { 3598 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX], 3599 &buf, 1, &actlen, 0); 3600 } else { 3601 actlen = 0; 3602 } 3603 3604 if (actlen) { 3605 3606 tr_any = 1; 3607 3608 DPRINTF("byte=0x%02x from FIFO %u\n", buf, 3609 (unsigned int)chan->curr_cable); 3610 3611 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) { 3612 3613 DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n", 3614 sub->temp_cmd[0], sub->temp_cmd[1], 3615 sub->temp_cmd[2], sub->temp_cmd[3]); 3616 3617 usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4); 3618 3619 nframes++; 3620 3621 if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0)) 3622 break; 3623 } else { 3624 continue; 3625 } 3626 } 3627 3628 chan->curr_cable++; 3629 if (chan->curr_cable >= chan->max_cable) 3630 chan->curr_cable = 0; 3631 3632 if (chan->curr_cable == start_cable) { 3633 if (tr_any == 0) 3634 break; 3635 tr_any = 0; 3636 } 3637 } 3638 3639 if (nframes != 0) { 3640 DPRINTF("Transferring %d frames\n", (int)nframes); 3641 usbd_xfer_set_frame_len(xfer, 0, 4 * nframes); 3642 usbd_transfer_submit(xfer); 3643 } 3644 break; 3645 3646 default: /* Error */ 3647 3648 DPRINTF("error=%s\n", usbd_errstr(error)); 3649 3650 if (error != USB_ERR_CANCELLED) { 3651 /* try to clear stall first */ 3652 usbd_xfer_set_stall(xfer); 3653 goto tr_setup; 3654 } 3655 break; 3656 } 3657 } 3658 3659 static struct umidi_sub_chan * 3660 umidi_sub_by_fifo(struct usb_fifo *fifo) 3661 { 3662 struct umidi_chan *chan = usb_fifo_softc(fifo); 3663 struct umidi_sub_chan *sub; 3664 uint32_t n; 3665 3666 for (n = 0; n < UMIDI_CABLES_MAX; n++) { 3667 sub = &chan->sub[n]; 3668 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) || 3669 (sub->fifo.fp[USB_FIFO_TX] == fifo)) { 3670 return (sub); 3671 } 3672 } 3673 3674 panic("%s:%d cannot find usb_fifo!\n", 3675 __FILE__, __LINE__); 3676 3677 return (NULL); 3678 } 3679 3680 static void 3681 umidi_start_read(struct usb_fifo *fifo) 3682 { 3683 struct umidi_chan *chan = usb_fifo_softc(fifo); 3684 3685 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]); 3686 } 3687 3688 static void 3689 umidi_stop_read(struct usb_fifo *fifo) 3690 { 3691 struct umidi_chan *chan = usb_fifo_softc(fifo); 3692 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 3693 3694 DPRINTF("\n"); 3695 3696 sub->read_open = 0; 3697 3698 if (--(chan->read_open_refcount) == 0) { 3699 /* 3700 * XXX don't stop the read transfer here, hence that causes 3701 * problems with some MIDI adapters 3702 */ 3703 DPRINTF("(stopping read transfer)\n"); 3704 } 3705 } 3706 3707 static void 3708 umidi_start_write(struct usb_fifo *fifo) 3709 { 3710 struct umidi_chan *chan = usb_fifo_softc(fifo); 3711 3712 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]); 3713 } 3714 3715 static void 3716 umidi_stop_write(struct usb_fifo *fifo) 3717 { 3718 struct umidi_chan *chan = usb_fifo_softc(fifo); 3719 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 3720 3721 DPRINTF("\n"); 3722 3723 sub->write_open = 0; 3724 3725 if (--(chan->write_open_refcount) == 0) { 3726 DPRINTF("(stopping write transfer)\n"); 3727 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]); 3728 } 3729 } 3730 3731 static int 3732 umidi_open(struct usb_fifo *fifo, int fflags) 3733 { 3734 struct umidi_chan *chan = usb_fifo_softc(fifo); 3735 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 3736 3737 if (fflags & FREAD) { 3738 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) { 3739 return (ENOMEM); 3740 } 3741 mtx_lock(&chan->mtx); 3742 chan->read_open_refcount++; 3743 sub->read_open = 1; 3744 mtx_unlock(&chan->mtx); 3745 } 3746 if (fflags & FWRITE) { 3747 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) { 3748 return (ENOMEM); 3749 } 3750 /* clear stall first */ 3751 mtx_lock(&chan->mtx); 3752 usbd_xfer_set_stall(chan->xfer[UMIDI_TX_TRANSFER]); 3753 chan->write_open_refcount++; 3754 sub->write_open = 1; 3755 3756 /* reset */ 3757 sub->state = UMIDI_ST_UNKNOWN; 3758 mtx_unlock(&chan->mtx); 3759 } 3760 return (0); /* success */ 3761 } 3762 3763 static void 3764 umidi_close(struct usb_fifo *fifo, int fflags) 3765 { 3766 if (fflags & FREAD) { 3767 usb_fifo_free_buffer(fifo); 3768 } 3769 if (fflags & FWRITE) { 3770 usb_fifo_free_buffer(fifo); 3771 } 3772 } 3773 3774 3775 static int 3776 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data, 3777 int fflags) 3778 { 3779 return (ENODEV); 3780 } 3781 3782 static void 3783 umidi_init(device_t dev) 3784 { 3785 struct uaudio_softc *sc = device_get_softc(dev); 3786 struct umidi_chan *chan = &sc->sc_midi_chan; 3787 3788 mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE); 3789 } 3790 3791 static struct usb_fifo_methods umidi_fifo_methods = { 3792 .f_start_read = &umidi_start_read, 3793 .f_start_write = &umidi_start_write, 3794 .f_stop_read = &umidi_stop_read, 3795 .f_stop_write = &umidi_stop_write, 3796 .f_open = &umidi_open, 3797 .f_close = &umidi_close, 3798 .f_ioctl = &umidi_ioctl, 3799 .basename[0] = "umidi", 3800 }; 3801 3802 static int 3803 umidi_probe(device_t dev) 3804 { 3805 struct uaudio_softc *sc = device_get_softc(dev); 3806 struct usb_attach_arg *uaa = device_get_ivars(dev); 3807 struct umidi_chan *chan = &sc->sc_midi_chan; 3808 struct umidi_sub_chan *sub; 3809 int unit = device_get_unit(dev); 3810 int error; 3811 uint32_t n; 3812 3813 if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI)) 3814 chan->single_command = 1; 3815 3816 if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index, 3817 chan->iface_alt_index)) { 3818 DPRINTF("setting of alternate index failed!\n"); 3819 goto detach; 3820 } 3821 usbd_set_parent_iface(sc->sc_udev, chan->iface_index, 3822 sc->sc_mixer_iface_index); 3823 3824 error = usbd_transfer_setup(uaa->device, &chan->iface_index, 3825 chan->xfer, umidi_config, UMIDI_N_TRANSFER, 3826 chan, &chan->mtx); 3827 if (error) { 3828 DPRINTF("error=%s\n", usbd_errstr(error)); 3829 goto detach; 3830 } 3831 if ((chan->max_cable > UMIDI_CABLES_MAX) || 3832 (chan->max_cable == 0)) { 3833 chan->max_cable = UMIDI_CABLES_MAX; 3834 } 3835 3836 for (n = 0; n < chan->max_cable; n++) { 3837 3838 sub = &chan->sub[n]; 3839 3840 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx, 3841 &umidi_fifo_methods, &sub->fifo, unit, n, 3842 chan->iface_index, 3843 UID_ROOT, GID_OPERATOR, 0644); 3844 if (error) { 3845 goto detach; 3846 } 3847 } 3848 3849 mtx_lock(&chan->mtx); 3850 3851 /* clear stall first */ 3852 usbd_xfer_set_stall(chan->xfer[UMIDI_RX_TRANSFER]); 3853 3854 /* 3855 * NOTE: At least one device will not work properly unless the 3856 * BULK IN pipe is open all the time. This might have to do 3857 * about that the internal queues of the device overflow if we 3858 * don't read them regularly. 3859 */ 3860 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]); 3861 3862 mtx_unlock(&chan->mtx); 3863 3864 return (0); /* success */ 3865 3866 detach: 3867 return (ENXIO); /* failure */ 3868 } 3869 3870 static int 3871 umidi_detach(device_t dev) 3872 { 3873 struct uaudio_softc *sc = device_get_softc(dev); 3874 struct umidi_chan *chan = &sc->sc_midi_chan; 3875 uint32_t n; 3876 3877 for (n = 0; n < UMIDI_CABLES_MAX; n++) { 3878 usb_fifo_detach(&chan->sub[n].fifo); 3879 } 3880 3881 mtx_lock(&chan->mtx); 3882 3883 usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]); 3884 3885 mtx_unlock(&chan->mtx); 3886 3887 usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER); 3888 3889 mtx_destroy(&chan->mtx); 3890 3891 return (0); 3892 } 3893 3894 DRIVER_MODULE(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0); 3895 MODULE_DEPEND(uaudio, usb, 1, 1, 1); 3896 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 3897 MODULE_VERSION(uaudio, 1); 3898