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