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