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