1 /* $NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $ */ 2 /* $FreeBSD$ */ 3 4 /*- 5 * SPDX-License-Identifier: BSD-2-Clause-NetBSD 6 * 7 * Copyright (c) 1999 The NetBSD Foundation, Inc. 8 * All rights reserved. 9 * 10 * This code is derived from software contributed to The NetBSD Foundation 11 * by Lennart Augustsson (lennart@augustsson.net) at 12 * Carlstedt Research & Technology. 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions 16 * are met: 17 * 1. Redistributions of source code must retain the above copyright 18 * notice, this list of conditions and the following disclaimer. 19 * 2. Redistributions in binary form must reproduce the above copyright 20 * notice, this list of conditions and the following disclaimer in the 21 * documentation and/or other materials provided with the distribution. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 24 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 27 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 /* 40 * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf 41 * http://www.usb.org/developers/devclass_docs/frmts10.pdf 42 * http://www.usb.org/developers/devclass_docs/termt10.pdf 43 */ 44 45 /* 46 * Also merged: 47 * $NetBSD: uaudio.c,v 1.94 2005/01/15 15:19:53 kent Exp $ 48 * $NetBSD: uaudio.c,v 1.95 2005/01/16 06:02:19 dsainty Exp $ 49 * $NetBSD: uaudio.c,v 1.96 2005/01/16 12:46:00 kent Exp $ 50 * $NetBSD: uaudio.c,v 1.97 2005/02/24 08:19:38 martin Exp $ 51 */ 52 53 #include <sys/stdint.h> 54 #include <sys/stddef.h> 55 #include <sys/param.h> 56 #include <sys/queue.h> 57 #include <sys/types.h> 58 #include <sys/systm.h> 59 #include <sys/kernel.h> 60 #include <sys/bus.h> 61 #include <sys/module.h> 62 #include <sys/lock.h> 63 #include <sys/mutex.h> 64 #include <sys/condvar.h> 65 #include <sys/sysctl.h> 66 #include <sys/sx.h> 67 #include <sys/unistd.h> 68 #include <sys/callout.h> 69 #include <sys/malloc.h> 70 #include <sys/priv.h> 71 72 #include "usbdevs.h" 73 #include <dev/usb/usb.h> 74 #include <dev/usb/usbdi.h> 75 #include <dev/usb/usbdi_util.h> 76 #include <dev/usb/usbhid.h> 77 #include <dev/usb/usb_request.h> 78 #include <dev/usb/usb_process.h> 79 80 #define USB_DEBUG_VAR uaudio_debug 81 #include <dev/usb/usb_debug.h> 82 83 #include <dev/usb/quirk/usb_quirk.h> 84 85 #include <sys/reboot.h> /* for bootverbose */ 86 87 #ifdef HAVE_KERNEL_OPTION_HEADERS 88 #include "opt_snd.h" 89 #endif 90 91 #include <dev/sound/pcm/sound.h> 92 #include <dev/sound/usb/uaudioreg.h> 93 #include <dev/sound/usb/uaudio.h> 94 #include <dev/sound/chip.h> 95 #include "feeder_if.h" 96 97 static int uaudio_default_rate = 0; /* use rate list */ 98 static int uaudio_default_bits = 32; 99 static int uaudio_default_channels = 0; /* use default */ 100 static int uaudio_buffer_ms = 8; 101 102 #ifdef USB_DEBUG 103 static int uaudio_debug; 104 105 static SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 106 "USB uaudio"); 107 108 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RWTUN, 109 &uaudio_debug, 0, "uaudio debug level"); 110 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_rate, CTLFLAG_RWTUN, 111 &uaudio_default_rate, 0, "uaudio default sample rate"); 112 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_bits, CTLFLAG_RWTUN, 113 &uaudio_default_bits, 0, "uaudio default sample bits"); 114 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_channels, CTLFLAG_RWTUN, 115 &uaudio_default_channels, 0, "uaudio default sample channels"); 116 117 static int 118 uaudio_buffer_ms_sysctl(SYSCTL_HANDLER_ARGS) 119 { 120 int err, val; 121 122 val = uaudio_buffer_ms; 123 err = sysctl_handle_int(oidp, &val, 0, req); 124 125 if (err != 0 || req->newptr == NULL || val == uaudio_buffer_ms) 126 return (err); 127 128 if (val > 8) 129 val = 8; 130 else if (val < 2) 131 val = 2; 132 133 uaudio_buffer_ms = val; 134 135 return (0); 136 } 137 SYSCTL_PROC(_hw_usb_uaudio, OID_AUTO, buffer_ms, 138 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0, sizeof(int), 139 uaudio_buffer_ms_sysctl, "I", 140 "uaudio buffering delay from 2ms to 8ms"); 141 #else 142 #define uaudio_debug 0 143 #endif 144 145 #define UAUDIO_NFRAMES 64 /* must be factor of 8 due HS-USB */ 146 #define UAUDIO_NCHANBUFS 2 /* number of outstanding request */ 147 #define UAUDIO_RECURSE_LIMIT 255 /* rounds */ 148 #define UAUDIO_CHANNELS_MAX MIN(64, AFMT_CHANNEL_MAX) 149 #define UAUDIO_MATRIX_MAX 8 /* channels */ 150 151 #define MAKE_WORD(h,l) (((h) << 8) | (l)) 152 #define BIT_TEST(bm,bno) (((bm)[(bno) / 8] >> (7 - ((bno) % 8))) & 1) 153 #define UAUDIO_MAX_CHAN(x) (x) 154 #define MIX(sc) ((sc)->sc_mixer_node) 155 156 union uaudio_asid { 157 const struct usb_audio_streaming_interface_descriptor *v1; 158 const struct usb_audio20_streaming_interface_descriptor *v2; 159 }; 160 161 union uaudio_asf1d { 162 const struct usb_audio_streaming_type1_descriptor *v1; 163 const struct usb_audio20_streaming_type1_descriptor *v2; 164 }; 165 166 union uaudio_sed { 167 const struct usb_audio_streaming_endpoint_descriptor *v1; 168 const struct usb_audio20_streaming_endpoint_descriptor *v2; 169 }; 170 171 struct uaudio_mixer_node { 172 const char *name; 173 174 int32_t minval; 175 int32_t maxval; 176 #define MIX_MAX_CHAN 16 177 int32_t wValue[MIX_MAX_CHAN]; /* using nchan */ 178 uint32_t mul; 179 uint32_t ctl; 180 181 int wData[MIX_MAX_CHAN]; /* using nchan */ 182 uint16_t wIndex; 183 184 uint8_t update[(MIX_MAX_CHAN + 7) / 8]; 185 uint8_t nchan; 186 uint8_t type; 187 #define MIX_ON_OFF 1 188 #define MIX_SIGNED_16 2 189 #define MIX_UNSIGNED_16 3 190 #define MIX_SIGNED_8 4 191 #define MIX_SELECTOR 5 192 #define MIX_UNKNOWN 6 193 #define MIX_SIZE(n) ((((n) == MIX_SIGNED_16) || \ 194 ((n) == MIX_UNSIGNED_16)) ? 2 : 1) 195 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16) 196 197 #define MAX_SELECTOR_INPUT_PIN 256 198 uint8_t slctrtype[MAX_SELECTOR_INPUT_PIN]; 199 uint8_t val_default; 200 201 uint8_t desc[64]; 202 203 struct uaudio_mixer_node *next; 204 }; 205 206 struct uaudio_configure_msg { 207 struct usb_proc_msg hdr; 208 struct uaudio_softc *sc; 209 }; 210 211 #define CHAN_MAX_ALT 24 212 213 struct uaudio_chan_alt { 214 union uaudio_asf1d p_asf1d; 215 union uaudio_sed p_sed; 216 const usb_endpoint_descriptor_audio_t *p_ed1; 217 const struct uaudio_format *p_fmt; 218 const struct usb_config *usb_cfg; 219 uint32_t sample_rate; /* in Hz */ 220 uint16_t sample_size; 221 uint8_t iface_index; 222 uint8_t iface_alt_index; 223 uint8_t channels; 224 }; 225 226 struct uaudio_chan { 227 struct pcmchan_caps pcm_cap; /* capabilities */ 228 struct uaudio_chan_alt usb_alt[CHAN_MAX_ALT]; 229 struct snd_dbuf *pcm_buf; 230 struct mtx *pcm_mtx; /* lock protecting this structure */ 231 struct uaudio_softc *priv_sc; 232 struct pcm_channel *pcm_ch; 233 struct usb_xfer *xfer[UAUDIO_NCHANBUFS + 1]; 234 235 uint8_t *buf; /* pointer to buffer */ 236 uint8_t *start; /* upper layer buffer start */ 237 uint8_t *end; /* upper layer buffer end */ 238 uint8_t *cur; /* current position in upper layer 239 * buffer */ 240 241 uint32_t intr_frames; /* in units */ 242 uint32_t frames_per_second; 243 uint32_t sample_rem; 244 uint32_t sample_curr; 245 uint32_t max_buf; 246 int32_t jitter_rem; 247 int32_t jitter_curr; 248 249 int feedback_rate; 250 251 uint32_t pcm_format[2]; 252 253 uint16_t bytes_per_frame[2]; 254 255 uint32_t intr_counter; 256 uint32_t running; 257 uint32_t num_alt; 258 uint32_t cur_alt; 259 uint32_t set_alt; 260 uint32_t operation; 261 #define CHAN_OP_NONE 0 262 #define CHAN_OP_START 1 263 #define CHAN_OP_STOP 2 264 #define CHAN_OP_DRAIN 3 265 }; 266 267 #define UMIDI_EMB_JACK_MAX 16 /* units */ 268 #define UMIDI_TX_FRAMES 256 /* units */ 269 #define UMIDI_TX_BUFFER (UMIDI_TX_FRAMES * 4) /* bytes */ 270 271 enum { 272 UMIDI_TX_TRANSFER, 273 UMIDI_RX_TRANSFER, 274 UMIDI_N_TRANSFER, 275 }; 276 277 struct umidi_sub_chan { 278 struct usb_fifo_sc fifo; 279 uint8_t *temp_cmd; 280 uint8_t temp_0[4]; 281 uint8_t temp_1[4]; 282 uint8_t state; 283 #define UMIDI_ST_UNKNOWN 0 /* scan for command */ 284 #define UMIDI_ST_1PARAM 1 285 #define UMIDI_ST_2PARAM_1 2 286 #define UMIDI_ST_2PARAM_2 3 287 #define UMIDI_ST_SYSEX_0 4 288 #define UMIDI_ST_SYSEX_1 5 289 #define UMIDI_ST_SYSEX_2 6 290 291 uint8_t read_open:1; 292 uint8_t write_open:1; 293 uint8_t unused:6; 294 }; 295 296 struct umidi_chan { 297 298 struct umidi_sub_chan sub[UMIDI_EMB_JACK_MAX]; 299 struct mtx mtx; 300 301 struct usb_xfer *xfer[UMIDI_N_TRANSFER]; 302 303 uint8_t iface_index; 304 uint8_t iface_alt_index; 305 306 uint8_t read_open_refcount; 307 uint8_t write_open_refcount; 308 309 uint8_t curr_cable; 310 uint8_t max_emb_jack; 311 uint8_t valid; 312 uint8_t single_command; 313 }; 314 315 struct uaudio_search_result { 316 uint8_t bit_input[(256 + 7) / 8]; 317 uint8_t bit_output[(256 + 7) / 8]; 318 uint8_t recurse_level; 319 uint8_t id_max; 320 uint8_t is_input; 321 }; 322 323 enum { 324 UAUDIO_HID_RX_TRANSFER, 325 UAUDIO_HID_N_TRANSFER, 326 }; 327 328 struct uaudio_hid { 329 struct usb_xfer *xfer[UAUDIO_HID_N_TRANSFER]; 330 struct hid_location volume_up_loc; 331 struct hid_location volume_down_loc; 332 struct hid_location mute_loc; 333 uint32_t flags; 334 #define UAUDIO_HID_VALID 0x0001 335 #define UAUDIO_HID_HAS_ID 0x0002 336 #define UAUDIO_HID_HAS_VOLUME_UP 0x0004 337 #define UAUDIO_HID_HAS_VOLUME_DOWN 0x0008 338 #define UAUDIO_HID_HAS_MUTE 0x0010 339 uint8_t iface_index; 340 uint8_t volume_up_id; 341 uint8_t volume_down_id; 342 uint8_t mute_id; 343 }; 344 345 #define UAUDIO_SPDIF_OUT 0x01 /* Enable S/PDIF output */ 346 #define UAUDIO_SPDIF_OUT_48K 0x02 /* Out sample rate = 48K */ 347 #define UAUDIO_SPDIF_OUT_96K 0x04 /* Out sample rate = 96K */ 348 #define UAUDIO_SPDIF_IN_MIX 0x10 /* Input mix enable */ 349 350 struct uaudio_softc { 351 struct sbuf sc_sndstat; 352 struct sndcard_func sc_sndcard_func; 353 struct uaudio_chan sc_rec_chan; 354 struct uaudio_chan sc_play_chan; 355 struct umidi_chan sc_midi_chan; 356 struct uaudio_hid sc_hid; 357 struct uaudio_search_result sc_mixer_clocks; 358 struct uaudio_mixer_node sc_mixer_node; 359 struct uaudio_configure_msg sc_config_msg[2]; 360 361 struct mtx *sc_mixer_lock; 362 struct snd_mixer *sc_mixer_dev; 363 struct usb_device *sc_udev; 364 struct usb_xfer *sc_mixer_xfer[1]; 365 struct uaudio_mixer_node *sc_mixer_root; 366 struct uaudio_mixer_node *sc_mixer_curr; 367 int (*sc_set_spdif_fn) (struct uaudio_softc *, int); 368 369 uint32_t sc_mix_info; 370 uint32_t sc_recsrc_info; 371 372 uint16_t sc_audio_rev; 373 uint16_t sc_mixer_count; 374 375 uint8_t sc_sndstat_valid; 376 uint8_t sc_mixer_iface_index; 377 uint8_t sc_mixer_iface_no; 378 uint8_t sc_mixer_chan; 379 uint8_t sc_pcm_registered:1; 380 uint8_t sc_mixer_init:1; 381 uint8_t sc_uq_audio_swap_lr:1; 382 uint8_t sc_uq_au_inp_async:1; 383 uint8_t sc_uq_au_no_xu:1; 384 uint8_t sc_uq_bad_adc:1; 385 uint8_t sc_uq_au_vendor_class:1; 386 uint8_t sc_pcm_bitperfect:1; 387 }; 388 389 struct uaudio_terminal_node { 390 union { 391 const struct usb_descriptor *desc; 392 const struct usb_audio_input_terminal *it_v1; 393 const struct usb_audio_output_terminal *ot_v1; 394 const struct usb_audio_mixer_unit_0 *mu_v1; 395 const struct usb_audio_selector_unit *su_v1; 396 const struct usb_audio_feature_unit *fu_v1; 397 const struct usb_audio_processing_unit_0 *pu_v1; 398 const struct usb_audio_extension_unit_0 *eu_v1; 399 const struct usb_audio20_clock_source_unit *csrc_v2; 400 const struct usb_audio20_clock_selector_unit_0 *csel_v2; 401 const struct usb_audio20_clock_multiplier_unit *cmul_v2; 402 const struct usb_audio20_input_terminal *it_v2; 403 const struct usb_audio20_output_terminal *ot_v2; 404 const struct usb_audio20_mixer_unit_0 *mu_v2; 405 const struct usb_audio20_selector_unit *su_v2; 406 const struct usb_audio20_feature_unit *fu_v2; 407 const struct usb_audio20_sample_rate_unit *ru_v2; 408 const struct usb_audio20_processing_unit_0 *pu_v2; 409 const struct usb_audio20_extension_unit_0 *eu_v2; 410 const struct usb_audio20_effect_unit *ef_v2; 411 } u; 412 struct uaudio_search_result usr; 413 struct uaudio_terminal_node *root; 414 }; 415 416 struct uaudio_format { 417 uint16_t wFormat; 418 uint8_t bPrecision; 419 uint32_t freebsd_fmt; 420 const char *description; 421 }; 422 423 static const struct uaudio_format uaudio10_formats[] = { 424 425 {UA_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"}, 426 {UA_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"}, 427 {UA_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"}, 428 {UA_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"}, 429 430 {UA_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"}, 431 {UA_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"}, 432 {UA_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"}, 433 {UA_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"}, 434 435 {UA_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"}, 436 {UA_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"}, 437 438 {0, 0, 0, NULL} 439 }; 440 441 static const struct uaudio_format uaudio20_formats[] = { 442 443 {UA20_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"}, 444 {UA20_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"}, 445 {UA20_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"}, 446 {UA20_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"}, 447 448 {UA20_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"}, 449 {UA20_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"}, 450 {UA20_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"}, 451 {UA20_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"}, 452 453 {UA20_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"}, 454 {UA20_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"}, 455 456 {0, 0, 0, NULL} 457 }; 458 459 /* prototypes */ 460 461 static device_probe_t uaudio_probe; 462 static device_attach_t uaudio_attach; 463 static device_detach_t uaudio_detach; 464 465 static usb_callback_t uaudio_chan_play_callback; 466 static usb_callback_t uaudio_chan_play_sync_callback; 467 static usb_callback_t uaudio_chan_record_callback; 468 static usb_callback_t uaudio_chan_record_sync_callback; 469 static usb_callback_t uaudio_mixer_write_cfg_callback; 470 static usb_callback_t umidi_bulk_read_callback; 471 static usb_callback_t umidi_bulk_write_callback; 472 static usb_callback_t uaudio_hid_rx_callback; 473 474 static usb_proc_callback_t uaudio_configure_msg; 475 476 /* ==== USB mixer ==== */ 477 478 static int uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS); 479 static void uaudio_mixer_ctl_free(struct uaudio_softc *); 480 static void uaudio_mixer_register_sysctl(struct uaudio_softc *, device_t); 481 static void uaudio_mixer_reload_all(struct uaudio_softc *); 482 static void uaudio_mixer_controls_create_ftu(struct uaudio_softc *); 483 484 /* ==== USB audio v1.0 ==== */ 485 486 static void uaudio_mixer_add_mixer(struct uaudio_softc *, 487 const struct uaudio_terminal_node *, int); 488 static void uaudio_mixer_add_selector(struct uaudio_softc *, 489 const struct uaudio_terminal_node *, int); 490 static uint32_t uaudio_mixer_feature_get_bmaControls( 491 const struct usb_audio_feature_unit *, uint8_t); 492 static void uaudio_mixer_add_feature(struct uaudio_softc *, 493 const struct uaudio_terminal_node *, int); 494 static void uaudio_mixer_add_processing_updown(struct uaudio_softc *, 495 const struct uaudio_terminal_node *, int); 496 static void uaudio_mixer_add_processing(struct uaudio_softc *, 497 const struct uaudio_terminal_node *, int); 498 static void uaudio_mixer_add_extension(struct uaudio_softc *, 499 const struct uaudio_terminal_node *, int); 500 static struct usb_audio_cluster uaudio_mixer_get_cluster(uint8_t, 501 const struct uaudio_terminal_node *); 502 static uint16_t uaudio_mixer_determine_class(const struct uaudio_terminal_node *); 503 static void uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *, 504 const uint8_t *, uint8_t, struct uaudio_search_result *); 505 static const void *uaudio_mixer_verify_desc(const void *, uint32_t); 506 static usb_error_t uaudio_set_speed(struct usb_device *, uint8_t, uint32_t); 507 static int uaudio_mixer_get(struct usb_device *, uint16_t, uint8_t, 508 struct uaudio_mixer_node *); 509 510 /* ==== USB audio v2.0 ==== */ 511 512 static void uaudio20_mixer_add_mixer(struct uaudio_softc *, 513 const struct uaudio_terminal_node *, int); 514 static void uaudio20_mixer_add_selector(struct uaudio_softc *, 515 const struct uaudio_terminal_node *, int); 516 static void uaudio20_mixer_add_feature(struct uaudio_softc *, 517 const struct uaudio_terminal_node *, int); 518 static struct usb_audio20_cluster uaudio20_mixer_get_cluster(uint8_t, 519 const struct uaudio_terminal_node *); 520 static uint16_t uaudio20_mixer_determine_class(const struct uaudio_terminal_node *); 521 static void uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *, 522 const uint8_t *, uint8_t, struct uaudio_search_result *); 523 static const void *uaudio20_mixer_verify_desc(const void *, uint32_t); 524 static usb_error_t uaudio20_set_speed(struct usb_device *, uint8_t, 525 uint8_t, uint32_t); 526 527 /* USB audio v1.0 and v2.0 */ 528 529 static void uaudio_chan_fill_info_sub(struct uaudio_softc *, 530 struct usb_device *, uint32_t, uint8_t, uint8_t); 531 static void uaudio_chan_fill_info(struct uaudio_softc *, 532 struct usb_device *); 533 static void uaudio_mixer_add_ctl_sub(struct uaudio_softc *, 534 struct uaudio_mixer_node *); 535 static void uaudio_mixer_add_ctl(struct uaudio_softc *, 536 struct uaudio_mixer_node *); 537 static void uaudio_mixer_fill_info(struct uaudio_softc *, 538 struct usb_device *, void *); 539 static int uaudio_mixer_signext(uint8_t, int); 540 static void uaudio_mixer_init(struct uaudio_softc *); 541 static uint8_t umidi_convert_to_usb(struct umidi_sub_chan *, uint8_t, uint8_t); 542 static struct umidi_sub_chan *umidi_sub_by_fifo(struct usb_fifo *); 543 static void umidi_start_read(struct usb_fifo *); 544 static void umidi_stop_read(struct usb_fifo *); 545 static void umidi_start_write(struct usb_fifo *); 546 static void umidi_stop_write(struct usb_fifo *); 547 static int umidi_open(struct usb_fifo *, int); 548 static int umidi_ioctl(struct usb_fifo *, u_long cmd, void *, int); 549 static void umidi_close(struct usb_fifo *, int); 550 static void umidi_init(device_t dev); 551 static int umidi_probe(device_t dev); 552 static int umidi_detach(device_t dev); 553 static int uaudio_hid_probe(struct uaudio_softc *sc, 554 struct usb_attach_arg *uaa); 555 static void uaudio_hid_detach(struct uaudio_softc *sc); 556 557 #ifdef USB_DEBUG 558 static void uaudio_chan_dump_ep_desc( 559 const usb_endpoint_descriptor_audio_t *); 560 #endif 561 562 static const struct usb_config 563 uaudio_cfg_record[UAUDIO_NCHANBUFS + 1] = { 564 [0] = { 565 .type = UE_ISOCHRONOUS, 566 .endpoint = UE_ADDR_ANY, 567 .direction = UE_DIR_IN, 568 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 569 .frames = UAUDIO_NFRAMES, 570 .flags = {.short_xfer_ok = 1,}, 571 .callback = &uaudio_chan_record_callback, 572 }, 573 574 [1] = { 575 .type = UE_ISOCHRONOUS, 576 .endpoint = UE_ADDR_ANY, 577 .direction = UE_DIR_IN, 578 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 579 .frames = UAUDIO_NFRAMES, 580 .flags = {.short_xfer_ok = 1,}, 581 .callback = &uaudio_chan_record_callback, 582 }, 583 584 [2] = { 585 .type = UE_ISOCHRONOUS, 586 .endpoint = UE_ADDR_ANY, 587 .direction = UE_DIR_OUT, 588 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 589 .frames = 1, 590 .flags = {.no_pipe_ok = 1,.short_xfer_ok = 1,}, 591 .callback = &uaudio_chan_record_sync_callback, 592 }, 593 }; 594 595 static const struct usb_config 596 uaudio_cfg_play[UAUDIO_NCHANBUFS + 1] = { 597 [0] = { 598 .type = UE_ISOCHRONOUS, 599 .endpoint = UE_ADDR_ANY, 600 .direction = UE_DIR_OUT, 601 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 602 .frames = UAUDIO_NFRAMES, 603 .flags = {.short_xfer_ok = 1,}, 604 .callback = &uaudio_chan_play_callback, 605 }, 606 607 [1] = { 608 .type = UE_ISOCHRONOUS, 609 .endpoint = UE_ADDR_ANY, 610 .direction = UE_DIR_OUT, 611 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 612 .frames = UAUDIO_NFRAMES, 613 .flags = {.short_xfer_ok = 1,}, 614 .callback = &uaudio_chan_play_callback, 615 }, 616 617 [2] = { 618 .type = UE_ISOCHRONOUS, 619 .endpoint = UE_ADDR_ANY, 620 .direction = UE_DIR_IN, 621 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 622 .frames = 1, 623 .flags = {.no_pipe_ok = 1,.short_xfer_ok = 1,}, 624 .callback = &uaudio_chan_play_sync_callback, 625 }, 626 }; 627 628 static const struct usb_config 629 uaudio_mixer_config[1] = { 630 [0] = { 631 .type = UE_CONTROL, 632 .endpoint = 0x00, /* Control pipe */ 633 .direction = UE_DIR_ANY, 634 .bufsize = (sizeof(struct usb_device_request) + 4), 635 .callback = &uaudio_mixer_write_cfg_callback, 636 .timeout = 1000, /* 1 second */ 637 }, 638 }; 639 640 static const 641 uint8_t umidi_cmd_to_len[16] = { 642 [0x0] = 0, /* reserved */ 643 [0x1] = 0, /* reserved */ 644 [0x2] = 2, /* bytes */ 645 [0x3] = 3, /* bytes */ 646 [0x4] = 3, /* bytes */ 647 [0x5] = 1, /* bytes */ 648 [0x6] = 2, /* bytes */ 649 [0x7] = 3, /* bytes */ 650 [0x8] = 3, /* bytes */ 651 [0x9] = 3, /* bytes */ 652 [0xA] = 3, /* bytes */ 653 [0xB] = 3, /* bytes */ 654 [0xC] = 2, /* bytes */ 655 [0xD] = 2, /* bytes */ 656 [0xE] = 3, /* bytes */ 657 [0xF] = 1, /* bytes */ 658 }; 659 660 static const struct usb_config 661 umidi_config[UMIDI_N_TRANSFER] = { 662 [UMIDI_TX_TRANSFER] = { 663 .type = UE_BULK, 664 .endpoint = UE_ADDR_ANY, 665 .direction = UE_DIR_OUT, 666 .bufsize = UMIDI_TX_BUFFER, 667 .flags = {.no_pipe_ok = 1}, 668 .callback = &umidi_bulk_write_callback, 669 }, 670 671 [UMIDI_RX_TRANSFER] = { 672 .type = UE_BULK, 673 .endpoint = UE_ADDR_ANY, 674 .direction = UE_DIR_IN, 675 .bufsize = 4, /* bytes */ 676 .flags = {.short_xfer_ok = 1,.proxy_buffer = 1,.no_pipe_ok = 1}, 677 .callback = &umidi_bulk_read_callback, 678 }, 679 }; 680 681 static const struct usb_config 682 uaudio_hid_config[UAUDIO_HID_N_TRANSFER] = { 683 [UAUDIO_HID_RX_TRANSFER] = { 684 .type = UE_INTERRUPT, 685 .endpoint = UE_ADDR_ANY, 686 .direction = UE_DIR_IN, 687 .bufsize = 0, /* use wMaxPacketSize */ 688 .flags = {.short_xfer_ok = 1,}, 689 .callback = &uaudio_hid_rx_callback, 690 }, 691 }; 692 693 static devclass_t uaudio_devclass; 694 695 static device_method_t uaudio_methods[] = { 696 DEVMETHOD(device_probe, uaudio_probe), 697 DEVMETHOD(device_attach, uaudio_attach), 698 DEVMETHOD(device_detach, uaudio_detach), 699 DEVMETHOD(device_suspend, bus_generic_suspend), 700 DEVMETHOD(device_resume, bus_generic_resume), 701 DEVMETHOD(device_shutdown, bus_generic_shutdown), 702 703 DEVMETHOD_END 704 }; 705 706 static driver_t uaudio_driver = { 707 .name = "uaudio", 708 .methods = uaudio_methods, 709 .size = sizeof(struct uaudio_softc), 710 }; 711 712 /* The following table is derived from Linux's quirks-table.h */ 713 static const STRUCT_USB_HOST_ID uaudio_vendor_midi[] = { 714 { USB_VPI(USB_VENDOR_YAMAHA, 0x1000, 0) }, /* UX256 */ 715 { USB_VPI(USB_VENDOR_YAMAHA, 0x1001, 0) }, /* MU1000 */ 716 { USB_VPI(USB_VENDOR_YAMAHA, 0x1002, 0) }, /* MU2000 */ 717 { USB_VPI(USB_VENDOR_YAMAHA, 0x1003, 0) }, /* MU500 */ 718 { USB_VPI(USB_VENDOR_YAMAHA, 0x1004, 3) }, /* UW500 */ 719 { USB_VPI(USB_VENDOR_YAMAHA, 0x1005, 0) }, /* MOTIF6 */ 720 { USB_VPI(USB_VENDOR_YAMAHA, 0x1006, 0) }, /* MOTIF7 */ 721 { USB_VPI(USB_VENDOR_YAMAHA, 0x1007, 0) }, /* MOTIF8 */ 722 { USB_VPI(USB_VENDOR_YAMAHA, 0x1008, 0) }, /* UX96 */ 723 { USB_VPI(USB_VENDOR_YAMAHA, 0x1009, 0) }, /* UX16 */ 724 { USB_VPI(USB_VENDOR_YAMAHA, 0x100a, 3) }, /* EOS BX */ 725 { USB_VPI(USB_VENDOR_YAMAHA, 0x100c, 0) }, /* UC-MX */ 726 { USB_VPI(USB_VENDOR_YAMAHA, 0x100d, 0) }, /* UC-KX */ 727 { USB_VPI(USB_VENDOR_YAMAHA, 0x100e, 0) }, /* S08 */ 728 { USB_VPI(USB_VENDOR_YAMAHA, 0x100f, 0) }, /* CLP-150 */ 729 { USB_VPI(USB_VENDOR_YAMAHA, 0x1010, 0) }, /* CLP-170 */ 730 { USB_VPI(USB_VENDOR_YAMAHA, 0x1011, 0) }, /* P-250 */ 731 { USB_VPI(USB_VENDOR_YAMAHA, 0x1012, 0) }, /* TYROS */ 732 { USB_VPI(USB_VENDOR_YAMAHA, 0x1013, 0) }, /* PF-500 */ 733 { USB_VPI(USB_VENDOR_YAMAHA, 0x1014, 0) }, /* S90 */ 734 { USB_VPI(USB_VENDOR_YAMAHA, 0x1015, 0) }, /* MOTIF-R */ 735 { USB_VPI(USB_VENDOR_YAMAHA, 0x1016, 0) }, /* MDP-5 */ 736 { USB_VPI(USB_VENDOR_YAMAHA, 0x1017, 0) }, /* CVP-204 */ 737 { USB_VPI(USB_VENDOR_YAMAHA, 0x1018, 0) }, /* CVP-206 */ 738 { USB_VPI(USB_VENDOR_YAMAHA, 0x1019, 0) }, /* CVP-208 */ 739 { USB_VPI(USB_VENDOR_YAMAHA, 0x101a, 0) }, /* CVP-210 */ 740 { USB_VPI(USB_VENDOR_YAMAHA, 0x101b, 0) }, /* PSR-1100 */ 741 { USB_VPI(USB_VENDOR_YAMAHA, 0x101c, 0) }, /* PSR-2100 */ 742 { USB_VPI(USB_VENDOR_YAMAHA, 0x101d, 0) }, /* CLP-175 */ 743 { USB_VPI(USB_VENDOR_YAMAHA, 0x101e, 0) }, /* PSR-K1 */ 744 { USB_VPI(USB_VENDOR_YAMAHA, 0x101f, 0) }, /* EZ-J24 */ 745 { USB_VPI(USB_VENDOR_YAMAHA, 0x1020, 0) }, /* EZ-250i */ 746 { USB_VPI(USB_VENDOR_YAMAHA, 0x1021, 0) }, /* MOTIF ES 6 */ 747 { USB_VPI(USB_VENDOR_YAMAHA, 0x1022, 0) }, /* MOTIF ES 7 */ 748 { USB_VPI(USB_VENDOR_YAMAHA, 0x1023, 0) }, /* MOTIF ES 8 */ 749 { USB_VPI(USB_VENDOR_YAMAHA, 0x1024, 0) }, /* CVP-301 */ 750 { USB_VPI(USB_VENDOR_YAMAHA, 0x1025, 0) }, /* CVP-303 */ 751 { USB_VPI(USB_VENDOR_YAMAHA, 0x1026, 0) }, /* CVP-305 */ 752 { USB_VPI(USB_VENDOR_YAMAHA, 0x1027, 0) }, /* CVP-307 */ 753 { USB_VPI(USB_VENDOR_YAMAHA, 0x1028, 0) }, /* CVP-309 */ 754 { USB_VPI(USB_VENDOR_YAMAHA, 0x1029, 0) }, /* CVP-309GP */ 755 { USB_VPI(USB_VENDOR_YAMAHA, 0x102a, 0) }, /* PSR-1500 */ 756 { USB_VPI(USB_VENDOR_YAMAHA, 0x102b, 0) }, /* PSR-3000 */ 757 { USB_VPI(USB_VENDOR_YAMAHA, 0x102e, 0) }, /* ELS-01/01C */ 758 { USB_VPI(USB_VENDOR_YAMAHA, 0x1030, 0) }, /* PSR-295/293 */ 759 { USB_VPI(USB_VENDOR_YAMAHA, 0x1031, 0) }, /* DGX-205/203 */ 760 { USB_VPI(USB_VENDOR_YAMAHA, 0x1032, 0) }, /* DGX-305 */ 761 { USB_VPI(USB_VENDOR_YAMAHA, 0x1033, 0) }, /* DGX-505 */ 762 { USB_VPI(USB_VENDOR_YAMAHA, 0x1034, 0) }, /* NULL */ 763 { USB_VPI(USB_VENDOR_YAMAHA, 0x1035, 0) }, /* NULL */ 764 { USB_VPI(USB_VENDOR_YAMAHA, 0x1036, 0) }, /* NULL */ 765 { USB_VPI(USB_VENDOR_YAMAHA, 0x1037, 0) }, /* NULL */ 766 { USB_VPI(USB_VENDOR_YAMAHA, 0x1038, 0) }, /* NULL */ 767 { USB_VPI(USB_VENDOR_YAMAHA, 0x1039, 0) }, /* NULL */ 768 { USB_VPI(USB_VENDOR_YAMAHA, 0x103a, 0) }, /* NULL */ 769 { USB_VPI(USB_VENDOR_YAMAHA, 0x103b, 0) }, /* NULL */ 770 { USB_VPI(USB_VENDOR_YAMAHA, 0x103c, 0) }, /* NULL */ 771 { USB_VPI(USB_VENDOR_YAMAHA, 0x103d, 0) }, /* NULL */ 772 { USB_VPI(USB_VENDOR_YAMAHA, 0x103e, 0) }, /* NULL */ 773 { USB_VPI(USB_VENDOR_YAMAHA, 0x103f, 0) }, /* NULL */ 774 { USB_VPI(USB_VENDOR_YAMAHA, 0x1040, 0) }, /* NULL */ 775 { USB_VPI(USB_VENDOR_YAMAHA, 0x1041, 0) }, /* NULL */ 776 { USB_VPI(USB_VENDOR_YAMAHA, 0x1042, 0) }, /* NULL */ 777 { USB_VPI(USB_VENDOR_YAMAHA, 0x1043, 0) }, /* NULL */ 778 { USB_VPI(USB_VENDOR_YAMAHA, 0x1044, 0) }, /* NULL */ 779 { USB_VPI(USB_VENDOR_YAMAHA, 0x1045, 0) }, /* NULL */ 780 { USB_VPI(USB_VENDOR_YAMAHA, 0x104e, 0) }, /* NULL */ 781 { USB_VPI(USB_VENDOR_YAMAHA, 0x104f, 0) }, /* NULL */ 782 { USB_VPI(USB_VENDOR_YAMAHA, 0x1050, 0) }, /* NULL */ 783 { USB_VPI(USB_VENDOR_YAMAHA, 0x1051, 0) }, /* NULL */ 784 { USB_VPI(USB_VENDOR_YAMAHA, 0x1052, 0) }, /* NULL */ 785 { USB_VPI(USB_VENDOR_YAMAHA, 0x1053, 0) }, /* NULL */ 786 { USB_VPI(USB_VENDOR_YAMAHA, 0x1054, 0) }, /* NULL */ 787 { USB_VPI(USB_VENDOR_YAMAHA, 0x1055, 0) }, /* NULL */ 788 { USB_VPI(USB_VENDOR_YAMAHA, 0x1056, 0) }, /* NULL */ 789 { USB_VPI(USB_VENDOR_YAMAHA, 0x1057, 0) }, /* NULL */ 790 { USB_VPI(USB_VENDOR_YAMAHA, 0x1058, 0) }, /* NULL */ 791 { USB_VPI(USB_VENDOR_YAMAHA, 0x1059, 0) }, /* NULL */ 792 { USB_VPI(USB_VENDOR_YAMAHA, 0x105a, 0) }, /* NULL */ 793 { USB_VPI(USB_VENDOR_YAMAHA, 0x105b, 0) }, /* NULL */ 794 { USB_VPI(USB_VENDOR_YAMAHA, 0x105c, 0) }, /* NULL */ 795 { USB_VPI(USB_VENDOR_YAMAHA, 0x105d, 0) }, /* NULL */ 796 { USB_VPI(USB_VENDOR_YAMAHA, 0x1503, 3) }, /* MOX6/MOX8 */ 797 { USB_VPI(USB_VENDOR_YAMAHA, 0x2000, 0) }, /* DGP-7 */ 798 { USB_VPI(USB_VENDOR_YAMAHA, 0x2001, 0) }, /* DGP-5 */ 799 { USB_VPI(USB_VENDOR_YAMAHA, 0x2002, 0) }, /* NULL */ 800 { USB_VPI(USB_VENDOR_YAMAHA, 0x2003, 0) }, /* NULL */ 801 { USB_VPI(USB_VENDOR_YAMAHA, 0x5000, 0) }, /* CS1D */ 802 { USB_VPI(USB_VENDOR_YAMAHA, 0x5001, 0) }, /* DSP1D */ 803 { USB_VPI(USB_VENDOR_YAMAHA, 0x5002, 0) }, /* DME32 */ 804 { USB_VPI(USB_VENDOR_YAMAHA, 0x5003, 0) }, /* DM2000 */ 805 { USB_VPI(USB_VENDOR_YAMAHA, 0x5004, 0) }, /* 02R96 */ 806 { USB_VPI(USB_VENDOR_YAMAHA, 0x5005, 0) }, /* ACU16-C */ 807 { USB_VPI(USB_VENDOR_YAMAHA, 0x5006, 0) }, /* NHB32-C */ 808 { USB_VPI(USB_VENDOR_YAMAHA, 0x5007, 0) }, /* DM1000 */ 809 { USB_VPI(USB_VENDOR_YAMAHA, 0x5008, 0) }, /* 01V96 */ 810 { USB_VPI(USB_VENDOR_YAMAHA, 0x5009, 0) }, /* SPX2000 */ 811 { USB_VPI(USB_VENDOR_YAMAHA, 0x500a, 0) }, /* PM5D */ 812 { USB_VPI(USB_VENDOR_YAMAHA, 0x500b, 0) }, /* DME64N */ 813 { USB_VPI(USB_VENDOR_YAMAHA, 0x500c, 0) }, /* DME24N */ 814 { USB_VPI(USB_VENDOR_YAMAHA, 0x500d, 0) }, /* NULL */ 815 { USB_VPI(USB_VENDOR_YAMAHA, 0x500e, 0) }, /* NULL */ 816 { USB_VPI(USB_VENDOR_YAMAHA, 0x500f, 0) }, /* NULL */ 817 { USB_VPI(USB_VENDOR_YAMAHA, 0x7000, 0) }, /* DTX */ 818 { USB_VPI(USB_VENDOR_YAMAHA, 0x7010, 0) }, /* UB99 */ 819 }; 820 821 static const STRUCT_USB_HOST_ID __used uaudio_devs[] = { 822 /* Generic USB audio class match */ 823 {USB_IFACE_CLASS(UICLASS_AUDIO), 824 USB_IFACE_SUBCLASS(UISUBCLASS_AUDIOCONTROL),}, 825 /* Generic USB MIDI class match */ 826 {USB_IFACE_CLASS(UICLASS_AUDIO), 827 USB_IFACE_SUBCLASS(UISUBCLASS_MIDISTREAM),}, 828 }; 829 830 static int 831 uaudio_probe(device_t dev) 832 { 833 struct usb_attach_arg *uaa = device_get_ivars(dev); 834 835 if (uaa->usb_mode != USB_MODE_HOST) 836 return (ENXIO); 837 838 /* lookup non-standard device(s) */ 839 840 if (usbd_lookup_id_by_uaa(uaudio_vendor_midi, 841 sizeof(uaudio_vendor_midi), uaa) == 0) { 842 return (BUS_PROBE_SPECIFIC); 843 } 844 845 if (uaa->info.bInterfaceClass != UICLASS_AUDIO) { 846 if (uaa->info.bInterfaceClass != UICLASS_VENDOR || 847 usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS) == 0) 848 return (ENXIO); 849 } 850 851 /* check for AUDIO control interface */ 852 853 if (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL) { 854 if (usb_test_quirk(uaa, UQ_BAD_AUDIO)) 855 return (ENXIO); 856 else 857 return (BUS_PROBE_GENERIC); 858 } 859 860 /* check for MIDI stream */ 861 862 if (uaa->info.bInterfaceSubClass == UISUBCLASS_MIDISTREAM) { 863 if (usb_test_quirk(uaa, UQ_BAD_MIDI)) 864 return (ENXIO); 865 else 866 return (BUS_PROBE_GENERIC); 867 } 868 return (ENXIO); 869 } 870 871 /* 872 * Set Cmedia CM6206 S/PDIF settings 873 * Source: CM6206 Datasheet v2.3. 874 */ 875 static int 876 uaudio_set_spdif_cm6206(struct uaudio_softc *sc, int flags) 877 { 878 uint8_t cmd[2][4] = { 879 {0x20, 0x20, 0x00, 0}, 880 {0x20, 0x30, 0x02, 1} 881 }; 882 int i; 883 884 if (flags & UAUDIO_SPDIF_OUT) 885 cmd[1][1] = 0x00; 886 else 887 cmd[1][1] = 0x02; 888 889 if (flags & UAUDIO_SPDIF_OUT_96K) 890 cmd[0][1] = 0x60; /* 96K: 3'b110 */ 891 892 if (flags & UAUDIO_SPDIF_IN_MIX) 893 cmd[1][1] = 0x03; /* SPDIFMIX */ 894 895 for (i = 0; i < 2; i++) { 896 if (usbd_req_set_report(sc->sc_udev, NULL, 897 cmd[i], sizeof(cmd[0]), 898 sc->sc_mixer_iface_index, UHID_OUTPUT_REPORT, 0) != 0) { 899 return (ENXIO); 900 } 901 } 902 return (0); 903 } 904 905 static int 906 uaudio_set_spdif_dummy(struct uaudio_softc *sc, int flags) 907 { 908 return (0); 909 } 910 911 static int 912 uaudio_attach(device_t dev) 913 { 914 struct usb_attach_arg *uaa = device_get_ivars(dev); 915 struct uaudio_softc *sc = device_get_softc(dev); 916 struct usb_interface_descriptor *id; 917 usb_error_t err; 918 device_t child; 919 920 sc->sc_play_chan.priv_sc = sc; 921 sc->sc_rec_chan.priv_sc = sc; 922 sc->sc_udev = uaa->device; 923 sc->sc_mixer_iface_index = uaa->info.bIfaceIndex; 924 sc->sc_mixer_iface_no = uaa->info.bIfaceNum; 925 sc->sc_config_msg[0].hdr.pm_callback = &uaudio_configure_msg; 926 sc->sc_config_msg[0].sc = sc; 927 sc->sc_config_msg[1].hdr.pm_callback = &uaudio_configure_msg; 928 sc->sc_config_msg[1].sc = sc; 929 930 if (usb_test_quirk(uaa, UQ_AUDIO_SWAP_LR)) 931 sc->sc_uq_audio_swap_lr = 1; 932 933 if (usb_test_quirk(uaa, UQ_AU_INP_ASYNC)) 934 sc->sc_uq_au_inp_async = 1; 935 936 if (usb_test_quirk(uaa, UQ_AU_NO_XU)) 937 sc->sc_uq_au_no_xu = 1; 938 939 if (usb_test_quirk(uaa, UQ_BAD_ADC)) 940 sc->sc_uq_bad_adc = 1; 941 942 if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS)) 943 sc->sc_uq_au_vendor_class = 1; 944 945 /* set S/PDIF function */ 946 if (usb_test_quirk(uaa, UQ_AU_SET_SPDIF_CM6206)) 947 sc->sc_set_spdif_fn = uaudio_set_spdif_cm6206; 948 else 949 sc->sc_set_spdif_fn = uaudio_set_spdif_dummy; 950 951 umidi_init(dev); 952 953 device_set_usb_desc(dev); 954 955 id = usbd_get_interface_descriptor(uaa->iface); 956 957 /* must fill mixer info before channel info */ 958 uaudio_mixer_fill_info(sc, uaa->device, id); 959 960 /* fill channel info */ 961 uaudio_chan_fill_info(sc, uaa->device); 962 963 DPRINTF("audio rev %d.%02x\n", 964 sc->sc_audio_rev >> 8, 965 sc->sc_audio_rev & 0xff); 966 967 if (sc->sc_mixer_count == 0) { 968 if (uaa->info.idVendor == USB_VENDOR_MAUDIO && 969 (uaa->info.idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA || 970 uaa->info.idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA8R)) { 971 DPRINTF("Generating mixer descriptors\n"); 972 uaudio_mixer_controls_create_ftu(sc); 973 } 974 } 975 976 DPRINTF("%d mixer controls\n", 977 sc->sc_mixer_count); 978 979 if (sc->sc_play_chan.num_alt > 0) { 980 uint8_t x; 981 982 /* 983 * Need to set a default alternate interface, else 984 * some USB audio devices might go into an infinte 985 * re-enumeration loop: 986 */ 987 err = usbd_set_alt_interface_index(sc->sc_udev, 988 sc->sc_play_chan.usb_alt[0].iface_index, 989 sc->sc_play_chan.usb_alt[0].iface_alt_index); 990 if (err) { 991 DPRINTF("setting of alternate index failed: %s!\n", 992 usbd_errstr(err)); 993 } 994 for (x = 0; x != sc->sc_play_chan.num_alt; x++) { 995 device_printf(dev, "Play: %d Hz, %d ch, %s format, " 996 "2x8ms buffer.\n", 997 sc->sc_play_chan.usb_alt[x].sample_rate, 998 sc->sc_play_chan.usb_alt[x].channels, 999 sc->sc_play_chan.usb_alt[x].p_fmt->description); 1000 } 1001 } else { 1002 device_printf(dev, "No playback.\n"); 1003 } 1004 1005 if (sc->sc_rec_chan.num_alt > 0) { 1006 uint8_t x; 1007 1008 /* 1009 * Need to set a default alternate interface, else 1010 * some USB audio devices might go into an infinte 1011 * re-enumeration loop: 1012 */ 1013 err = usbd_set_alt_interface_index(sc->sc_udev, 1014 sc->sc_rec_chan.usb_alt[0].iface_index, 1015 sc->sc_rec_chan.usb_alt[0].iface_alt_index); 1016 if (err) { 1017 DPRINTF("setting of alternate index failed: %s!\n", 1018 usbd_errstr(err)); 1019 } 1020 for (x = 0; x != sc->sc_rec_chan.num_alt; x++) { 1021 device_printf(dev, "Record: %d Hz, %d ch, %s format, " 1022 "2x8ms buffer.\n", 1023 sc->sc_rec_chan.usb_alt[x].sample_rate, 1024 sc->sc_rec_chan.usb_alt[x].channels, 1025 sc->sc_rec_chan.usb_alt[x].p_fmt->description); 1026 } 1027 } else { 1028 device_printf(dev, "No recording.\n"); 1029 } 1030 1031 if (sc->sc_midi_chan.valid == 0) { 1032 if (usbd_lookup_id_by_uaa(uaudio_vendor_midi, 1033 sizeof(uaudio_vendor_midi), uaa) == 0) { 1034 sc->sc_midi_chan.iface_index = 1035 (uint8_t)uaa->driver_info; 1036 sc->sc_midi_chan.iface_alt_index = 0; 1037 sc->sc_midi_chan.valid = 1; 1038 } 1039 } 1040 1041 if (sc->sc_midi_chan.valid) { 1042 1043 if (umidi_probe(dev)) { 1044 goto detach; 1045 } 1046 device_printf(dev, "MIDI sequencer.\n"); 1047 } else { 1048 device_printf(dev, "No MIDI sequencer.\n"); 1049 } 1050 1051 DPRINTF("doing child attach\n"); 1052 1053 /* attach the children */ 1054 1055 sc->sc_sndcard_func.func = SCF_PCM; 1056 1057 /* 1058 * Only attach a PCM device if we have a playback, recording 1059 * or mixer device present: 1060 */ 1061 if (sc->sc_play_chan.num_alt > 0 || 1062 sc->sc_rec_chan.num_alt > 0 || 1063 sc->sc_mix_info) { 1064 child = device_add_child(dev, "pcm", -1); 1065 1066 if (child == NULL) { 1067 DPRINTF("out of memory\n"); 1068 goto detach; 1069 } 1070 device_set_ivars(child, &sc->sc_sndcard_func); 1071 } 1072 1073 if (bus_generic_attach(dev)) { 1074 DPRINTF("child attach failed\n"); 1075 goto detach; 1076 } 1077 1078 if (uaudio_hid_probe(sc, uaa) == 0) { 1079 device_printf(dev, "HID volume keys found.\n"); 1080 } else { 1081 device_printf(dev, "No HID volume keys found.\n"); 1082 } 1083 1084 /* reload all mixer settings */ 1085 uaudio_mixer_reload_all(sc); 1086 1087 /* enable S/PDIF output, if any */ 1088 if (sc->sc_set_spdif_fn(sc, 1089 UAUDIO_SPDIF_OUT | UAUDIO_SPDIF_OUT_48K) != 0) { 1090 device_printf(dev, "Failed to enable S/PDIF at 48K\n"); 1091 } 1092 return (0); /* success */ 1093 1094 detach: 1095 uaudio_detach(dev); 1096 return (ENXIO); 1097 } 1098 1099 static void 1100 uaudio_pcm_setflags(device_t dev, uint32_t flags) 1101 { 1102 pcm_setflags(dev, pcm_getflags(dev) | flags); 1103 } 1104 1105 int 1106 uaudio_attach_sub(device_t dev, kobj_class_t mixer_class, kobj_class_t chan_class) 1107 { 1108 struct uaudio_softc *sc = device_get_softc(device_get_parent(dev)); 1109 char status[SND_STATUSLEN]; 1110 1111 uaudio_mixer_init(sc); 1112 1113 if (sc->sc_uq_audio_swap_lr) { 1114 DPRINTF("hardware has swapped left and right\n"); 1115 /* uaudio_pcm_setflags(dev, SD_F_PSWAPLR); */ 1116 } 1117 if (sc->sc_play_chan.num_alt > 0 && 1118 (sc->sc_mix_info & SOUND_MASK_PCM) == 0) { 1119 1120 DPRINTF("emulating master volume\n"); 1121 1122 /* 1123 * Emulate missing pcm mixer controller 1124 * through FEEDER_VOLUME 1125 */ 1126 uaudio_pcm_setflags(dev, SD_F_SOFTPCMVOL); 1127 } 1128 if (sc->sc_pcm_bitperfect) { 1129 DPRINTF("device needs bitperfect by default\n"); 1130 uaudio_pcm_setflags(dev, SD_F_BITPERFECT); 1131 } 1132 if (mixer_init(dev, mixer_class, sc)) 1133 goto detach; 1134 sc->sc_mixer_init = 1; 1135 1136 mixer_hwvol_init(dev); 1137 1138 snprintf(status, sizeof(status), "at ? %s", PCM_KLDSTRING(snd_uaudio)); 1139 1140 if (pcm_register(dev, sc, 1141 (sc->sc_play_chan.num_alt > 0) ? 1 : 0, 1142 (sc->sc_rec_chan.num_alt > 0) ? 1 : 0)) { 1143 goto detach; 1144 } 1145 1146 uaudio_pcm_setflags(dev, SD_F_MPSAFE); 1147 sc->sc_pcm_registered = 1; 1148 1149 if (sc->sc_play_chan.num_alt > 0) { 1150 pcm_addchan(dev, PCMDIR_PLAY, chan_class, sc); 1151 } 1152 if (sc->sc_rec_chan.num_alt > 0) { 1153 pcm_addchan(dev, PCMDIR_REC, chan_class, sc); 1154 } 1155 pcm_setstatus(dev, status); 1156 1157 uaudio_mixer_register_sysctl(sc, dev); 1158 1159 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 1160 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, 1161 "feedback_rate", CTLFLAG_RD, &sc->sc_play_chan.feedback_rate, 1162 0, "Feedback sample rate in Hz"); 1163 1164 return (0); /* success */ 1165 1166 detach: 1167 uaudio_detach_sub(dev); 1168 return (ENXIO); 1169 } 1170 1171 int 1172 uaudio_detach_sub(device_t dev) 1173 { 1174 struct uaudio_softc *sc = device_get_softc(device_get_parent(dev)); 1175 int error = 0; 1176 1177 /* disable S/PDIF output, if any */ 1178 (void) sc->sc_set_spdif_fn(sc, 0); 1179 1180 repeat: 1181 if (sc->sc_pcm_registered) { 1182 error = pcm_unregister(dev); 1183 } else { 1184 if (sc->sc_mixer_init) { 1185 error = mixer_uninit(dev); 1186 } 1187 } 1188 1189 if (error) { 1190 device_printf(dev, "Waiting for sound application to exit!\n"); 1191 usb_pause_mtx(NULL, 2 * hz); 1192 goto repeat; /* try again */ 1193 } 1194 return (0); /* success */ 1195 } 1196 1197 static int 1198 uaudio_detach(device_t dev) 1199 { 1200 struct uaudio_softc *sc = device_get_softc(dev); 1201 1202 /* 1203 * Stop USB transfers early so that any audio applications 1204 * will time out and close opened /dev/dspX.Y device(s), if 1205 * any. 1206 */ 1207 usb_proc_explore_lock(sc->sc_udev); 1208 sc->sc_play_chan.operation = CHAN_OP_DRAIN; 1209 sc->sc_rec_chan.operation = CHAN_OP_DRAIN; 1210 usb_proc_explore_mwait(sc->sc_udev, 1211 &sc->sc_config_msg[0], &sc->sc_config_msg[1]); 1212 usb_proc_explore_unlock(sc->sc_udev); 1213 1214 usbd_transfer_unsetup(sc->sc_play_chan.xfer, UAUDIO_NCHANBUFS + 1); 1215 usbd_transfer_unsetup(sc->sc_rec_chan.xfer, UAUDIO_NCHANBUFS + 1); 1216 1217 uaudio_hid_detach(sc); 1218 1219 if (bus_generic_detach(dev) != 0) { 1220 DPRINTF("detach failed!\n"); 1221 } 1222 sbuf_delete(&sc->sc_sndstat); 1223 sc->sc_sndstat_valid = 0; 1224 1225 umidi_detach(dev); 1226 1227 /* free mixer data */ 1228 1229 uaudio_mixer_ctl_free(sc); 1230 1231 return (0); 1232 } 1233 1234 static uint32_t 1235 uaudio_get_buffer_size(struct uaudio_chan *ch, uint8_t alt) 1236 { 1237 struct uaudio_chan_alt *chan_alt = &ch->usb_alt[alt]; 1238 /* We use 2 times 8ms of buffer */ 1239 uint32_t buf_size = chan_alt->sample_size * 1240 howmany(chan_alt->sample_rate * (UAUDIO_NFRAMES / 8), 1000); 1241 return (buf_size); 1242 } 1243 1244 static void 1245 uaudio_configure_msg_sub(struct uaudio_softc *sc, 1246 struct uaudio_chan *chan, int dir) 1247 { 1248 struct uaudio_chan_alt *chan_alt; 1249 uint32_t frames; 1250 uint32_t buf_size; 1251 uint16_t fps; 1252 uint8_t set_alt; 1253 uint8_t fps_shift; 1254 uint8_t operation; 1255 usb_error_t err; 1256 1257 if (chan->num_alt <= 0) 1258 return; 1259 1260 DPRINTF("\n"); 1261 1262 usb_proc_explore_lock(sc->sc_udev); 1263 operation = chan->operation; 1264 chan->operation = CHAN_OP_NONE; 1265 usb_proc_explore_unlock(sc->sc_udev); 1266 1267 mtx_lock(chan->pcm_mtx); 1268 if (chan->cur_alt != chan->set_alt) 1269 set_alt = chan->set_alt; 1270 else 1271 set_alt = CHAN_MAX_ALT; 1272 mtx_unlock(chan->pcm_mtx); 1273 1274 if (set_alt >= chan->num_alt) 1275 goto done; 1276 1277 chan_alt = chan->usb_alt + set_alt; 1278 1279 usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1); 1280 1281 err = usbd_set_alt_interface_index(sc->sc_udev, 1282 chan_alt->iface_index, chan_alt->iface_alt_index); 1283 if (err) { 1284 DPRINTF("setting of alternate index failed: %s!\n", 1285 usbd_errstr(err)); 1286 goto error; 1287 } 1288 1289 /* 1290 * Only set the sample rate if the channel reports that it 1291 * supports the frequency control. 1292 */ 1293 1294 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) { 1295 /* FALLTHROUGH */ 1296 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) { 1297 unsigned int x; 1298 1299 for (x = 0; x != 256; x++) { 1300 if (dir == PCMDIR_PLAY) { 1301 if (!(sc->sc_mixer_clocks.bit_output[x / 8] & 1302 (1 << (x % 8)))) { 1303 continue; 1304 } 1305 } else { 1306 if (!(sc->sc_mixer_clocks.bit_input[x / 8] & 1307 (1 << (x % 8)))) { 1308 continue; 1309 } 1310 } 1311 1312 if (uaudio20_set_speed(sc->sc_udev, 1313 sc->sc_mixer_iface_no, x, chan_alt->sample_rate)) { 1314 /* 1315 * If the endpoint is adaptive setting 1316 * the speed may fail. 1317 */ 1318 DPRINTF("setting of sample rate failed! " 1319 "(continuing anyway)\n"); 1320 } 1321 } 1322 } else if (chan_alt->p_sed.v1->bmAttributes & UA_SED_FREQ_CONTROL) { 1323 if (uaudio_set_speed(sc->sc_udev, 1324 chan_alt->p_ed1->bEndpointAddress, chan_alt->sample_rate)) { 1325 /* 1326 * If the endpoint is adaptive setting the 1327 * speed may fail. 1328 */ 1329 DPRINTF("setting of sample rate failed! " 1330 "(continuing anyway)\n"); 1331 } 1332 } 1333 if (usbd_transfer_setup(sc->sc_udev, &chan_alt->iface_index, chan->xfer, 1334 chan_alt->usb_cfg, UAUDIO_NCHANBUFS + 1, chan, chan->pcm_mtx)) { 1335 DPRINTF("could not allocate USB transfers!\n"); 1336 goto error; 1337 } 1338 1339 fps = usbd_get_isoc_fps(sc->sc_udev); 1340 1341 if (fps < 8000) { 1342 /* FULL speed USB */ 1343 frames = uaudio_buffer_ms; 1344 } else { 1345 /* HIGH speed USB */ 1346 frames = uaudio_buffer_ms * 8; 1347 } 1348 1349 fps_shift = usbd_xfer_get_fps_shift(chan->xfer[0]); 1350 1351 /* down shift number of frames per second, if any */ 1352 fps >>= fps_shift; 1353 frames >>= fps_shift; 1354 1355 /* bytes per frame should not be zero */ 1356 chan->bytes_per_frame[0] = 1357 ((chan_alt->sample_rate / fps) * chan_alt->sample_size); 1358 chan->bytes_per_frame[1] = howmany(chan_alt->sample_rate, fps) * 1359 chan_alt->sample_size; 1360 1361 /* setup data rate dithering, if any */ 1362 chan->frames_per_second = fps; 1363 chan->sample_rem = chan_alt->sample_rate % fps; 1364 chan->sample_curr = 0; 1365 1366 /* compute required buffer size */ 1367 buf_size = (chan->bytes_per_frame[1] * frames); 1368 1369 if (buf_size > (chan->end - chan->start)) { 1370 DPRINTF("buffer size is too big\n"); 1371 goto error; 1372 } 1373 1374 chan->intr_frames = frames; 1375 1376 DPRINTF("fps=%d sample_rem=%d\n", (int)fps, (int)chan->sample_rem); 1377 1378 if (chan->intr_frames == 0) { 1379 DPRINTF("frame shift is too high!\n"); 1380 goto error; 1381 } 1382 1383 mtx_lock(chan->pcm_mtx); 1384 chan->cur_alt = set_alt; 1385 mtx_unlock(chan->pcm_mtx); 1386 1387 done: 1388 #if (UAUDIO_NCHANBUFS != 2) 1389 #error "please update code" 1390 #endif 1391 switch (operation) { 1392 case CHAN_OP_START: 1393 mtx_lock(chan->pcm_mtx); 1394 usbd_transfer_start(chan->xfer[0]); 1395 usbd_transfer_start(chan->xfer[1]); 1396 mtx_unlock(chan->pcm_mtx); 1397 break; 1398 case CHAN_OP_STOP: 1399 mtx_lock(chan->pcm_mtx); 1400 usbd_transfer_stop(chan->xfer[0]); 1401 usbd_transfer_stop(chan->xfer[1]); 1402 mtx_unlock(chan->pcm_mtx); 1403 break; 1404 default: 1405 break; 1406 } 1407 return; 1408 1409 error: 1410 usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1); 1411 1412 mtx_lock(chan->pcm_mtx); 1413 chan->cur_alt = CHAN_MAX_ALT; 1414 mtx_unlock(chan->pcm_mtx); 1415 } 1416 1417 static void 1418 uaudio_configure_msg(struct usb_proc_msg *pm) 1419 { 1420 struct uaudio_softc *sc = ((struct uaudio_configure_msg *)pm)->sc; 1421 1422 usb_proc_explore_unlock(sc->sc_udev); 1423 uaudio_configure_msg_sub(sc, &sc->sc_play_chan, PCMDIR_PLAY); 1424 uaudio_configure_msg_sub(sc, &sc->sc_rec_chan, PCMDIR_REC); 1425 usb_proc_explore_lock(sc->sc_udev); 1426 } 1427 1428 /*========================================================================* 1429 * AS - Audio Stream - routines 1430 *========================================================================*/ 1431 1432 #ifdef USB_DEBUG 1433 static void 1434 uaudio_chan_dump_ep_desc(const usb_endpoint_descriptor_audio_t *ed) 1435 { 1436 if (ed) { 1437 DPRINTF("endpoint=%p bLength=%d bDescriptorType=%d \n" 1438 "bEndpointAddress=%d bmAttributes=0x%x \n" 1439 "wMaxPacketSize=%d bInterval=%d \n" 1440 "bRefresh=%d bSynchAddress=%d\n", 1441 ed, ed->bLength, ed->bDescriptorType, 1442 ed->bEndpointAddress, ed->bmAttributes, 1443 UGETW(ed->wMaxPacketSize), ed->bInterval, 1444 UEP_HAS_REFRESH(ed) ? ed->bRefresh : 0, 1445 UEP_HAS_SYNCADDR(ed) ? ed->bSynchAddress : 0); 1446 } 1447 } 1448 1449 #endif 1450 1451 /* 1452 * The following is a workaround for broken no-name USB audio devices 1453 * sold by dealextreme called "3D sound". The problem is that the 1454 * manufacturer computed wMaxPacketSize is too small to hold the 1455 * actual data sent. In other words the device sometimes sends more 1456 * data than it actually reports it can send in a single isochronous 1457 * packet. 1458 */ 1459 static void 1460 uaudio_record_fix_fs(usb_endpoint_descriptor_audio_t *ep, 1461 uint32_t xps, uint32_t add) 1462 { 1463 uint32_t mps; 1464 1465 mps = UGETW(ep->wMaxPacketSize); 1466 1467 /* 1468 * If the device indicates it can send more data than what the 1469 * sample rate indicates, we apply the workaround. 1470 */ 1471 if (mps > xps) { 1472 1473 /* allow additional data */ 1474 xps += add; 1475 1476 /* check against the maximum USB 1.x length */ 1477 if (xps > 1023) 1478 xps = 1023; 1479 1480 /* check if we should do an update */ 1481 if (mps < xps) { 1482 /* simply update the wMaxPacketSize field */ 1483 USETW(ep->wMaxPacketSize, xps); 1484 DPRINTF("Workaround: Updated wMaxPacketSize " 1485 "from %d to %d bytes.\n", 1486 (int)mps, (int)xps); 1487 } 1488 } 1489 } 1490 1491 static usb_error_t 1492 uaudio20_check_rate(struct usb_device *udev, uint8_t iface_no, 1493 uint8_t clockid, uint32_t rate) 1494 { 1495 struct usb_device_request req; 1496 usb_error_t error; 1497 #define UAUDIO20_MAX_RATES 32 /* we support at maxium 32 rates */ 1498 uint8_t data[2 + UAUDIO20_MAX_RATES * 12]; 1499 uint16_t actlen; 1500 uint16_t rates; 1501 uint16_t x; 1502 1503 DPRINTFN(6, "ifaceno=%d clockid=%d rate=%u\n", 1504 iface_no, clockid, rate); 1505 1506 req.bmRequestType = UT_READ_CLASS_INTERFACE; 1507 req.bRequest = UA20_CS_RANGE; 1508 USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0); 1509 USETW2(req.wIndex, clockid, iface_no); 1510 /* 1511 * Assume there is at least one rate to begin with, else some 1512 * devices might refuse to return the USB descriptor: 1513 */ 1514 USETW(req.wLength, (2 + 1 * 12)); 1515 1516 error = usbd_do_request_flags(udev, NULL, &req, data, 1517 USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT); 1518 1519 if (error != 0 || actlen < 2) { 1520 /* 1521 * Likely the descriptor doesn't fit into the supplied 1522 * buffer. Try using a larger buffer and see if that 1523 * helps: 1524 */ 1525 rates = MIN(UAUDIO20_MAX_RATES, (255 - 2) / 12); 1526 error = USB_ERR_INVAL; 1527 } else { 1528 rates = UGETW(data); 1529 1530 if (rates > UAUDIO20_MAX_RATES) { 1531 DPRINTF("Too many rates truncating to %d\n", UAUDIO20_MAX_RATES); 1532 rates = UAUDIO20_MAX_RATES; 1533 error = USB_ERR_INVAL; 1534 } else if (rates > 1) { 1535 DPRINTF("Need to read full rate descriptor\n"); 1536 error = USB_ERR_INVAL; 1537 } 1538 } 1539 1540 if (error != 0) { 1541 /* 1542 * Try to read full rate descriptor. 1543 */ 1544 actlen = (2 + rates * 12); 1545 1546 USETW(req.wLength, actlen); 1547 1548 error = usbd_do_request_flags(udev, NULL, &req, data, 1549 USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT); 1550 1551 if (error != 0 || actlen < 2) 1552 return (USB_ERR_INVAL); 1553 1554 rates = UGETW(data); 1555 } 1556 1557 actlen = (actlen - 2) / 12; 1558 1559 if (rates > actlen) { 1560 DPRINTF("Too many rates truncating to %d\n", actlen); 1561 rates = actlen; 1562 } 1563 1564 for (x = 0; x != rates; x++) { 1565 uint32_t min = UGETDW(data + 2 + (12 * x)); 1566 uint32_t max = UGETDW(data + 6 + (12 * x)); 1567 uint32_t res = UGETDW(data + 10 + (12 * x)); 1568 1569 if (res == 0) { 1570 DPRINTF("Zero residue\n"); 1571 res = 1; 1572 } 1573 1574 if (min > max) { 1575 DPRINTF("Swapped max and min\n"); 1576 uint32_t temp; 1577 temp = min; 1578 min = max; 1579 max = temp; 1580 } 1581 1582 if (rate >= min && rate <= max && 1583 (((rate - min) % res) == 0)) { 1584 return (0); 1585 } 1586 } 1587 return (USB_ERR_INVAL); 1588 } 1589 1590 static void 1591 uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev, 1592 uint32_t rate, uint8_t channels, uint8_t bit_resolution) 1593 { 1594 struct usb_descriptor *desc = NULL; 1595 union uaudio_asid asid = { NULL }; 1596 union uaudio_asf1d asf1d = { NULL }; 1597 union uaudio_sed sed = { NULL }; 1598 struct usb_midi_streaming_endpoint_descriptor *msid = NULL; 1599 usb_endpoint_descriptor_audio_t *ed1 = NULL; 1600 const struct usb_audio_control_descriptor *acdp = NULL; 1601 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); 1602 struct usb_interface_descriptor *id; 1603 const struct uaudio_format *p_fmt = NULL; 1604 struct uaudio_chan *chan; 1605 struct uaudio_chan_alt *chan_alt; 1606 uint32_t format; 1607 uint16_t curidx = 0xFFFF; 1608 uint16_t lastidx = 0xFFFF; 1609 uint16_t alt_index = 0; 1610 uint16_t audio_rev = 0; 1611 uint16_t x; 1612 uint8_t ep_dir; 1613 uint8_t bChannels; 1614 uint8_t bBitResolution; 1615 uint8_t audio_if = 0; 1616 uint8_t midi_if = 0; 1617 uint8_t uma_if_class; 1618 1619 while ((desc = usb_desc_foreach(cd, desc))) { 1620 1621 if ((desc->bDescriptorType == UDESC_INTERFACE) && 1622 (desc->bLength >= sizeof(*id))) { 1623 1624 id = (void *)desc; 1625 1626 if (id->bInterfaceNumber != lastidx) { 1627 lastidx = id->bInterfaceNumber; 1628 curidx++; 1629 alt_index = 0; 1630 1631 } else { 1632 alt_index++; 1633 } 1634 1635 if ((!(sc->sc_hid.flags & UAUDIO_HID_VALID)) && 1636 (id->bInterfaceClass == UICLASS_HID) && 1637 (id->bInterfaceSubClass == 0) && 1638 (id->bInterfaceProtocol == 0) && 1639 (alt_index == 0) && 1640 usbd_get_iface(udev, curidx) != NULL) { 1641 DPRINTF("Found HID interface at %d\n", 1642 curidx); 1643 sc->sc_hid.flags |= UAUDIO_HID_VALID; 1644 sc->sc_hid.iface_index = curidx; 1645 } 1646 1647 uma_if_class = 1648 ((id->bInterfaceClass == UICLASS_AUDIO) || 1649 ((id->bInterfaceClass == UICLASS_VENDOR) && 1650 (sc->sc_uq_au_vendor_class != 0))); 1651 1652 if ((uma_if_class != 0) && 1653 (id->bInterfaceSubClass == UISUBCLASS_AUDIOSTREAM)) { 1654 audio_if = 1; 1655 } else { 1656 audio_if = 0; 1657 } 1658 1659 if ((uma_if_class != 0) && 1660 (id->bInterfaceSubClass == UISUBCLASS_MIDISTREAM)) { 1661 1662 /* 1663 * XXX could allow multiple MIDI interfaces 1664 */ 1665 midi_if = 1; 1666 1667 if ((sc->sc_midi_chan.valid == 0) && 1668 (usbd_get_iface(udev, curidx) != NULL)) { 1669 sc->sc_midi_chan.iface_index = curidx; 1670 sc->sc_midi_chan.iface_alt_index = alt_index; 1671 sc->sc_midi_chan.valid = 1; 1672 } 1673 } else { 1674 midi_if = 0; 1675 } 1676 asid.v1 = NULL; 1677 asf1d.v1 = NULL; 1678 ed1 = NULL; 1679 sed.v1 = NULL; 1680 1681 /* 1682 * There can only be one USB audio instance 1683 * per USB device. Grab all USB audio 1684 * interfaces on this USB device so that we 1685 * don't attach USB audio twice: 1686 */ 1687 if (alt_index == 0 && curidx != sc->sc_mixer_iface_index && 1688 (id->bInterfaceClass == UICLASS_AUDIO || audio_if != 0 || 1689 midi_if != 0)) { 1690 usbd_set_parent_iface(sc->sc_udev, curidx, 1691 sc->sc_mixer_iface_index); 1692 } 1693 } 1694 1695 if (audio_if == 0) { 1696 if (midi_if == 0) { 1697 if ((acdp == NULL) && 1698 (desc->bDescriptorType == UDESC_CS_INTERFACE) && 1699 (desc->bDescriptorSubtype == UDESCSUB_AC_HEADER) && 1700 (desc->bLength >= sizeof(*acdp))) { 1701 acdp = (void *)desc; 1702 audio_rev = UGETW(acdp->bcdADC); 1703 } 1704 } else { 1705 msid = (void *)desc; 1706 1707 /* get the maximum number of embedded jacks in use, if any */ 1708 if (msid->bLength >= sizeof(*msid) && 1709 msid->bDescriptorType == UDESC_CS_ENDPOINT && 1710 msid->bDescriptorSubtype == MS_GENERAL && 1711 msid->bNumEmbMIDIJack > sc->sc_midi_chan.max_emb_jack) { 1712 sc->sc_midi_chan.max_emb_jack = msid->bNumEmbMIDIJack; 1713 } 1714 } 1715 /* 1716 * Don't collect any USB audio descriptors if 1717 * this is not an USB audio stream interface. 1718 */ 1719 continue; 1720 } 1721 1722 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) && 1723 (desc->bDescriptorType == UDESC_CS_INTERFACE) && 1724 (desc->bDescriptorSubtype == AS_GENERAL) && 1725 (asid.v1 == NULL)) { 1726 if (audio_rev >= UAUDIO_VERSION_30) { 1727 /* FALLTHROUGH */ 1728 } else if (audio_rev >= UAUDIO_VERSION_20) { 1729 if (desc->bLength >= sizeof(*asid.v2)) { 1730 asid.v2 = (void *)desc; 1731 } 1732 } else { 1733 if (desc->bLength >= sizeof(*asid.v1)) { 1734 asid.v1 = (void *)desc; 1735 } 1736 } 1737 } 1738 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) && 1739 (desc->bDescriptorType == UDESC_CS_INTERFACE) && 1740 (desc->bDescriptorSubtype == FORMAT_TYPE) && 1741 (asf1d.v1 == NULL)) { 1742 if (audio_rev >= UAUDIO_VERSION_30) { 1743 /* FALLTHROUGH */ 1744 } else if (audio_rev >= UAUDIO_VERSION_20) { 1745 if (desc->bLength >= sizeof(*asf1d.v2)) 1746 asf1d.v2 = (void *)desc; 1747 } else { 1748 if (desc->bLength >= sizeof(*asf1d.v1)) { 1749 asf1d.v1 = (void *)desc; 1750 1751 if (asf1d.v1->bFormatType != FORMAT_TYPE_I) { 1752 DPRINTFN(11, "ignored bFormatType = %d\n", 1753 asf1d.v1->bFormatType); 1754 asf1d.v1 = NULL; 1755 continue; 1756 } 1757 if (desc->bLength < (sizeof(*asf1d.v1) + 1758 ((asf1d.v1->bSamFreqType == 0) ? 6 : 1759 (asf1d.v1->bSamFreqType * 3)))) { 1760 DPRINTFN(11, "invalid descriptor, " 1761 "too short\n"); 1762 asf1d.v1 = NULL; 1763 continue; 1764 } 1765 } 1766 } 1767 } 1768 if ((desc->bDescriptorType == UDESC_ENDPOINT) && 1769 (desc->bLength >= UEP_MINSIZE) && 1770 (ed1 == NULL)) { 1771 ed1 = (void *)desc; 1772 if (UE_GET_XFERTYPE(ed1->bmAttributes) != UE_ISOCHRONOUS) { 1773 ed1 = NULL; 1774 continue; 1775 } 1776 } 1777 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) && 1778 (desc->bDescriptorType == UDESC_CS_ENDPOINT) && 1779 (desc->bDescriptorSubtype == AS_GENERAL) && 1780 (sed.v1 == NULL)) { 1781 if (audio_rev >= UAUDIO_VERSION_30) { 1782 /* FALLTHROUGH */ 1783 } else if (audio_rev >= UAUDIO_VERSION_20) { 1784 if (desc->bLength >= sizeof(*sed.v2)) 1785 sed.v2 = (void *)desc; 1786 } else { 1787 if (desc->bLength >= sizeof(*sed.v1)) 1788 sed.v1 = (void *)desc; 1789 } 1790 } 1791 if (asid.v1 == NULL || asf1d.v1 == NULL || 1792 ed1 == NULL || sed.v1 == NULL) { 1793 /* need more descriptors */ 1794 continue; 1795 } 1796 1797 ep_dir = UE_GET_DIR(ed1->bEndpointAddress); 1798 1799 /* We ignore sync endpoint information until further. */ 1800 1801 if (audio_rev >= UAUDIO_VERSION_30) { 1802 goto next_ep; 1803 } else if (audio_rev >= UAUDIO_VERSION_20) { 1804 1805 uint32_t dwFormat; 1806 1807 dwFormat = UGETDW(asid.v2->bmFormats); 1808 bChannels = asid.v2->bNrChannels; 1809 bBitResolution = asf1d.v2->bSubslotSize * 8; 1810 1811 if ((bChannels != channels) || 1812 (bBitResolution != bit_resolution)) { 1813 DPRINTF("Wrong number of channels\n"); 1814 goto next_ep; 1815 } 1816 1817 for (p_fmt = uaudio20_formats; 1818 p_fmt->wFormat != 0; p_fmt++) { 1819 if ((p_fmt->wFormat & dwFormat) && 1820 (p_fmt->bPrecision == bBitResolution)) 1821 break; 1822 } 1823 1824 if (p_fmt->wFormat == 0) { 1825 DPRINTF("Unsupported audio format\n"); 1826 goto next_ep; 1827 } 1828 1829 for (x = 0; x != 256; x++) { 1830 if (ep_dir == UE_DIR_OUT) { 1831 if (!(sc->sc_mixer_clocks.bit_output[x / 8] & 1832 (1 << (x % 8)))) { 1833 continue; 1834 } 1835 } else { 1836 if (!(sc->sc_mixer_clocks.bit_input[x / 8] & 1837 (1 << (x % 8)))) { 1838 continue; 1839 } 1840 } 1841 1842 DPRINTF("Checking clock ID=%d\n", x); 1843 1844 if (uaudio20_check_rate(udev, 1845 sc->sc_mixer_iface_no, x, rate)) { 1846 DPRINTF("Unsupported sampling " 1847 "rate, id=%d\n", x); 1848 goto next_ep; 1849 } 1850 } 1851 } else { 1852 uint16_t wFormat; 1853 1854 wFormat = UGETW(asid.v1->wFormatTag); 1855 bChannels = UAUDIO_MAX_CHAN(asf1d.v1->bNrChannels); 1856 bBitResolution = asf1d.v1->bSubFrameSize * 8; 1857 1858 if (asf1d.v1->bSamFreqType == 0) { 1859 DPRINTFN(16, "Sample rate: %d-%dHz\n", 1860 UA_SAMP_LO(asf1d.v1), 1861 UA_SAMP_HI(asf1d.v1)); 1862 1863 if ((rate >= UA_SAMP_LO(asf1d.v1)) && 1864 (rate <= UA_SAMP_HI(asf1d.v1))) 1865 goto found_rate; 1866 } else { 1867 1868 for (x = 0; x < asf1d.v1->bSamFreqType; x++) { 1869 DPRINTFN(16, "Sample rate = %dHz\n", 1870 UA_GETSAMP(asf1d.v1, x)); 1871 1872 if (rate == UA_GETSAMP(asf1d.v1, x)) 1873 goto found_rate; 1874 } 1875 } 1876 goto next_ep; 1877 1878 found_rate: 1879 for (p_fmt = uaudio10_formats; 1880 p_fmt->wFormat != 0; p_fmt++) { 1881 if ((p_fmt->wFormat == wFormat) && 1882 (p_fmt->bPrecision == bBitResolution)) 1883 break; 1884 } 1885 if (p_fmt->wFormat == 0) { 1886 DPRINTF("Unsupported audio format\n"); 1887 goto next_ep; 1888 } 1889 1890 if ((bChannels != channels) || 1891 (bBitResolution != bit_resolution)) { 1892 DPRINTF("Wrong number of channels\n"); 1893 goto next_ep; 1894 } 1895 } 1896 1897 chan = (ep_dir == UE_DIR_IN) ? 1898 &sc->sc_rec_chan : &sc->sc_play_chan; 1899 1900 if (usbd_get_iface(udev, curidx) == NULL) { 1901 DPRINTF("Interface is not valid\n"); 1902 goto next_ep; 1903 } 1904 if (chan->num_alt == CHAN_MAX_ALT) { 1905 DPRINTF("Too many alternate settings\n"); 1906 goto next_ep; 1907 } 1908 chan->set_alt = 0; 1909 chan->cur_alt = CHAN_MAX_ALT; 1910 1911 chan_alt = &chan->usb_alt[chan->num_alt++]; 1912 1913 #ifdef USB_DEBUG 1914 uaudio_chan_dump_ep_desc(ed1); 1915 #endif 1916 DPRINTF("Sample rate = %dHz, channels = %d, " 1917 "bits = %d, format = %s\n", rate, channels, 1918 bit_resolution, p_fmt->description); 1919 1920 chan_alt->sample_rate = rate; 1921 chan_alt->p_asf1d = asf1d; 1922 chan_alt->p_ed1 = ed1; 1923 chan_alt->p_fmt = p_fmt; 1924 chan_alt->p_sed = sed; 1925 chan_alt->iface_index = curidx; 1926 chan_alt->iface_alt_index = alt_index; 1927 1928 if (ep_dir == UE_DIR_IN) 1929 chan_alt->usb_cfg = uaudio_cfg_record; 1930 else 1931 chan_alt->usb_cfg = uaudio_cfg_play; 1932 1933 chan_alt->sample_size = (UAUDIO_MAX_CHAN(channels) * 1934 p_fmt->bPrecision) / 8; 1935 chan_alt->channels = channels; 1936 1937 if (ep_dir == UE_DIR_IN && 1938 usbd_get_speed(udev) == USB_SPEED_FULL) { 1939 uaudio_record_fix_fs(ed1, 1940 chan_alt->sample_size * (rate / 1000), 1941 chan_alt->sample_size * (rate / 4000)); 1942 } 1943 1944 /* setup play/record format */ 1945 1946 format = chan_alt->p_fmt->freebsd_fmt; 1947 1948 /* get default SND_FORMAT() */ 1949 format = SND_FORMAT(format, chan_alt->channels, 0); 1950 1951 switch (chan_alt->channels) { 1952 uint32_t temp_fmt; 1953 case 1: 1954 case 2: 1955 /* mono and stereo */ 1956 break; 1957 default: 1958 /* surround and more */ 1959 temp_fmt = feeder_matrix_default_format(format); 1960 /* if multichannel, then format can be zero */ 1961 if (temp_fmt != 0) 1962 format = temp_fmt; 1963 break; 1964 } 1965 1966 /* check if format is not supported */ 1967 if (format == 0) { 1968 DPRINTF("The selected audio format is not supported\n"); 1969 chan->num_alt--; 1970 goto next_ep; 1971 } 1972 if (chan->num_alt > 1) { 1973 /* we only accumulate one format at different sample rates */ 1974 if (chan->pcm_format[0] != format) { 1975 DPRINTF("Multiple formats is not supported\n"); 1976 chan->num_alt--; 1977 goto next_ep; 1978 } 1979 /* ignore if duplicate sample rate entry */ 1980 if (rate == chan->usb_alt[chan->num_alt - 2].sample_rate) { 1981 DPRINTF("Duplicate sample rate detected\n"); 1982 chan->num_alt--; 1983 goto next_ep; 1984 } 1985 } 1986 chan->pcm_cap.fmtlist = chan->pcm_format; 1987 chan->pcm_cap.fmtlist[0] = format; 1988 1989 /* check if device needs bitperfect */ 1990 if (chan_alt->channels > UAUDIO_MATRIX_MAX) 1991 sc->sc_pcm_bitperfect = 1; 1992 1993 if (rate < chan->pcm_cap.minspeed || chan->pcm_cap.minspeed == 0) 1994 chan->pcm_cap.minspeed = rate; 1995 if (rate > chan->pcm_cap.maxspeed || chan->pcm_cap.maxspeed == 0) 1996 chan->pcm_cap.maxspeed = rate; 1997 1998 if (sc->sc_sndstat_valid != 0) { 1999 sbuf_printf(&sc->sc_sndstat, "\n\t" 2000 "mode %d.%d:(%s) %dch, %dbit, %s, %dHz", 2001 curidx, alt_index, 2002 (ep_dir == UE_DIR_IN) ? "input" : "output", 2003 channels, p_fmt->bPrecision, 2004 p_fmt->description, rate); 2005 } 2006 2007 next_ep: 2008 sed.v1 = NULL; 2009 ed1 = NULL; 2010 } 2011 } 2012 2013 /* This structure defines all the supported rates. */ 2014 2015 static const uint32_t uaudio_rate_list[CHAN_MAX_ALT] = { 2016 384000, 2017 352800, 2018 192000, 2019 176400, 2020 96000, 2021 88200, 2022 88000, 2023 80000, 2024 72000, 2025 64000, 2026 56000, 2027 48000, 2028 44100, 2029 40000, 2030 32000, 2031 24000, 2032 22050, 2033 16000, 2034 11025, 2035 8000, 2036 0 2037 }; 2038 2039 static void 2040 uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev) 2041 { 2042 uint32_t rate = uaudio_default_rate; 2043 uint8_t z; 2044 uint8_t bits = uaudio_default_bits; 2045 uint8_t y; 2046 uint8_t channels = uaudio_default_channels; 2047 uint8_t x; 2048 2049 bits -= (bits % 8); 2050 if ((bits == 0) || (bits > 32)) { 2051 /* set a valid value */ 2052 bits = 32; 2053 } 2054 if (channels == 0) { 2055 switch (usbd_get_speed(udev)) { 2056 case USB_SPEED_LOW: 2057 case USB_SPEED_FULL: 2058 /* 2059 * Due to high bandwidth usage and problems 2060 * with HIGH-speed split transactions we 2061 * disable surround setups on FULL-speed USB 2062 * by default 2063 */ 2064 channels = 4; 2065 break; 2066 default: 2067 channels = UAUDIO_CHANNELS_MAX; 2068 break; 2069 } 2070 } else if (channels > UAUDIO_CHANNELS_MAX) 2071 channels = UAUDIO_CHANNELS_MAX; 2072 2073 if (sbuf_new(&sc->sc_sndstat, NULL, 4096, SBUF_AUTOEXTEND)) 2074 sc->sc_sndstat_valid = 1; 2075 2076 /* try to search for a valid config */ 2077 2078 for (x = channels; x; x--) { 2079 for (y = bits; y; y -= 8) { 2080 2081 /* try user defined rate, if any */ 2082 if (rate != 0) 2083 uaudio_chan_fill_info_sub(sc, udev, rate, x, y); 2084 2085 /* try find a matching rate, if any */ 2086 for (z = 0; uaudio_rate_list[z]; z++) 2087 uaudio_chan_fill_info_sub(sc, udev, uaudio_rate_list[z], x, y); 2088 } 2089 } 2090 if (sc->sc_sndstat_valid) 2091 sbuf_finish(&sc->sc_sndstat); 2092 } 2093 2094 static void 2095 uaudio_chan_play_sync_callback(struct usb_xfer *xfer, usb_error_t error) 2096 { 2097 struct uaudio_chan *ch = usbd_xfer_softc(xfer); 2098 struct usb_page_cache *pc; 2099 uint64_t sample_rate; 2100 uint8_t buf[4]; 2101 uint64_t temp; 2102 int len; 2103 int actlen; 2104 int nframes; 2105 2106 usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes); 2107 2108 switch (USB_GET_STATE(xfer)) { 2109 case USB_ST_TRANSFERRED: 2110 2111 DPRINTFN(6, "transferred %d bytes\n", actlen); 2112 2113 if (nframes == 0) 2114 break; 2115 len = usbd_xfer_frame_len(xfer, 0); 2116 if (len == 0) 2117 break; 2118 if (len > sizeof(buf)) 2119 len = sizeof(buf); 2120 2121 memset(buf, 0, sizeof(buf)); 2122 2123 pc = usbd_xfer_get_frame(xfer, 0); 2124 usbd_copy_out(pc, 0, buf, len); 2125 2126 temp = UGETDW(buf); 2127 2128 DPRINTF("Value = 0x%08x\n", (int)temp); 2129 2130 /* auto-detect SYNC format */ 2131 2132 if (len == 4) 2133 temp &= 0x0fffffff; 2134 2135 /* check for no data */ 2136 2137 if (temp == 0) 2138 break; 2139 2140 temp *= 125ULL; 2141 2142 sample_rate = ch->usb_alt[ch->cur_alt].sample_rate; 2143 2144 /* auto adjust */ 2145 while (temp < (sample_rate - (sample_rate / 4))) 2146 temp *= 2; 2147 2148 while (temp > (sample_rate + (sample_rate / 2))) 2149 temp /= 2; 2150 2151 DPRINTF("Comparing %d Hz :: %d Hz\n", 2152 (int)temp, (int)sample_rate); 2153 2154 /* 2155 * Use feedback value as fallback when there is no 2156 * recording channel: 2157 */ 2158 if (ch->priv_sc->sc_rec_chan.num_alt == 0) { 2159 int32_t jitter_max = howmany(sample_rate, 16000); 2160 2161 /* 2162 * Range check the jitter values to avoid 2163 * bogus sample rate adjustments. The expected 2164 * deviation should not be more than 1Hz per 2165 * second. The USB v2.0 specification also 2166 * mandates this requirement. Refer to chapter 2167 * 5.12.4.2 about feedback. 2168 */ 2169 ch->jitter_curr = temp - sample_rate; 2170 if (ch->jitter_curr > jitter_max) 2171 ch->jitter_curr = jitter_max; 2172 else if (ch->jitter_curr < -jitter_max) 2173 ch->jitter_curr = -jitter_max; 2174 } 2175 ch->feedback_rate = temp; 2176 break; 2177 2178 case USB_ST_SETUP: 2179 /* 2180 * Check if the recording stream can be used as a 2181 * source of jitter information to save some 2182 * isochronous bandwidth: 2183 */ 2184 if (ch->priv_sc->sc_rec_chan.num_alt != 0 && 2185 uaudio_debug == 0) 2186 break; 2187 usbd_xfer_set_frames(xfer, 1); 2188 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_framelen(xfer)); 2189 usbd_transfer_submit(xfer); 2190 break; 2191 2192 default: /* Error */ 2193 break; 2194 } 2195 } 2196 2197 static int 2198 uaudio_chan_is_async(struct uaudio_chan *ch, uint8_t alt) 2199 { 2200 uint8_t attr = ch->usb_alt[alt].p_ed1->bmAttributes; 2201 return (UE_GET_ISO_TYPE(attr) == UE_ISO_ASYNC); 2202 } 2203 2204 static void 2205 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error) 2206 { 2207 struct uaudio_chan *ch = usbd_xfer_softc(xfer); 2208 struct uaudio_chan *ch_rec; 2209 struct usb_page_cache *pc; 2210 uint32_t mfl; 2211 uint32_t total; 2212 uint32_t blockcount; 2213 uint32_t n; 2214 uint32_t offset; 2215 int sample_size; 2216 int actlen; 2217 int sumlen; 2218 2219 if (ch->running == 0 || ch->start == ch->end) { 2220 DPRINTF("not running or no buffer!\n"); 2221 return; 2222 } 2223 2224 /* check if there is a record channel */ 2225 if (ch->priv_sc->sc_rec_chan.num_alt > 0) 2226 ch_rec = &ch->priv_sc->sc_rec_chan; 2227 else 2228 ch_rec = NULL; 2229 2230 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 2231 2232 switch (USB_GET_STATE(xfer)) { 2233 case USB_ST_SETUP: 2234 tr_setup: 2235 if (ch_rec != NULL) { 2236 /* reset receive jitter counters */ 2237 mtx_lock(ch_rec->pcm_mtx); 2238 ch_rec->jitter_curr = 0; 2239 ch_rec->jitter_rem = 0; 2240 mtx_unlock(ch_rec->pcm_mtx); 2241 } 2242 2243 /* reset transmit jitter counters */ 2244 ch->jitter_curr = 0; 2245 ch->jitter_rem = 0; 2246 2247 /* FALLTHROUGH */ 2248 case USB_ST_TRANSFERRED: 2249 if (actlen < sumlen) { 2250 DPRINTF("short transfer, " 2251 "%d of %d bytes\n", actlen, sumlen); 2252 } 2253 chn_intr(ch->pcm_ch); 2254 2255 /* 2256 * Check for asynchronous playback endpoint and that 2257 * the playback endpoint is properly configured: 2258 */ 2259 if (ch_rec != NULL && 2260 uaudio_chan_is_async(ch, ch->cur_alt) != 0) { 2261 mtx_lock(ch_rec->pcm_mtx); 2262 if (ch_rec->cur_alt < ch_rec->num_alt) { 2263 int64_t tx_jitter; 2264 int64_t rx_rate; 2265 2266 /* translate receive jitter into transmit jitter */ 2267 tx_jitter = ch->usb_alt[ch->cur_alt].sample_rate; 2268 tx_jitter = (tx_jitter * ch_rec->jitter_curr) + 2269 ch->jitter_rem; 2270 2271 /* reset receive jitter counters */ 2272 ch_rec->jitter_curr = 0; 2273 ch_rec->jitter_rem = 0; 2274 2275 /* compute exact number of transmit jitter samples */ 2276 rx_rate = ch_rec->usb_alt[ch_rec->cur_alt].sample_rate; 2277 ch->jitter_curr += tx_jitter / rx_rate; 2278 ch->jitter_rem = tx_jitter % rx_rate; 2279 } 2280 mtx_unlock(ch_rec->pcm_mtx); 2281 } 2282 2283 /* start the SYNC transfer one time per second, if any */ 2284 ch->intr_counter += ch->intr_frames; 2285 if (ch->intr_counter >= ch->frames_per_second) { 2286 ch->intr_counter -= ch->frames_per_second; 2287 usbd_transfer_start(ch->xfer[UAUDIO_NCHANBUFS]); 2288 } 2289 2290 mfl = usbd_xfer_max_framelen(xfer); 2291 2292 if (ch->bytes_per_frame[1] > mfl) { 2293 DPRINTF("bytes per transfer, %d, " 2294 "exceeds maximum, %d!\n", 2295 ch->bytes_per_frame[1], 2296 mfl); 2297 break; 2298 } 2299 2300 blockcount = ch->intr_frames; 2301 2302 /* setup number of frames */ 2303 usbd_xfer_set_frames(xfer, blockcount); 2304 2305 /* get sample size */ 2306 sample_size = ch->usb_alt[ch->cur_alt].sample_size; 2307 2308 /* reset total length */ 2309 total = 0; 2310 2311 /* setup frame lengths */ 2312 for (n = 0; n != blockcount; n++) { 2313 uint32_t frame_len; 2314 2315 ch->sample_curr += ch->sample_rem; 2316 if (ch->sample_curr >= ch->frames_per_second) { 2317 ch->sample_curr -= ch->frames_per_second; 2318 frame_len = ch->bytes_per_frame[1]; 2319 } else { 2320 frame_len = ch->bytes_per_frame[0]; 2321 } 2322 2323 /* handle free running clock case */ 2324 if (ch->jitter_curr > 0 && 2325 (frame_len + sample_size) <= mfl) { 2326 DPRINTFN(6, "sending one sample more\n"); 2327 ch->jitter_curr--; 2328 frame_len += sample_size; 2329 } else if (ch->jitter_curr < 0 && 2330 frame_len >= sample_size) { 2331 DPRINTFN(6, "sending one sample less\n"); 2332 ch->jitter_curr++; 2333 frame_len -= sample_size; 2334 } 2335 usbd_xfer_set_frame_len(xfer, n, frame_len); 2336 total += frame_len; 2337 } 2338 2339 DPRINTFN(6, "transferring %d bytes\n", total); 2340 2341 offset = 0; 2342 2343 pc = usbd_xfer_get_frame(xfer, 0); 2344 while (total > 0) { 2345 2346 n = (ch->end - ch->cur); 2347 if (n > total) 2348 n = total; 2349 2350 usbd_copy_in(pc, offset, ch->cur, n); 2351 2352 total -= n; 2353 ch->cur += n; 2354 offset += n; 2355 2356 if (ch->cur >= ch->end) 2357 ch->cur = ch->start; 2358 } 2359 usbd_transfer_submit(xfer); 2360 break; 2361 2362 default: /* Error */ 2363 if (error != USB_ERR_CANCELLED) 2364 goto tr_setup; 2365 break; 2366 } 2367 } 2368 2369 static void 2370 uaudio_chan_record_sync_callback(struct usb_xfer *xfer, usb_error_t error) 2371 { 2372 /* TODO */ 2373 } 2374 2375 static void 2376 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error) 2377 { 2378 struct uaudio_chan *ch = usbd_xfer_softc(xfer); 2379 struct usb_page_cache *pc; 2380 uint32_t offset0; 2381 uint32_t mfl; 2382 int m; 2383 int n; 2384 int len; 2385 int actlen; 2386 int nframes; 2387 int expected_bytes; 2388 int sample_size; 2389 2390 if (ch->start == ch->end) { 2391 DPRINTF("no buffer!\n"); 2392 return; 2393 } 2394 2395 usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes); 2396 mfl = usbd_xfer_max_framelen(xfer); 2397 2398 switch (USB_GET_STATE(xfer)) { 2399 case USB_ST_TRANSFERRED: 2400 2401 offset0 = 0; 2402 pc = usbd_xfer_get_frame(xfer, 0); 2403 2404 /* try to compute the number of expected bytes */ 2405 ch->sample_curr += (ch->sample_rem * ch->intr_frames); 2406 2407 /* compute number of expected bytes */ 2408 expected_bytes = (ch->intr_frames * ch->bytes_per_frame[0]) + 2409 ((ch->sample_curr / ch->frames_per_second) * 2410 (ch->bytes_per_frame[1] - ch->bytes_per_frame[0])); 2411 2412 /* keep remainder */ 2413 ch->sample_curr %= ch->frames_per_second; 2414 2415 /* get current sample size */ 2416 sample_size = ch->usb_alt[ch->cur_alt].sample_size; 2417 2418 for (n = 0; n != nframes; n++) { 2419 uint32_t offset1 = offset0; 2420 2421 len = usbd_xfer_frame_len(xfer, n); 2422 2423 /* make sure we only receive complete samples */ 2424 len = len - (len % sample_size); 2425 2426 /* subtract bytes received from expected payload */ 2427 expected_bytes -= len; 2428 2429 /* don't receive data when not ready */ 2430 if (ch->running == 0 || ch->cur_alt != ch->set_alt) 2431 continue; 2432 2433 /* fill ring buffer with samples, if any */ 2434 while (len > 0) { 2435 2436 m = (ch->end - ch->cur); 2437 2438 if (m > len) 2439 m = len; 2440 2441 usbd_copy_out(pc, offset1, ch->cur, m); 2442 2443 len -= m; 2444 offset1 += m; 2445 ch->cur += m; 2446 2447 if (ch->cur >= ch->end) 2448 ch->cur = ch->start; 2449 } 2450 2451 offset0 += mfl; 2452 } 2453 2454 /* update current jitter */ 2455 ch->jitter_curr -= (expected_bytes / sample_size); 2456 2457 /* don't allow a huge amount of jitter to accumulate */ 2458 nframes = 2 * ch->intr_frames; 2459 2460 /* range check current jitter */ 2461 if (ch->jitter_curr < -nframes) 2462 ch->jitter_curr = -nframes; 2463 else if (ch->jitter_curr > nframes) 2464 ch->jitter_curr = nframes; 2465 2466 DPRINTFN(6, "transferred %d bytes, jitter %d samples\n", 2467 actlen, ch->jitter_curr); 2468 2469 if (ch->running != 0) 2470 chn_intr(ch->pcm_ch); 2471 2472 case USB_ST_SETUP: 2473 tr_setup: 2474 nframes = ch->intr_frames; 2475 2476 usbd_xfer_set_frames(xfer, nframes); 2477 for (n = 0; n != nframes; n++) 2478 usbd_xfer_set_frame_len(xfer, n, mfl); 2479 2480 usbd_transfer_submit(xfer); 2481 break; 2482 2483 default: /* Error */ 2484 if (error != USB_ERR_CANCELLED) 2485 goto tr_setup; 2486 break; 2487 } 2488 } 2489 2490 void * 2491 uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b, 2492 struct pcm_channel *c, int dir) 2493 { 2494 struct uaudio_chan *ch = ((dir == PCMDIR_PLAY) ? 2495 &sc->sc_play_chan : &sc->sc_rec_chan); 2496 uint32_t buf_size; 2497 uint8_t x; 2498 2499 /* store mutex and PCM channel */ 2500 2501 ch->pcm_ch = c; 2502 ch->pcm_mtx = c->lock; 2503 2504 /* compute worst case buffer */ 2505 2506 buf_size = 0; 2507 for (x = 0; x != ch->num_alt; x++) { 2508 uint32_t temp = uaudio_get_buffer_size(ch, x); 2509 if (temp > buf_size) 2510 buf_size = temp; 2511 } 2512 2513 /* allow double buffering */ 2514 buf_size *= 2; 2515 2516 DPRINTF("Worst case buffer is %d bytes\n", (int)buf_size); 2517 2518 ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO); 2519 if (ch->buf == NULL) 2520 goto error; 2521 if (sndbuf_setup(b, ch->buf, buf_size) != 0) 2522 goto error; 2523 2524 ch->start = ch->buf; 2525 ch->end = ch->buf + buf_size; 2526 ch->cur = ch->buf; 2527 ch->pcm_buf = b; 2528 ch->max_buf = buf_size; 2529 2530 if (ch->pcm_mtx == NULL) { 2531 DPRINTF("ERROR: PCM channels does not have a mutex!\n"); 2532 goto error; 2533 } 2534 return (ch); 2535 2536 error: 2537 uaudio_chan_free(ch); 2538 return (NULL); 2539 } 2540 2541 int 2542 uaudio_chan_free(struct uaudio_chan *ch) 2543 { 2544 if (ch->buf != NULL) { 2545 free(ch->buf, M_DEVBUF); 2546 ch->buf = NULL; 2547 } 2548 usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS + 1); 2549 2550 ch->num_alt = 0; 2551 2552 return (0); 2553 } 2554 2555 int 2556 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize) 2557 { 2558 uint32_t temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt); 2559 sndbuf_setup(ch->pcm_buf, ch->buf, temp); 2560 return (temp / 2); 2561 } 2562 2563 int 2564 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize, 2565 uint32_t blockcount) 2566 { 2567 return (1); 2568 } 2569 2570 int 2571 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed) 2572 { 2573 struct uaudio_softc *sc; 2574 uint8_t x; 2575 2576 sc = ch->priv_sc; 2577 2578 for (x = 0; x < ch->num_alt; x++) { 2579 if (ch->usb_alt[x].sample_rate < speed) { 2580 /* sample rate is too low */ 2581 break; 2582 } 2583 } 2584 2585 if (x != 0) 2586 x--; 2587 2588 usb_proc_explore_lock(sc->sc_udev); 2589 ch->set_alt = x; 2590 usb_proc_explore_unlock(sc->sc_udev); 2591 2592 DPRINTF("Selecting alt %d\n", (int)x); 2593 2594 return (ch->usb_alt[x].sample_rate); 2595 } 2596 2597 int 2598 uaudio_chan_getptr(struct uaudio_chan *ch) 2599 { 2600 return (ch->cur - ch->start); 2601 } 2602 2603 struct pcmchan_caps * 2604 uaudio_chan_getcaps(struct uaudio_chan *ch) 2605 { 2606 return (&ch->pcm_cap); 2607 } 2608 2609 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = { 2610 .id = SND_CHN_MATRIX_DRV, 2611 .channels = 2, 2612 .ext = 0, 2613 .map = { 2614 /* Right */ 2615 [0] = { 2616 .type = SND_CHN_T_FR, 2617 .members = 2618 SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC | 2619 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR | 2620 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR 2621 }, 2622 /* Left */ 2623 [1] = { 2624 .type = SND_CHN_T_FL, 2625 .members = 2626 SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC | 2627 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL | 2628 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL 2629 }, 2630 [2] = { 2631 .type = SND_CHN_T_MAX, 2632 .members = 0 2633 } 2634 }, 2635 .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL, 2636 .offset = { 1, 0, -1, -1, -1, -1, -1, -1, -1, 2637 -1, -1, -1, -1, -1, -1, -1, -1, -1 } 2638 }; 2639 2640 struct pcmchan_matrix * 2641 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format) 2642 { 2643 struct uaudio_softc *sc; 2644 2645 sc = ch->priv_sc; 2646 2647 if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 && 2648 AFMT_CHANNEL(format) == 2) 2649 return (&uaudio_chan_matrix_swap_2_0); 2650 2651 return (feeder_matrix_format_map(format)); 2652 } 2653 2654 int 2655 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format) 2656 { 2657 DPRINTF("Selecting format 0x%08x\n", (unsigned int)format); 2658 return (0); 2659 } 2660 2661 static void 2662 uaudio_chan_start_sub(struct uaudio_chan *ch) 2663 { 2664 struct uaudio_softc *sc = ch->priv_sc; 2665 int do_start = 0; 2666 2667 if (ch->operation != CHAN_OP_DRAIN) { 2668 if (ch->cur_alt == ch->set_alt && 2669 ch->operation == CHAN_OP_NONE && 2670 mtx_owned(ch->pcm_mtx) != 0) { 2671 /* save doing the explore task */ 2672 do_start = 1; 2673 } else { 2674 ch->operation = CHAN_OP_START; 2675 (void)usb_proc_explore_msignal(sc->sc_udev, 2676 &sc->sc_config_msg[0], &sc->sc_config_msg[1]); 2677 } 2678 } 2679 if (do_start) { 2680 usbd_transfer_start(ch->xfer[0]); 2681 usbd_transfer_start(ch->xfer[1]); 2682 } 2683 } 2684 2685 static int 2686 uaudio_chan_need_both(struct uaudio_softc *sc) 2687 { 2688 return (sc->sc_play_chan.num_alt > 0 && 2689 sc->sc_play_chan.running != 0 && 2690 uaudio_chan_is_async(&sc->sc_play_chan, 2691 sc->sc_play_chan.set_alt) != 0 && 2692 sc->sc_rec_chan.num_alt > 0 && 2693 sc->sc_rec_chan.running == 0); 2694 } 2695 2696 static int 2697 uaudio_chan_need_none(struct uaudio_softc *sc) 2698 { 2699 return (sc->sc_play_chan.num_alt > 0 && 2700 sc->sc_play_chan.running == 0 && 2701 sc->sc_rec_chan.num_alt > 0 && 2702 sc->sc_rec_chan.running == 0); 2703 } 2704 2705 void 2706 uaudio_chan_start(struct uaudio_chan *ch) 2707 { 2708 struct uaudio_softc *sc = ch->priv_sc; 2709 2710 /* make operation atomic */ 2711 usb_proc_explore_lock(sc->sc_udev); 2712 2713 /* check if not running */ 2714 if (ch->running == 0) { 2715 uint32_t temp; 2716 2717 /* get current buffer size */ 2718 temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt); 2719 2720 /* set running flag */ 2721 ch->running = 1; 2722 2723 /* ensure the hardware buffer is reset */ 2724 ch->start = ch->buf; 2725 ch->end = ch->buf + temp; 2726 ch->cur = ch->buf; 2727 2728 if (uaudio_chan_need_both(sc)) { 2729 /* 2730 * Start both endpoints because of need for 2731 * jitter information: 2732 */ 2733 uaudio_chan_start_sub(&sc->sc_rec_chan); 2734 uaudio_chan_start_sub(&sc->sc_play_chan); 2735 } else { 2736 uaudio_chan_start_sub(ch); 2737 } 2738 } 2739 2740 /* exit atomic operation */ 2741 usb_proc_explore_unlock(sc->sc_udev); 2742 } 2743 2744 static void 2745 uaudio_chan_stop_sub(struct uaudio_chan *ch) 2746 { 2747 struct uaudio_softc *sc = ch->priv_sc; 2748 int do_stop = 0; 2749 2750 if (ch->operation != CHAN_OP_DRAIN) { 2751 if (ch->cur_alt == ch->set_alt && 2752 ch->operation == CHAN_OP_NONE && 2753 mtx_owned(ch->pcm_mtx) != 0) { 2754 /* save doing the explore task */ 2755 do_stop = 1; 2756 } else { 2757 ch->operation = CHAN_OP_STOP; 2758 (void)usb_proc_explore_msignal(sc->sc_udev, 2759 &sc->sc_config_msg[0], &sc->sc_config_msg[1]); 2760 } 2761 } 2762 if (do_stop) { 2763 usbd_transfer_stop(ch->xfer[0]); 2764 usbd_transfer_stop(ch->xfer[1]); 2765 } 2766 } 2767 2768 void 2769 uaudio_chan_stop(struct uaudio_chan *ch) 2770 { 2771 struct uaudio_softc *sc = ch->priv_sc; 2772 2773 /* make operation atomic */ 2774 usb_proc_explore_lock(sc->sc_udev); 2775 2776 /* check if running */ 2777 if (ch->running != 0) { 2778 /* clear running flag */ 2779 ch->running = 0; 2780 2781 if (uaudio_chan_need_both(sc)) { 2782 /* 2783 * Leave the endpoints running because we need 2784 * information about jitter! 2785 */ 2786 } else if (uaudio_chan_need_none(sc)) { 2787 /* 2788 * Stop both endpoints in case the one was used for 2789 * jitter information: 2790 */ 2791 uaudio_chan_stop_sub(&sc->sc_rec_chan); 2792 uaudio_chan_stop_sub(&sc->sc_play_chan); 2793 } else { 2794 uaudio_chan_stop_sub(ch); 2795 } 2796 } 2797 2798 /* exit atomic operation */ 2799 usb_proc_explore_unlock(sc->sc_udev); 2800 } 2801 2802 /*========================================================================* 2803 * AC - Audio Controller - routines 2804 *========================================================================*/ 2805 2806 static int 2807 uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS) 2808 { 2809 struct uaudio_softc *sc; 2810 struct uaudio_mixer_node *pmc; 2811 int hint; 2812 int error; 2813 int temp = 0; 2814 int chan = 0; 2815 2816 sc = (struct uaudio_softc *)oidp->oid_arg1; 2817 hint = oidp->oid_arg2; 2818 2819 if (sc->sc_mixer_lock == NULL) 2820 return (ENXIO); 2821 2822 /* lookup mixer node */ 2823 2824 mtx_lock(sc->sc_mixer_lock); 2825 for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) { 2826 for (chan = 0; chan != (int)pmc->nchan; chan++) { 2827 if (pmc->wValue[chan] != -1 && 2828 pmc->wValue[chan] == hint) { 2829 temp = pmc->wData[chan]; 2830 goto found; 2831 } 2832 } 2833 } 2834 found: 2835 mtx_unlock(sc->sc_mixer_lock); 2836 2837 error = sysctl_handle_int(oidp, &temp, 0, req); 2838 if (error != 0 || req->newptr == NULL) 2839 return (error); 2840 2841 /* update mixer value */ 2842 2843 mtx_lock(sc->sc_mixer_lock); 2844 if (pmc != NULL && 2845 temp >= pmc->minval && 2846 temp <= pmc->maxval) { 2847 2848 pmc->wData[chan] = temp; 2849 pmc->update[(chan / 8)] |= (1 << (chan % 8)); 2850 2851 /* start the transfer, if not already started */ 2852 usbd_transfer_start(sc->sc_mixer_xfer[0]); 2853 } 2854 mtx_unlock(sc->sc_mixer_lock); 2855 2856 return (0); 2857 } 2858 2859 static void 2860 uaudio_mixer_ctl_free(struct uaudio_softc *sc) 2861 { 2862 struct uaudio_mixer_node *p_mc; 2863 2864 while ((p_mc = sc->sc_mixer_root) != NULL) { 2865 sc->sc_mixer_root = p_mc->next; 2866 free(p_mc, M_USBDEV); 2867 } 2868 } 2869 2870 static void 2871 uaudio_mixer_register_sysctl(struct uaudio_softc *sc, device_t dev) 2872 { 2873 struct uaudio_mixer_node *pmc; 2874 struct sysctl_oid *mixer_tree; 2875 struct sysctl_oid *control_tree; 2876 char buf[32]; 2877 int chan; 2878 int n; 2879 2880 mixer_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev), 2881 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "mixer", 2882 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, ""); 2883 2884 if (mixer_tree == NULL) 2885 return; 2886 2887 for (n = 0, pmc = sc->sc_mixer_root; pmc != NULL; 2888 pmc = pmc->next, n++) { 2889 2890 for (chan = 0; chan < pmc->nchan; chan++) { 2891 2892 if (pmc->nchan > 1) { 2893 snprintf(buf, sizeof(buf), "%s_%d_%d", 2894 pmc->name, n, chan); 2895 } else { 2896 snprintf(buf, sizeof(buf), "%s_%d", 2897 pmc->name, n); 2898 } 2899 2900 control_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev), 2901 SYSCTL_CHILDREN(mixer_tree), OID_AUTO, buf, 2902 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 2903 "Mixer control nodes"); 2904 2905 if (control_tree == NULL) 2906 continue; 2907 2908 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 2909 SYSCTL_CHILDREN(control_tree), 2910 OID_AUTO, "val", 2911 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 2912 sc, pmc->wValue[chan], 2913 uaudio_mixer_sysctl_handler, "I", "Current value"); 2914 2915 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 2916 SYSCTL_CHILDREN(control_tree), 2917 OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval, 2918 "Minimum value"); 2919 2920 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 2921 SYSCTL_CHILDREN(control_tree), 2922 OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval, 2923 "Maximum value"); 2924 2925 SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev), 2926 SYSCTL_CHILDREN(control_tree), 2927 OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0, 2928 "Description"); 2929 } 2930 } 2931 } 2932 2933 /* M-Audio FastTrack Ultra Mixer Description */ 2934 /* Origin: Linux USB Audio driver */ 2935 static void 2936 uaudio_mixer_controls_create_ftu(struct uaudio_softc *sc) 2937 { 2938 int chx; 2939 int chy; 2940 2941 memset(&MIX(sc), 0, sizeof(MIX(sc))); 2942 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no); 2943 MIX(sc).wValue[0] = MAKE_WORD(8, 0); 2944 MIX(sc).type = MIX_UNSIGNED_16; 2945 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 2946 MIX(sc).name = "effect"; 2947 MIX(sc).minval = 0; 2948 MIX(sc).maxval = 7; 2949 MIX(sc).mul = 7; 2950 MIX(sc).nchan = 1; 2951 MIX(sc).update[0] = 1; 2952 strlcpy(MIX(sc).desc, "Room1,2,3,Hall1,2,Plate,Delay,Echo", sizeof(MIX(sc).desc)); 2953 uaudio_mixer_add_ctl_sub(sc, &MIX(sc)); 2954 2955 memset(&MIX(sc), 0, sizeof(MIX(sc))); 2956 MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no); 2957 2958 for (chx = 0; chx != 8; chx++) { 2959 for (chy = 0; chy != 8; chy++) { 2960 2961 MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1); 2962 MIX(sc).type = MIX_SIGNED_16; 2963 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 2964 MIX(sc).name = "mix_rec"; 2965 MIX(sc).nchan = 1; 2966 MIX(sc).update[0] = 1; 2967 MIX(sc).val_default = 0; 2968 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 2969 "AIn%d - Out%d Record Volume", chy + 1, chx + 1); 2970 2971 uaudio_mixer_add_ctl(sc, &MIX(sc)); 2972 2973 MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1 + 8); 2974 MIX(sc).type = MIX_SIGNED_16; 2975 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 2976 MIX(sc).name = "mix_play"; 2977 MIX(sc).nchan = 1; 2978 MIX(sc).update[0] = 1; 2979 MIX(sc).val_default = (chx == chy) ? 2 : 0; 2980 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 2981 "DIn%d - Out%d Playback Volume", chy + 1, chx + 1); 2982 2983 uaudio_mixer_add_ctl(sc, &MIX(sc)); 2984 } 2985 } 2986 2987 memset(&MIX(sc), 0, sizeof(MIX(sc))); 2988 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no); 2989 MIX(sc).wValue[0] = MAKE_WORD(2, 0); 2990 MIX(sc).type = MIX_SIGNED_8; 2991 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 2992 MIX(sc).name = "effect_vol"; 2993 MIX(sc).nchan = 1; 2994 MIX(sc).update[0] = 1; 2995 MIX(sc).minval = 0; 2996 MIX(sc).maxval = 0x7f; 2997 MIX(sc).mul = 0x7f; 2998 MIX(sc).nchan = 1; 2999 MIX(sc).update[0] = 1; 3000 strlcpy(MIX(sc).desc, "Effect Volume", sizeof(MIX(sc).desc)); 3001 uaudio_mixer_add_ctl_sub(sc, &MIX(sc)); 3002 3003 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3004 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no); 3005 MIX(sc).wValue[0] = MAKE_WORD(3, 0); 3006 MIX(sc).type = MIX_SIGNED_16; 3007 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3008 MIX(sc).name = "effect_dur"; 3009 MIX(sc).nchan = 1; 3010 MIX(sc).update[0] = 1; 3011 MIX(sc).minval = 0; 3012 MIX(sc).maxval = 0x7f00; 3013 MIX(sc).mul = 0x7f00; 3014 MIX(sc).nchan = 1; 3015 MIX(sc).update[0] = 1; 3016 strlcpy(MIX(sc).desc, "Effect Duration", sizeof(MIX(sc).desc)); 3017 uaudio_mixer_add_ctl_sub(sc, &MIX(sc)); 3018 3019 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3020 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no); 3021 MIX(sc).wValue[0] = MAKE_WORD(4, 0); 3022 MIX(sc).type = MIX_SIGNED_8; 3023 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3024 MIX(sc).name = "effect_fb"; 3025 MIX(sc).nchan = 1; 3026 MIX(sc).update[0] = 1; 3027 MIX(sc).minval = 0; 3028 MIX(sc).maxval = 0x7f; 3029 MIX(sc).mul = 0x7f; 3030 MIX(sc).nchan = 1; 3031 MIX(sc).update[0] = 1; 3032 strlcpy(MIX(sc).desc, "Effect Feedback Volume", sizeof(MIX(sc).desc)); 3033 uaudio_mixer_add_ctl_sub(sc, &MIX(sc)); 3034 3035 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3036 MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no); 3037 for (chy = 0; chy != 4; chy++) { 3038 3039 MIX(sc).wValue[0] = MAKE_WORD(7, chy + 1); 3040 MIX(sc).type = MIX_SIGNED_16; 3041 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3042 MIX(sc).name = "effect_ret"; 3043 MIX(sc).nchan = 1; 3044 MIX(sc).update[0] = 1; 3045 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 3046 "Effect Return %d Volume", chy + 1); 3047 3048 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3049 } 3050 3051 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3052 MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no); 3053 3054 for (chy = 0; chy != 8; chy++) { 3055 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1); 3056 MIX(sc).type = MIX_SIGNED_16; 3057 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3058 MIX(sc).name = "effect_send"; 3059 MIX(sc).nchan = 1; 3060 MIX(sc).update[0] = 1; 3061 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 3062 "Effect Send AIn%d Volume", chy + 1); 3063 3064 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3065 3066 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1 + 8); 3067 MIX(sc).type = MIX_SIGNED_16; 3068 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3069 MIX(sc).name = "effect_send"; 3070 MIX(sc).nchan = 1; 3071 MIX(sc).update[0] = 1; 3072 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 3073 "Effect Send DIn%d Volume", chy + 1); 3074 3075 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3076 } 3077 } 3078 3079 static void 3080 uaudio_mixer_reload_all(struct uaudio_softc *sc) 3081 { 3082 struct uaudio_mixer_node *pmc; 3083 int chan; 3084 3085 if (sc->sc_mixer_lock == NULL) 3086 return; 3087 3088 mtx_lock(sc->sc_mixer_lock); 3089 for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) { 3090 /* use reset defaults for non-oss controlled settings */ 3091 if (pmc->ctl == SOUND_MIXER_NRDEVICES) 3092 continue; 3093 for (chan = 0; chan < pmc->nchan; chan++) 3094 pmc->update[chan / 8] |= (1 << (chan % 8)); 3095 } 3096 usbd_transfer_start(sc->sc_mixer_xfer[0]); 3097 3098 /* start HID volume keys, if any */ 3099 usbd_transfer_start(sc->sc_hid.xfer[0]); 3100 mtx_unlock(sc->sc_mixer_lock); 3101 } 3102 3103 static void 3104 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc) 3105 { 3106 struct uaudio_mixer_node *p_mc_new = 3107 malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK); 3108 int ch; 3109 3110 if (p_mc_new != NULL) { 3111 memcpy(p_mc_new, mc, sizeof(*p_mc_new)); 3112 p_mc_new->next = sc->sc_mixer_root; 3113 sc->sc_mixer_root = p_mc_new; 3114 sc->sc_mixer_count++; 3115 3116 /* set default value for all channels */ 3117 for (ch = 0; ch < p_mc_new->nchan; ch++) { 3118 switch (p_mc_new->val_default) { 3119 case 1: 3120 /* 50% */ 3121 p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2; 3122 break; 3123 case 2: 3124 /* 100% */ 3125 p_mc_new->wData[ch] = p_mc_new->maxval; 3126 break; 3127 default: 3128 /* 0% */ 3129 p_mc_new->wData[ch] = p_mc_new->minval; 3130 break; 3131 } 3132 } 3133 } else { 3134 DPRINTF("out of memory\n"); 3135 } 3136 } 3137 3138 static void 3139 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc) 3140 { 3141 int32_t res; 3142 3143 DPRINTF("adding %d\n", mc->ctl); 3144 3145 if (mc->type == MIX_ON_OFF) { 3146 mc->minval = 0; 3147 mc->maxval = 1; 3148 } else if (mc->type == MIX_SELECTOR) { 3149 } else { 3150 3151 /* determine min and max values */ 3152 3153 mc->minval = uaudio_mixer_get(sc->sc_udev, 3154 sc->sc_audio_rev, GET_MIN, mc); 3155 mc->maxval = uaudio_mixer_get(sc->sc_udev, 3156 sc->sc_audio_rev, GET_MAX, mc); 3157 3158 /* check if max and min was swapped */ 3159 3160 if (mc->maxval < mc->minval) { 3161 res = mc->maxval; 3162 mc->maxval = mc->minval; 3163 mc->minval = res; 3164 } 3165 3166 /* compute value range */ 3167 mc->mul = mc->maxval - mc->minval; 3168 if (mc->mul == 0) 3169 mc->mul = 1; 3170 3171 /* compute value alignment */ 3172 res = uaudio_mixer_get(sc->sc_udev, 3173 sc->sc_audio_rev, GET_RES, mc); 3174 3175 DPRINTF("Resolution = %d\n", (int)res); 3176 } 3177 3178 uaudio_mixer_add_ctl_sub(sc, mc); 3179 3180 #ifdef USB_DEBUG 3181 if (uaudio_debug > 2) { 3182 uint8_t i; 3183 3184 for (i = 0; i < mc->nchan; i++) { 3185 DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]); 3186 } 3187 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' " 3188 "min=%d max=%d\n", 3189 mc->wIndex, mc->type, mc->ctl, 3190 mc->minval, mc->maxval); 3191 } 3192 #endif 3193 } 3194 3195 static void 3196 uaudio_mixer_add_mixer(struct uaudio_softc *sc, 3197 const struct uaudio_terminal_node *iot, int id) 3198 { 3199 const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu_v1; 3200 const struct usb_audio_mixer_unit_1 *d1; 3201 3202 uint32_t bno; /* bit number */ 3203 uint32_t p; /* bit number accumulator */ 3204 uint32_t mo; /* matching outputs */ 3205 uint32_t mc; /* matching channels */ 3206 uint32_t ichs; /* input channels */ 3207 uint32_t ochs; /* output channels */ 3208 uint32_t c; 3209 uint32_t chs; /* channels */ 3210 uint32_t i; 3211 uint32_t o; 3212 3213 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3214 d0->bUnitId, d0->bNrInPins); 3215 3216 /* compute the number of input channels */ 3217 3218 ichs = 0; 3219 for (i = 0; i < d0->bNrInPins; i++) { 3220 ichs += uaudio_mixer_get_cluster( 3221 d0->baSourceId[i], iot).bNrChannels; 3222 } 3223 3224 d1 = (const void *)(d0->baSourceId + d0->bNrInPins); 3225 3226 /* and the number of output channels */ 3227 3228 ochs = d1->bNrChannels; 3229 3230 DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs); 3231 3232 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3233 3234 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 3235 MIX(sc).type = MIX_SIGNED_16; 3236 3237 if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL) 3238 return; 3239 3240 for (p = i = 0; i < d0->bNrInPins; i++) { 3241 chs = uaudio_mixer_get_cluster( 3242 d0->baSourceId[i], iot).bNrChannels; 3243 mc = 0; 3244 for (c = 0; c < chs; c++) { 3245 mo = 0; 3246 for (o = 0; o < ochs; o++) { 3247 bno = ((p + c) * ochs) + o; 3248 if (BIT_TEST(d1->bmControls, bno)) 3249 mo++; 3250 } 3251 if (mo == 1) 3252 mc++; 3253 } 3254 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) { 3255 3256 /* repeat bit-scan */ 3257 3258 mc = 0; 3259 for (c = 0; c < chs; c++) { 3260 for (o = 0; o < ochs; o++) { 3261 bno = ((p + c) * ochs) + o; 3262 if (BIT_TEST(d1->bmControls, bno)) 3263 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1); 3264 } 3265 } 3266 MIX(sc).nchan = chs; 3267 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3268 } 3269 p += chs; 3270 } 3271 } 3272 3273 static void 3274 uaudio20_mixer_add_mixer(struct uaudio_softc *sc, 3275 const struct uaudio_terminal_node *iot, int id) 3276 { 3277 const struct usb_audio20_mixer_unit_0 *d0 = iot[id].u.mu_v2; 3278 const struct usb_audio20_mixer_unit_1 *d1; 3279 3280 uint32_t bno; /* bit number */ 3281 uint32_t p; /* bit number accumulator */ 3282 uint32_t mo; /* matching outputs */ 3283 uint32_t mc; /* matching channels */ 3284 uint32_t ichs; /* input channels */ 3285 uint32_t ochs; /* output channels */ 3286 uint32_t c; 3287 uint32_t chs; /* channels */ 3288 uint32_t i; 3289 uint32_t o; 3290 3291 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3292 d0->bUnitId, d0->bNrInPins); 3293 3294 /* compute the number of input channels */ 3295 3296 ichs = 0; 3297 for (i = 0; i < d0->bNrInPins; i++) { 3298 ichs += uaudio20_mixer_get_cluster( 3299 d0->baSourceId[i], iot).bNrChannels; 3300 } 3301 3302 d1 = (const void *)(d0->baSourceId + d0->bNrInPins); 3303 3304 /* and the number of output channels */ 3305 3306 ochs = d1->bNrChannels; 3307 3308 DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs); 3309 3310 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3311 3312 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 3313 MIX(sc).type = MIX_SIGNED_16; 3314 3315 if (uaudio20_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL) 3316 return; 3317 3318 for (p = i = 0; i < d0->bNrInPins; i++) { 3319 chs = uaudio20_mixer_get_cluster( 3320 d0->baSourceId[i], iot).bNrChannels; 3321 mc = 0; 3322 for (c = 0; c < chs; c++) { 3323 mo = 0; 3324 for (o = 0; o < ochs; o++) { 3325 bno = ((p + c) * ochs) + o; 3326 if (BIT_TEST(d1->bmControls, bno)) 3327 mo++; 3328 } 3329 if (mo == 1) 3330 mc++; 3331 } 3332 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) { 3333 3334 /* repeat bit-scan */ 3335 3336 mc = 0; 3337 for (c = 0; c < chs; c++) { 3338 for (o = 0; o < ochs; o++) { 3339 bno = ((p + c) * ochs) + o; 3340 if (BIT_TEST(d1->bmControls, bno)) 3341 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1); 3342 } 3343 } 3344 MIX(sc).nchan = chs; 3345 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3346 } 3347 p += chs; 3348 } 3349 } 3350 3351 static void 3352 uaudio_mixer_check_selectors(struct uaudio_softc *sc) 3353 { 3354 uint8_t reserve_feature[] = { 3355 SOUND_MIXER_LINE, 3356 SOUND_MIXER_LINE1, 3357 SOUND_MIXER_LINE2, 3358 SOUND_MIXER_LINE3, 3359 SOUND_MIXER_DIGITAL1, 3360 SOUND_MIXER_DIGITAL2, 3361 SOUND_MIXER_DIGITAL3, 3362 }; 3363 const uint16_t reserve_max = 3364 sizeof(reserve_feature) / sizeof(reserve_feature[0]); 3365 uint16_t i; 3366 uint16_t j; 3367 uint16_t k; 3368 3369 /* remove existing selector types from the reserve */ 3370 for (i = 0; i < MIX(sc).maxval; i++) { 3371 if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES) 3372 continue; 3373 for (j = 0; j != reserve_max; j++) { 3374 if (reserve_feature[j] == MIX(sc).slctrtype[i]) 3375 reserve_feature[j] = SOUND_MIXER_NRDEVICES; 3376 } 3377 } 3378 3379 /* make sure selector types are not overlapping */ 3380 for (i = 0; i < MIX(sc).maxval; i++) { 3381 if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES) 3382 continue; 3383 for (j = i + 1; j < MIX(sc).maxval; j++) { 3384 if (MIX(sc).slctrtype[j] == SOUND_MIXER_NRDEVICES) 3385 continue; 3386 if (MIX(sc).slctrtype[i] != MIX(sc).slctrtype[j]) 3387 continue; 3388 for (k = 0; k != reserve_max; k++) { 3389 if (reserve_feature[k] == SOUND_MIXER_NRDEVICES) 3390 continue; 3391 MIX(sc).slctrtype[j] = reserve_feature[k]; 3392 reserve_feature[k] = SOUND_MIXER_NRDEVICES; 3393 break; 3394 } 3395 if (k == reserve_max) { 3396 DPRINTF("Selector type %d is not selectable!\n", j); 3397 MIX(sc).slctrtype[j] = SOUND_MIXER_NRDEVICES; 3398 } 3399 } 3400 } 3401 } 3402 3403 static void 3404 uaudio_mixer_add_selector(struct uaudio_softc *sc, 3405 const struct uaudio_terminal_node *iot, int id) 3406 { 3407 const struct usb_audio_selector_unit *d = iot[id].u.su_v1; 3408 uint16_t i; 3409 3410 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3411 d->bUnitId, d->bNrInPins); 3412 3413 if (d->bNrInPins == 0) 3414 return; 3415 3416 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3417 3418 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 3419 MIX(sc).wValue[0] = MAKE_WORD(0, 0); 3420 MIX(sc).nchan = 1; 3421 MIX(sc).type = MIX_SELECTOR; 3422 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3423 MIX(sc).minval = 1; 3424 MIX(sc).maxval = d->bNrInPins; 3425 MIX(sc).name = "selector"; 3426 3427 i = d->baSourceId[d->bNrInPins]; 3428 if (i == 0 || 3429 usbd_req_get_string_any(sc->sc_udev, NULL, 3430 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) { 3431 MIX(sc).desc[0] = 0; 3432 } 3433 3434 if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN) 3435 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN; 3436 3437 MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval; 3438 3439 for (i = 0; i < MIX(sc).maxval; i++) { 3440 MIX(sc).slctrtype[i] = 3441 uaudio_mixer_determine_class(&iot[d->baSourceId[i]]); 3442 } 3443 for (; i < MAX_SELECTOR_INPUT_PIN; i++) 3444 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES; 3445 3446 uaudio_mixer_check_selectors(sc); 3447 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3448 } 3449 3450 static void 3451 uaudio20_mixer_add_selector(struct uaudio_softc *sc, 3452 const struct uaudio_terminal_node *iot, int id) 3453 { 3454 const struct usb_audio20_selector_unit *d = iot[id].u.su_v2; 3455 uint16_t i; 3456 3457 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3458 d->bUnitId, d->bNrInPins); 3459 3460 if (d->bNrInPins == 0) 3461 return; 3462 3463 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3464 3465 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 3466 MIX(sc).wValue[0] = MAKE_WORD(0, 0); 3467 MIX(sc).nchan = 1; 3468 MIX(sc).type = MIX_SELECTOR; 3469 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3470 MIX(sc).minval = 1; 3471 MIX(sc).maxval = d->bNrInPins; 3472 MIX(sc).name = "selector"; 3473 3474 i = d->baSourceId[d->bNrInPins]; 3475 if (i == 0 || 3476 usbd_req_get_string_any(sc->sc_udev, NULL, 3477 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) { 3478 MIX(sc).desc[0] = 0; 3479 } 3480 3481 if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN) 3482 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN; 3483 3484 MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval; 3485 3486 for (i = 0; i < MIX(sc).maxval; i++) { 3487 MIX(sc).slctrtype[i] = 3488 uaudio20_mixer_determine_class(&iot[d->baSourceId[i]]); 3489 } 3490 for (; i < MAX_SELECTOR_INPUT_PIN; i++) 3491 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES; 3492 3493 uaudio_mixer_check_selectors(sc); 3494 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3495 } 3496 3497 static uint32_t 3498 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d, 3499 uint8_t i) 3500 { 3501 uint32_t temp = 0; 3502 uint32_t offset = (i * d->bControlSize); 3503 3504 if (d->bControlSize > 0) { 3505 temp |= d->bmaControls[offset]; 3506 if (d->bControlSize > 1) { 3507 temp |= d->bmaControls[offset + 1] << 8; 3508 if (d->bControlSize > 2) { 3509 temp |= d->bmaControls[offset + 2] << 16; 3510 if (d->bControlSize > 3) { 3511 temp |= d->bmaControls[offset + 3] << 24; 3512 } 3513 } 3514 } 3515 } 3516 return (temp); 3517 } 3518 3519 static void 3520 uaudio_mixer_add_feature(struct uaudio_softc *sc, 3521 const struct uaudio_terminal_node *iot, int id) 3522 { 3523 const struct usb_audio_feature_unit *d = iot[id].u.fu_v1; 3524 uint32_t fumask; 3525 uint32_t mmask; 3526 uint32_t cmask; 3527 uint16_t mixernumber; 3528 uint8_t nchan; 3529 uint8_t chan; 3530 uint8_t ctl; 3531 uint8_t i; 3532 3533 if (d->bControlSize == 0) 3534 return; 3535 3536 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3537 3538 nchan = (d->bLength - 7) / d->bControlSize; 3539 mmask = uaudio_mixer_feature_get_bmaControls(d, 0); 3540 cmask = 0; 3541 3542 if (nchan == 0) 3543 return; 3544 3545 /* figure out what we can control */ 3546 3547 for (chan = 1; chan < nchan; chan++) { 3548 DPRINTFN(10, "chan=%d mask=%x\n", 3549 chan, uaudio_mixer_feature_get_bmaControls(d, chan)); 3550 3551 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan); 3552 } 3553 3554 if (nchan > MIX_MAX_CHAN) 3555 nchan = MIX_MAX_CHAN; 3556 3557 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 3558 3559 i = d->bmaControls[d->bControlSize]; 3560 if (i == 0 || 3561 usbd_req_get_string_any(sc->sc_udev, NULL, 3562 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) { 3563 MIX(sc).desc[0] = 0; 3564 } 3565 3566 for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) { 3567 3568 fumask = FU_MASK(ctl); 3569 3570 DPRINTFN(5, "ctl=%d fumask=0x%04x\n", 3571 ctl, fumask); 3572 3573 if (mmask & fumask) { 3574 MIX(sc).nchan = 1; 3575 MIX(sc).wValue[0] = MAKE_WORD(ctl, 0); 3576 } else if (cmask & fumask) { 3577 MIX(sc).nchan = nchan - 1; 3578 for (i = 1; i < nchan; i++) { 3579 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask) 3580 MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i); 3581 else 3582 MIX(sc).wValue[i - 1] = -1; 3583 } 3584 } else { 3585 continue; 3586 } 3587 3588 mixernumber = uaudio_mixer_determine_class(&iot[id]); 3589 3590 switch (ctl) { 3591 case MUTE_CONTROL: 3592 MIX(sc).type = MIX_ON_OFF; 3593 MIX(sc).ctl = SOUND_MIXER_MUTE; 3594 MIX(sc).name = "mute"; 3595 break; 3596 3597 case VOLUME_CONTROL: 3598 MIX(sc).type = MIX_SIGNED_16; 3599 MIX(sc).ctl = mixernumber; 3600 MIX(sc).name = "vol"; 3601 break; 3602 3603 case BASS_CONTROL: 3604 MIX(sc).type = MIX_SIGNED_8; 3605 MIX(sc).ctl = SOUND_MIXER_BASS; 3606 MIX(sc).name = "bass"; 3607 break; 3608 3609 case MID_CONTROL: 3610 MIX(sc).type = MIX_SIGNED_8; 3611 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3612 MIX(sc).name = "mid"; 3613 break; 3614 3615 case TREBLE_CONTROL: 3616 MIX(sc).type = MIX_SIGNED_8; 3617 MIX(sc).ctl = SOUND_MIXER_TREBLE; 3618 MIX(sc).name = "treble"; 3619 break; 3620 3621 case GRAPHIC_EQUALIZER_CONTROL: 3622 continue; /* XXX don't add anything */ 3623 3624 case AGC_CONTROL: 3625 MIX(sc).type = MIX_ON_OFF; 3626 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3627 MIX(sc).name = "agc"; 3628 break; 3629 3630 case DELAY_CONTROL: 3631 MIX(sc).type = MIX_UNSIGNED_16; 3632 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3633 MIX(sc).name = "delay"; 3634 break; 3635 3636 case BASS_BOOST_CONTROL: 3637 MIX(sc).type = MIX_ON_OFF; 3638 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3639 MIX(sc).name = "boost"; 3640 break; 3641 3642 case LOUDNESS_CONTROL: 3643 MIX(sc).type = MIX_ON_OFF; 3644 MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */ 3645 MIX(sc).name = "loudness"; 3646 break; 3647 3648 default: 3649 MIX(sc).type = MIX_UNKNOWN; 3650 break; 3651 } 3652 3653 if (MIX(sc).type != MIX_UNKNOWN) 3654 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3655 } 3656 } 3657 3658 static void 3659 uaudio20_mixer_add_feature(struct uaudio_softc *sc, 3660 const struct uaudio_terminal_node *iot, int id) 3661 { 3662 const struct usb_audio20_feature_unit *d = iot[id].u.fu_v2; 3663 uint32_t ctl; 3664 uint32_t mmask; 3665 uint32_t cmask; 3666 uint16_t mixernumber; 3667 uint8_t nchan; 3668 uint8_t chan; 3669 uint8_t i; 3670 uint8_t what; 3671 3672 if (UGETDW(d->bmaControls[0]) == 0) 3673 return; 3674 3675 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3676 3677 nchan = (d->bLength - 6) / 4; 3678 mmask = UGETDW(d->bmaControls[0]); 3679 cmask = 0; 3680 3681 if (nchan == 0) 3682 return; 3683 3684 /* figure out what we can control */ 3685 3686 for (chan = 1; chan < nchan; chan++) 3687 cmask |= UGETDW(d->bmaControls[chan]); 3688 3689 if (nchan > MIX_MAX_CHAN) 3690 nchan = MIX_MAX_CHAN; 3691 3692 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 3693 3694 i = d->bmaControls[nchan][0]; 3695 if (i == 0 || 3696 usbd_req_get_string_any(sc->sc_udev, NULL, 3697 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) { 3698 MIX(sc).desc[0] = 0; 3699 } 3700 3701 for (ctl = 3; ctl != 0; ctl <<= 2) { 3702 3703 mixernumber = uaudio20_mixer_determine_class(&iot[id]); 3704 3705 switch (ctl) { 3706 case (3 << 0): 3707 MIX(sc).type = MIX_ON_OFF; 3708 MIX(sc).ctl = SOUND_MIXER_MUTE; 3709 MIX(sc).name = "mute"; 3710 what = MUTE_CONTROL; 3711 break; 3712 case (3 << 2): 3713 MIX(sc).type = MIX_SIGNED_16; 3714 MIX(sc).ctl = mixernumber; 3715 MIX(sc).name = "vol"; 3716 what = VOLUME_CONTROL; 3717 break; 3718 case (3 << 4): 3719 MIX(sc).type = MIX_SIGNED_8; 3720 MIX(sc).ctl = SOUND_MIXER_BASS; 3721 MIX(sc).name = "bass"; 3722 what = BASS_CONTROL; 3723 break; 3724 case (3 << 6): 3725 MIX(sc).type = MIX_SIGNED_8; 3726 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3727 MIX(sc).name = "mid"; 3728 what = MID_CONTROL; 3729 break; 3730 case (3 << 8): 3731 MIX(sc).type = MIX_SIGNED_8; 3732 MIX(sc).ctl = SOUND_MIXER_TREBLE; 3733 MIX(sc).name = "treble"; 3734 what = TREBLE_CONTROL; 3735 break; 3736 case (3 << 12): 3737 MIX(sc).type = MIX_ON_OFF; 3738 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3739 MIX(sc).name = "agc"; 3740 what = AGC_CONTROL; 3741 break; 3742 case (3 << 14): 3743 MIX(sc).type = MIX_UNSIGNED_16; 3744 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3745 MIX(sc).name = "delay"; 3746 what = DELAY_CONTROL; 3747 break; 3748 case (3 << 16): 3749 MIX(sc).type = MIX_ON_OFF; 3750 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3751 MIX(sc).name = "boost"; 3752 what = BASS_BOOST_CONTROL; 3753 break; 3754 case (3 << 18): 3755 MIX(sc).type = MIX_ON_OFF; 3756 MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */ 3757 MIX(sc).name = "loudness"; 3758 what = LOUDNESS_CONTROL; 3759 break; 3760 case (3 << 20): 3761 MIX(sc).type = MIX_SIGNED_16; 3762 MIX(sc).ctl = mixernumber; 3763 MIX(sc).name = "igain"; 3764 what = INPUT_GAIN_CONTROL; 3765 break; 3766 case (3 << 22): 3767 MIX(sc).type = MIX_SIGNED_16; 3768 MIX(sc).ctl = mixernumber; 3769 MIX(sc).name = "igainpad"; 3770 what = INPUT_GAIN_PAD_CONTROL; 3771 break; 3772 default: 3773 continue; 3774 } 3775 3776 if ((mmask & ctl) == ctl) { 3777 MIX(sc).nchan = 1; 3778 MIX(sc).wValue[0] = MAKE_WORD(what, 0); 3779 } else if ((cmask & ctl) == ctl) { 3780 MIX(sc).nchan = nchan - 1; 3781 for (i = 1; i < nchan; i++) { 3782 if ((UGETDW(d->bmaControls[i]) & ctl) == ctl) 3783 MIX(sc).wValue[i - 1] = MAKE_WORD(what, i); 3784 else 3785 MIX(sc).wValue[i - 1] = -1; 3786 } 3787 } else { 3788 continue; 3789 } 3790 3791 if (MIX(sc).type != MIX_UNKNOWN) 3792 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3793 } 3794 } 3795 3796 static void 3797 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc, 3798 const struct uaudio_terminal_node *iot, int id) 3799 { 3800 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1; 3801 const struct usb_audio_processing_unit_1 *d1 = 3802 (const void *)(d0->baSourceId + d0->bNrInPins); 3803 const struct usb_audio_processing_unit_updown *ud = 3804 (const void *)(d1->bmControls + d1->bControlSize); 3805 uint8_t i; 3806 3807 if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) { 3808 return; 3809 } 3810 if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes)) 3811 == NULL) { 3812 return; 3813 } 3814 DPRINTFN(3, "bUnitId=%d bNrModes=%d\n", 3815 d0->bUnitId, ud->bNrModes); 3816 3817 if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) { 3818 DPRINTF("no mode select\n"); 3819 return; 3820 } 3821 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3822 3823 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 3824 MIX(sc).nchan = 1; 3825 MIX(sc).wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0); 3826 MIX(sc).type = MIX_ON_OFF; /* XXX */ 3827 3828 for (i = 0; i < ud->bNrModes; i++) { 3829 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i])); 3830 /* XXX */ 3831 } 3832 3833 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3834 } 3835 3836 static void 3837 uaudio_mixer_add_processing(struct uaudio_softc *sc, 3838 const struct uaudio_terminal_node *iot, int id) 3839 { 3840 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1; 3841 const struct usb_audio_processing_unit_1 *d1 = 3842 (const void *)(d0->baSourceId + d0->bNrInPins); 3843 uint16_t ptype; 3844 3845 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3846 3847 ptype = UGETW(d0->wProcessType); 3848 3849 DPRINTFN(3, "wProcessType=%d bUnitId=%d " 3850 "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins); 3851 3852 if (d1->bControlSize == 0) { 3853 return; 3854 } 3855 if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) { 3856 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 3857 MIX(sc).nchan = 1; 3858 MIX(sc).wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0); 3859 MIX(sc).type = MIX_ON_OFF; 3860 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3861 } 3862 switch (ptype) { 3863 case UPDOWNMIX_PROCESS: 3864 uaudio_mixer_add_processing_updown(sc, iot, id); 3865 break; 3866 3867 case DOLBY_PROLOGIC_PROCESS: 3868 case P3D_STEREO_EXTENDER_PROCESS: 3869 case REVERBATION_PROCESS: 3870 case CHORUS_PROCESS: 3871 case DYN_RANGE_COMP_PROCESS: 3872 default: 3873 DPRINTF("unit %d, type=%d is not implemented\n", 3874 d0->bUnitId, ptype); 3875 break; 3876 } 3877 } 3878 3879 static void 3880 uaudio_mixer_add_extension(struct uaudio_softc *sc, 3881 const struct uaudio_terminal_node *iot, int id) 3882 { 3883 const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu_v1; 3884 const struct usb_audio_extension_unit_1 *d1 = 3885 (const void *)(d0->baSourceId + d0->bNrInPins); 3886 3887 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3888 d0->bUnitId, d0->bNrInPins); 3889 3890 if (sc->sc_uq_au_no_xu) { 3891 return; 3892 } 3893 if (d1->bControlSize == 0) { 3894 return; 3895 } 3896 if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) { 3897 3898 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3899 3900 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 3901 MIX(sc).nchan = 1; 3902 MIX(sc).wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0); 3903 MIX(sc).type = MIX_ON_OFF; 3904 3905 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3906 } 3907 } 3908 3909 static const void * 3910 uaudio_mixer_verify_desc(const void *arg, uint32_t len) 3911 { 3912 const struct usb_audio_mixer_unit_1 *d1; 3913 const struct usb_audio_extension_unit_1 *e1; 3914 const struct usb_audio_processing_unit_1 *u1; 3915 3916 union { 3917 const struct usb_descriptor *desc; 3918 const struct usb_audio_input_terminal *it; 3919 const struct usb_audio_output_terminal *ot; 3920 const struct usb_audio_mixer_unit_0 *mu; 3921 const struct usb_audio_selector_unit *su; 3922 const struct usb_audio_feature_unit *fu; 3923 const struct usb_audio_processing_unit_0 *pu; 3924 const struct usb_audio_extension_unit_0 *eu; 3925 } u; 3926 3927 u.desc = arg; 3928 3929 if (u.desc == NULL) { 3930 goto error; 3931 } 3932 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) { 3933 goto error; 3934 } 3935 switch (u.desc->bDescriptorSubtype) { 3936 case UDESCSUB_AC_INPUT: 3937 len += sizeof(*u.it); 3938 break; 3939 3940 case UDESCSUB_AC_OUTPUT: 3941 len += sizeof(*u.ot); 3942 break; 3943 3944 case UDESCSUB_AC_MIXER: 3945 len += sizeof(*u.mu); 3946 3947 if (u.desc->bLength < len) { 3948 goto error; 3949 } 3950 len += u.mu->bNrInPins; 3951 3952 if (u.desc->bLength < len) { 3953 goto error; 3954 } 3955 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins); 3956 3957 len += sizeof(*d1); 3958 break; 3959 3960 case UDESCSUB_AC_SELECTOR: 3961 len += sizeof(*u.su); 3962 3963 if (u.desc->bLength < len) { 3964 goto error; 3965 } 3966 len += u.su->bNrInPins + 1; 3967 break; 3968 3969 case UDESCSUB_AC_FEATURE: 3970 len += sizeof(*u.fu) + 1; 3971 3972 if (u.desc->bLength < len) 3973 goto error; 3974 3975 len += u.fu->bControlSize; 3976 break; 3977 3978 case UDESCSUB_AC_PROCESSING: 3979 len += sizeof(*u.pu); 3980 3981 if (u.desc->bLength < len) { 3982 goto error; 3983 } 3984 len += u.pu->bNrInPins; 3985 3986 if (u.desc->bLength < len) { 3987 goto error; 3988 } 3989 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins); 3990 3991 len += sizeof(*u1); 3992 3993 if (u.desc->bLength < len) { 3994 goto error; 3995 } 3996 len += u1->bControlSize; 3997 3998 break; 3999 4000 case UDESCSUB_AC_EXTENSION: 4001 len += sizeof(*u.eu); 4002 4003 if (u.desc->bLength < len) { 4004 goto error; 4005 } 4006 len += u.eu->bNrInPins; 4007 4008 if (u.desc->bLength < len) { 4009 goto error; 4010 } 4011 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins); 4012 4013 len += sizeof(*e1); 4014 4015 if (u.desc->bLength < len) { 4016 goto error; 4017 } 4018 len += e1->bControlSize; 4019 break; 4020 4021 default: 4022 goto error; 4023 } 4024 4025 if (u.desc->bLength < len) { 4026 goto error; 4027 } 4028 return (u.desc); 4029 4030 error: 4031 if (u.desc) { 4032 DPRINTF("invalid descriptor, type=%d, " 4033 "sub_type=%d, len=%d of %d bytes\n", 4034 u.desc->bDescriptorType, 4035 u.desc->bDescriptorSubtype, 4036 u.desc->bLength, len); 4037 } 4038 return (NULL); 4039 } 4040 4041 static const void * 4042 uaudio20_mixer_verify_desc(const void *arg, uint32_t len) 4043 { 4044 const struct usb_audio20_mixer_unit_1 *d1; 4045 const struct usb_audio20_extension_unit_1 *e1; 4046 const struct usb_audio20_processing_unit_1 *u1; 4047 const struct usb_audio20_clock_selector_unit_1 *c1; 4048 4049 union { 4050 const struct usb_descriptor *desc; 4051 const struct usb_audio20_clock_source_unit *csrc; 4052 const struct usb_audio20_clock_selector_unit_0 *csel; 4053 const struct usb_audio20_clock_multiplier_unit *cmul; 4054 const struct usb_audio20_input_terminal *it; 4055 const struct usb_audio20_output_terminal *ot; 4056 const struct usb_audio20_mixer_unit_0 *mu; 4057 const struct usb_audio20_selector_unit *su; 4058 const struct usb_audio20_feature_unit *fu; 4059 const struct usb_audio20_sample_rate_unit *ru; 4060 const struct usb_audio20_processing_unit_0 *pu; 4061 const struct usb_audio20_extension_unit_0 *eu; 4062 const struct usb_audio20_effect_unit *ef; 4063 } u; 4064 4065 u.desc = arg; 4066 4067 if (u.desc == NULL) 4068 goto error; 4069 4070 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) 4071 goto error; 4072 4073 switch (u.desc->bDescriptorSubtype) { 4074 case UDESCSUB_AC_INPUT: 4075 len += sizeof(*u.it); 4076 break; 4077 4078 case UDESCSUB_AC_OUTPUT: 4079 len += sizeof(*u.ot); 4080 break; 4081 4082 case UDESCSUB_AC_MIXER: 4083 len += sizeof(*u.mu); 4084 4085 if (u.desc->bLength < len) 4086 goto error; 4087 len += u.mu->bNrInPins; 4088 4089 if (u.desc->bLength < len) 4090 goto error; 4091 4092 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins); 4093 4094 len += sizeof(*d1) + d1->bNrChannels; 4095 break; 4096 4097 case UDESCSUB_AC_SELECTOR: 4098 len += sizeof(*u.su); 4099 4100 if (u.desc->bLength < len) 4101 goto error; 4102 4103 len += u.su->bNrInPins + 1; 4104 break; 4105 4106 case UDESCSUB_AC_FEATURE: 4107 len += sizeof(*u.fu) + 1; 4108 break; 4109 4110 case UDESCSUB_AC_EFFECT: 4111 len += sizeof(*u.ef) + 4; 4112 break; 4113 4114 case UDESCSUB_AC_PROCESSING_V2: 4115 len += sizeof(*u.pu); 4116 4117 if (u.desc->bLength < len) 4118 goto error; 4119 4120 len += u.pu->bNrInPins; 4121 4122 if (u.desc->bLength < len) 4123 goto error; 4124 4125 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins); 4126 4127 len += sizeof(*u1); 4128 break; 4129 4130 case UDESCSUB_AC_EXTENSION_V2: 4131 len += sizeof(*u.eu); 4132 4133 if (u.desc->bLength < len) 4134 goto error; 4135 4136 len += u.eu->bNrInPins; 4137 4138 if (u.desc->bLength < len) 4139 goto error; 4140 4141 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins); 4142 4143 len += sizeof(*e1); 4144 break; 4145 4146 case UDESCSUB_AC_CLOCK_SRC: 4147 len += sizeof(*u.csrc); 4148 break; 4149 4150 case UDESCSUB_AC_CLOCK_SEL: 4151 len += sizeof(*u.csel); 4152 4153 if (u.desc->bLength < len) 4154 goto error; 4155 4156 len += u.csel->bNrInPins; 4157 4158 if (u.desc->bLength < len) 4159 goto error; 4160 4161 c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins); 4162 4163 len += sizeof(*c1); 4164 break; 4165 4166 case UDESCSUB_AC_CLOCK_MUL: 4167 len += sizeof(*u.cmul); 4168 break; 4169 4170 case UDESCSUB_AC_SAMPLE_RT: 4171 len += sizeof(*u.ru); 4172 break; 4173 4174 default: 4175 goto error; 4176 } 4177 4178 if (u.desc->bLength < len) 4179 goto error; 4180 4181 return (u.desc); 4182 4183 error: 4184 if (u.desc) { 4185 DPRINTF("invalid descriptor, type=%d, " 4186 "sub_type=%d, len=%d of %d bytes\n", 4187 u.desc->bDescriptorType, 4188 u.desc->bDescriptorSubtype, 4189 u.desc->bLength, len); 4190 } 4191 return (NULL); 4192 } 4193 4194 static struct usb_audio_cluster 4195 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot) 4196 { 4197 struct usb_audio_cluster r; 4198 const struct usb_descriptor *dp; 4199 uint8_t i; 4200 4201 for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) { /* avoid infinite loops */ 4202 dp = iot[id].u.desc; 4203 if (dp == NULL) { 4204 goto error; 4205 } 4206 switch (dp->bDescriptorSubtype) { 4207 case UDESCSUB_AC_INPUT: 4208 r.bNrChannels = iot[id].u.it_v1->bNrChannels; 4209 r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0]; 4210 r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1]; 4211 r.iChannelNames = iot[id].u.it_v1->iChannelNames; 4212 goto done; 4213 4214 case UDESCSUB_AC_OUTPUT: 4215 id = iot[id].u.ot_v1->bSourceId; 4216 break; 4217 4218 case UDESCSUB_AC_MIXER: 4219 r = *(const struct usb_audio_cluster *) 4220 &iot[id].u.mu_v1->baSourceId[ 4221 iot[id].u.mu_v1->bNrInPins]; 4222 goto done; 4223 4224 case UDESCSUB_AC_SELECTOR: 4225 if (iot[id].u.su_v1->bNrInPins > 0) { 4226 /* XXX This is not really right */ 4227 id = iot[id].u.su_v1->baSourceId[0]; 4228 } 4229 break; 4230 4231 case UDESCSUB_AC_FEATURE: 4232 id = iot[id].u.fu_v1->bSourceId; 4233 break; 4234 4235 case UDESCSUB_AC_PROCESSING: 4236 r = *((const struct usb_audio_cluster *) 4237 &iot[id].u.pu_v1->baSourceId[ 4238 iot[id].u.pu_v1->bNrInPins]); 4239 goto done; 4240 4241 case UDESCSUB_AC_EXTENSION: 4242 r = *((const struct usb_audio_cluster *) 4243 &iot[id].u.eu_v1->baSourceId[ 4244 iot[id].u.eu_v1->bNrInPins]); 4245 goto done; 4246 4247 default: 4248 goto error; 4249 } 4250 } 4251 error: 4252 DPRINTF("bad data\n"); 4253 memset(&r, 0, sizeof(r)); 4254 done: 4255 return (r); 4256 } 4257 4258 static struct usb_audio20_cluster 4259 uaudio20_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot) 4260 { 4261 struct usb_audio20_cluster r; 4262 const struct usb_descriptor *dp; 4263 uint8_t i; 4264 4265 for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) { /* avoid infinite loops */ 4266 dp = iot[id].u.desc; 4267 if (dp == NULL) 4268 goto error; 4269 4270 switch (dp->bDescriptorSubtype) { 4271 case UDESCSUB_AC_INPUT: 4272 r.bNrChannels = iot[id].u.it_v2->bNrChannels; 4273 r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0]; 4274 r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1]; 4275 r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2]; 4276 r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3]; 4277 r.iChannelNames = iot[id].u.it_v2->iTerminal; 4278 goto done; 4279 4280 case UDESCSUB_AC_OUTPUT: 4281 id = iot[id].u.ot_v2->bSourceId; 4282 break; 4283 4284 case UDESCSUB_AC_MIXER: 4285 r = *(const struct usb_audio20_cluster *) 4286 &iot[id].u.mu_v2->baSourceId[ 4287 iot[id].u.mu_v2->bNrInPins]; 4288 goto done; 4289 4290 case UDESCSUB_AC_SELECTOR: 4291 if (iot[id].u.su_v2->bNrInPins > 0) { 4292 /* XXX This is not really right */ 4293 id = iot[id].u.su_v2->baSourceId[0]; 4294 } 4295 break; 4296 4297 case UDESCSUB_AC_SAMPLE_RT: 4298 id = iot[id].u.ru_v2->bSourceId; 4299 break; 4300 4301 case UDESCSUB_AC_EFFECT: 4302 id = iot[id].u.ef_v2->bSourceId; 4303 break; 4304 4305 case UDESCSUB_AC_FEATURE: 4306 id = iot[id].u.fu_v2->bSourceId; 4307 break; 4308 4309 case UDESCSUB_AC_PROCESSING_V2: 4310 r = *((const struct usb_audio20_cluster *) 4311 &iot[id].u.pu_v2->baSourceId[ 4312 iot[id].u.pu_v2->bNrInPins]); 4313 goto done; 4314 4315 case UDESCSUB_AC_EXTENSION_V2: 4316 r = *((const struct usb_audio20_cluster *) 4317 &iot[id].u.eu_v2->baSourceId[ 4318 iot[id].u.eu_v2->bNrInPins]); 4319 goto done; 4320 4321 default: 4322 goto error; 4323 } 4324 } 4325 error: 4326 DPRINTF("Bad data!\n"); 4327 memset(&r, 0, sizeof(r)); 4328 done: 4329 return (r); 4330 } 4331 4332 static bool 4333 uaudio_mixer_foreach_input(const struct uaudio_terminal_node *iot, uint8_t *pindex) 4334 { 4335 uint8_t n; 4336 4337 n = *pindex; 4338 4339 while (1) { 4340 if (!n--) 4341 n = iot->usr.id_max; 4342 if (n == 0) 4343 return (false); 4344 if (iot->usr.bit_input[n / 8] & (1 << (n % 8))) 4345 break; 4346 } 4347 *pindex = n; 4348 return (true); 4349 } 4350 4351 static bool 4352 uaudio_mixer_foreach_output(const struct uaudio_terminal_node *iot, uint8_t *pindex) 4353 { 4354 uint8_t n; 4355 4356 n = *pindex; 4357 4358 while (1) { 4359 if (!n--) 4360 n = iot->usr.id_max; 4361 if (n == 0) 4362 return (false); 4363 if (iot->usr.bit_output[n / 8] & (1 << (n % 8))) 4364 break; 4365 } 4366 *pindex = n; 4367 return (true); 4368 } 4369 4370 struct uaudio_tt_to_feature { 4371 uint16_t terminal_type; 4372 uint16_t feature; 4373 }; 4374 4375 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = { 4376 4377 {UATI_MICROPHONE, SOUND_MIXER_MIC}, 4378 {UATI_DESKMICROPHONE, SOUND_MIXER_MIC}, 4379 {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC}, 4380 {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC}, 4381 {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC}, 4382 {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC}, 4383 4384 {UATE_ANALOGCONN, SOUND_MIXER_LINE}, 4385 {UATE_LINECONN, SOUND_MIXER_LINE}, 4386 {UATE_LEGACYCONN, SOUND_MIXER_LINE}, 4387 4388 {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM}, 4389 {UATE_SPDIF, SOUND_MIXER_ALTPCM}, 4390 {UATE_1394DA, SOUND_MIXER_ALTPCM}, 4391 {UATE_1394DV, SOUND_MIXER_ALTPCM}, 4392 4393 {UATF_CDPLAYER, SOUND_MIXER_CD}, 4394 4395 {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH}, 4396 4397 {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO}, 4398 {UATF_DVDAUDIO, SOUND_MIXER_VIDEO}, 4399 {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO}, 4400 4401 {UATF_RADIORECV, SOUND_MIXER_RADIO}, 4402 {UATF_RADIOXMIT, SOUND_MIXER_RADIO}, 4403 4404 {} /* END */ 4405 }; 4406 4407 static uint16_t 4408 uaudio_mixer_get_feature_by_tt(uint16_t terminal_type, uint16_t default_type) 4409 { 4410 const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature; 4411 uint16_t retval; 4412 4413 if (terminal_type == 0) { 4414 retval = default_type; 4415 } else while (1) { 4416 if (uat->terminal_type == 0) { 4417 switch (terminal_type >> 8) { 4418 case UATI_UNDEFINED >> 8: 4419 retval = SOUND_MIXER_RECLEV; 4420 goto done; 4421 case UATO_UNDEFINED >> 8: 4422 retval = SOUND_MIXER_PCM; 4423 goto done; 4424 case UATT_UNDEFINED >> 8: 4425 retval = SOUND_MIXER_PHONEIN; 4426 goto done; 4427 default: 4428 retval = default_type; 4429 goto done; 4430 } 4431 } else if (uat->terminal_type == terminal_type) { 4432 retval = uat->feature; 4433 goto done; 4434 } 4435 uat++; 4436 } 4437 done: 4438 DPRINTF("terminal_type=0x%04x RET=%d DEF=%d\n", 4439 terminal_type, retval, default_type); 4440 return (retval); 4441 } 4442 4443 static uint16_t 4444 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot) 4445 { 4446 const struct uaudio_terminal_node *ptr; 4447 uint16_t terminal_type_input = 0; 4448 uint16_t terminal_type_output = 0; 4449 uint16_t temp; 4450 uint8_t match = 0; 4451 uint8_t i; 4452 4453 for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) { 4454 ptr = iot->root + i; 4455 temp = UGETW(ptr->u.it_v1->wTerminalType); 4456 4457 if (temp == 0) 4458 continue; 4459 else if (temp == UAT_STREAM) 4460 match |= 1; 4461 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00)) 4462 terminal_type_input = temp; 4463 } 4464 4465 for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) { 4466 ptr = iot->root + i; 4467 temp = UGETW(ptr->u.ot_v1->wTerminalType); 4468 4469 if (temp == 0) 4470 continue; 4471 else if (temp == UAT_STREAM) 4472 match |= 2; 4473 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00)) 4474 terminal_type_output = temp; 4475 } 4476 4477 DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n", 4478 match, terminal_type_input, terminal_type_output); 4479 4480 switch (match) { 4481 case 0: /* not connected to USB */ 4482 if (terminal_type_output != 0) { 4483 return (uaudio_mixer_get_feature_by_tt( 4484 terminal_type_output, SOUND_MIXER_MONITOR)); 4485 } else { 4486 return (uaudio_mixer_get_feature_by_tt( 4487 terminal_type_input, SOUND_MIXER_MONITOR)); 4488 } 4489 case 3: /* connected to both USB input and USB output */ 4490 return (SOUND_MIXER_IMIX); 4491 case 2: /* connected to USB output */ 4492 return (uaudio_mixer_get_feature_by_tt( 4493 terminal_type_input, SOUND_MIXER_RECLEV)); 4494 case 1: /* connected to USB input */ 4495 return (uaudio_mixer_get_feature_by_tt( 4496 terminal_type_output, SOUND_MIXER_PCM)); 4497 default: 4498 return (SOUND_MIXER_NRDEVICES); 4499 } 4500 } 4501 4502 static uint16_t 4503 uaudio20_mixer_determine_class(const struct uaudio_terminal_node *iot) 4504 { 4505 const struct uaudio_terminal_node *ptr; 4506 uint16_t terminal_type_input = 0; 4507 uint16_t terminal_type_output = 0; 4508 uint16_t temp; 4509 uint8_t match = 0; 4510 uint8_t i; 4511 4512 for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) { 4513 ptr = iot->root + i; 4514 temp = UGETW(ptr->u.it_v2->wTerminalType); 4515 4516 if (temp == 0) 4517 continue; 4518 else if (temp == UAT_STREAM) 4519 match |= 1; 4520 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00)) 4521 terminal_type_input = temp; 4522 } 4523 4524 for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) { 4525 ptr = iot->root + i; 4526 temp = UGETW(ptr->u.ot_v2->wTerminalType); 4527 4528 if (temp == 0) 4529 continue; 4530 else if (temp == UAT_STREAM) 4531 match |= 2; 4532 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00)) 4533 terminal_type_output = temp; 4534 } 4535 4536 DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n", 4537 match, terminal_type_input, terminal_type_output); 4538 4539 switch (match) { 4540 case 0: /* not connected to USB */ 4541 if (terminal_type_output != 0) { 4542 return (uaudio_mixer_get_feature_by_tt( 4543 terminal_type_output, SOUND_MIXER_MONITOR)); 4544 } else { 4545 return (uaudio_mixer_get_feature_by_tt( 4546 terminal_type_input, SOUND_MIXER_MONITOR)); 4547 } 4548 case 3: /* connected to both USB input and USB output */ 4549 return (SOUND_MIXER_IMIX); 4550 case 2: /* connected to USB output */ 4551 return (uaudio_mixer_get_feature_by_tt( 4552 terminal_type_input, SOUND_MIXER_RECLEV)); 4553 case 1: /* connected to USB input */ 4554 return (uaudio_mixer_get_feature_by_tt( 4555 terminal_type_output, SOUND_MIXER_PCM)); 4556 default: 4557 return (SOUND_MIXER_NRDEVICES); 4558 } 4559 } 4560 4561 static void 4562 uaudio_mixer_merge_outputs(struct uaudio_search_result *dst, 4563 const struct uaudio_search_result *src) 4564 { 4565 const uint8_t max = sizeof(src->bit_output) / sizeof(src->bit_output[0]); 4566 uint8_t x; 4567 4568 for (x = 0; x != max; x++) 4569 dst->bit_output[x] |= src->bit_output[x]; 4570 } 4571 4572 static void 4573 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root, 4574 const uint8_t *p_id, uint8_t n_id, 4575 struct uaudio_search_result *info) 4576 { 4577 struct uaudio_terminal_node *iot; 4578 uint8_t n; 4579 uint8_t i; 4580 4581 for (n = 0; n < n_id; n++) { 4582 4583 i = p_id[n]; 4584 4585 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) { 4586 DPRINTF("avoided going into a circle at id=%d!\n", i); 4587 return; 4588 } 4589 4590 info->recurse_level++; 4591 4592 iot = (root + i); 4593 4594 if (iot->u.desc == NULL) 4595 continue; 4596 4597 switch (iot->u.desc->bDescriptorSubtype) { 4598 case UDESCSUB_AC_INPUT: 4599 uaudio_mixer_merge_outputs(&iot->usr, info); 4600 info->bit_input[i / 8] |= (1 << (i % 8)); 4601 break; 4602 4603 case UDESCSUB_AC_FEATURE: 4604 uaudio_mixer_merge_outputs(&iot->usr, info); 4605 uaudio_mixer_find_inputs_sub( 4606 root, &iot->u.fu_v1->bSourceId, 1, info); 4607 break; 4608 4609 case UDESCSUB_AC_OUTPUT: 4610 info->bit_output[i / 8] |= (1 << (i % 8)); 4611 uaudio_mixer_find_inputs_sub( 4612 root, &iot->u.ot_v1->bSourceId, 1, info); 4613 info->bit_output[i / 8] &= ~(1 << (i % 8)); 4614 break; 4615 4616 case UDESCSUB_AC_MIXER: 4617 uaudio_mixer_merge_outputs(&iot->usr, info); 4618 uaudio_mixer_find_inputs_sub( 4619 root, iot->u.mu_v1->baSourceId, 4620 iot->u.mu_v1->bNrInPins, info); 4621 break; 4622 4623 case UDESCSUB_AC_SELECTOR: 4624 uaudio_mixer_merge_outputs(&iot->usr, info); 4625 uaudio_mixer_find_inputs_sub( 4626 root, iot->u.su_v1->baSourceId, 4627 iot->u.su_v1->bNrInPins, info); 4628 break; 4629 4630 case UDESCSUB_AC_PROCESSING: 4631 uaudio_mixer_merge_outputs(&iot->usr, info); 4632 uaudio_mixer_find_inputs_sub( 4633 root, iot->u.pu_v1->baSourceId, 4634 iot->u.pu_v1->bNrInPins, info); 4635 break; 4636 4637 case UDESCSUB_AC_EXTENSION: 4638 uaudio_mixer_merge_outputs(&iot->usr, info); 4639 uaudio_mixer_find_inputs_sub( 4640 root, iot->u.eu_v1->baSourceId, 4641 iot->u.eu_v1->bNrInPins, info); 4642 break; 4643 4644 default: 4645 break; 4646 } 4647 } 4648 } 4649 4650 static void 4651 uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *root, 4652 const uint8_t *p_id, uint8_t n_id, 4653 struct uaudio_search_result *info) 4654 { 4655 struct uaudio_terminal_node *iot; 4656 uint8_t n; 4657 uint8_t i; 4658 4659 for (n = 0; n < n_id; n++) { 4660 4661 i = p_id[n]; 4662 4663 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) { 4664 DPRINTF("avoided going into a circle at id=%d!\n", i); 4665 return; 4666 } 4667 4668 info->recurse_level++; 4669 4670 iot = (root + i); 4671 4672 if (iot->u.desc == NULL) 4673 continue; 4674 4675 switch (iot->u.desc->bDescriptorSubtype) { 4676 case UDESCSUB_AC_INPUT: 4677 uaudio_mixer_merge_outputs(&iot->usr, info); 4678 info->bit_input[i / 8] |= (1 << (i % 8)); 4679 break; 4680 4681 case UDESCSUB_AC_OUTPUT: 4682 info->bit_output[i / 8] |= (1 << (i % 8)); 4683 uaudio20_mixer_find_inputs_sub( 4684 root, &iot->u.ot_v2->bSourceId, 1, info); 4685 info->bit_output[i / 8] &= ~(1 << (i % 8)); 4686 break; 4687 4688 case UDESCSUB_AC_MIXER: 4689 uaudio_mixer_merge_outputs(&iot->usr, info); 4690 uaudio20_mixer_find_inputs_sub( 4691 root, iot->u.mu_v2->baSourceId, 4692 iot->u.mu_v2->bNrInPins, info); 4693 break; 4694 4695 case UDESCSUB_AC_SELECTOR: 4696 uaudio_mixer_merge_outputs(&iot->usr, info); 4697 uaudio20_mixer_find_inputs_sub( 4698 root, iot->u.su_v2->baSourceId, 4699 iot->u.su_v2->bNrInPins, info); 4700 break; 4701 4702 case UDESCSUB_AC_SAMPLE_RT: 4703 uaudio_mixer_merge_outputs(&iot->usr, info); 4704 uaudio20_mixer_find_inputs_sub( 4705 root, &iot->u.ru_v2->bSourceId, 4706 1, info); 4707 break; 4708 4709 case UDESCSUB_AC_EFFECT: 4710 uaudio_mixer_merge_outputs(&iot->usr, info); 4711 uaudio20_mixer_find_inputs_sub( 4712 root, &iot->u.ef_v2->bSourceId, 4713 1, info); 4714 break; 4715 4716 case UDESCSUB_AC_FEATURE: 4717 uaudio_mixer_merge_outputs(&iot->usr, info); 4718 uaudio20_mixer_find_inputs_sub( 4719 root, &iot->u.fu_v2->bSourceId, 1, info); 4720 break; 4721 4722 case UDESCSUB_AC_PROCESSING_V2: 4723 uaudio_mixer_merge_outputs(&iot->usr, info); 4724 uaudio20_mixer_find_inputs_sub( 4725 root, iot->u.pu_v2->baSourceId, 4726 iot->u.pu_v2->bNrInPins, info); 4727 break; 4728 4729 case UDESCSUB_AC_EXTENSION_V2: 4730 uaudio_mixer_merge_outputs(&iot->usr, info); 4731 uaudio20_mixer_find_inputs_sub( 4732 root, iot->u.eu_v2->baSourceId, 4733 iot->u.eu_v2->bNrInPins, info); 4734 break; 4735 default: 4736 break; 4737 } 4738 } 4739 } 4740 4741 static void 4742 uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root, 4743 const uint8_t *p_id, uint8_t n_id, 4744 struct uaudio_search_result *info) 4745 { 4746 struct uaudio_terminal_node *iot; 4747 uint8_t n; 4748 uint8_t i; 4749 uint8_t is_last; 4750 uint8_t id; 4751 4752 top: 4753 for (n = 0; n < n_id; n++) { 4754 4755 i = p_id[n]; 4756 4757 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) { 4758 DPRINTF("avoided going into a circle at id=%d!\n", i); 4759 return; 4760 } 4761 4762 info->recurse_level++; 4763 4764 iot = (root + i); 4765 4766 if (iot->u.desc == NULL) 4767 continue; 4768 4769 is_last = ((n + 1) == n_id); 4770 4771 switch (iot->u.desc->bDescriptorSubtype) { 4772 case UDESCSUB_AC_INPUT: 4773 info->is_input = 1; 4774 if (is_last) { 4775 p_id = &iot->u.it_v2->bCSourceId; 4776 n_id = 1; 4777 goto top; 4778 } 4779 uaudio20_mixer_find_clocks_sub(root, 4780 &iot->u.it_v2->bCSourceId, 1, info); 4781 break; 4782 4783 case UDESCSUB_AC_OUTPUT: 4784 info->is_input = 0; 4785 if (is_last) { 4786 p_id = &iot->u.ot_v2->bCSourceId; 4787 n_id = 1; 4788 goto top; 4789 } 4790 uaudio20_mixer_find_clocks_sub(root, 4791 &iot->u.ot_v2->bCSourceId, 1, info); 4792 break; 4793 4794 case UDESCSUB_AC_CLOCK_SEL: 4795 if (is_last) { 4796 p_id = iot->u.csel_v2->baCSourceId; 4797 n_id = iot->u.csel_v2->bNrInPins; 4798 goto top; 4799 } 4800 uaudio20_mixer_find_clocks_sub(root, 4801 iot->u.csel_v2->baCSourceId, 4802 iot->u.csel_v2->bNrInPins, info); 4803 break; 4804 4805 case UDESCSUB_AC_CLOCK_MUL: 4806 if (is_last) { 4807 p_id = &iot->u.cmul_v2->bCSourceId; 4808 n_id = 1; 4809 goto top; 4810 } 4811 uaudio20_mixer_find_clocks_sub(root, 4812 &iot->u.cmul_v2->bCSourceId, 4813 1, info); 4814 break; 4815 4816 case UDESCSUB_AC_CLOCK_SRC: 4817 4818 id = iot->u.csrc_v2->bClockId; 4819 4820 switch (info->is_input) { 4821 case 0: 4822 info->bit_output[id / 8] |= (1 << (id % 8)); 4823 break; 4824 case 1: 4825 info->bit_input[id / 8] |= (1 << (id % 8)); 4826 break; 4827 default: 4828 break; 4829 } 4830 break; 4831 4832 default: 4833 break; 4834 } 4835 } 4836 } 4837 4838 static void 4839 uaudio_mixer_fill_info(struct uaudio_softc *sc, 4840 struct usb_device *udev, void *desc) 4841 { 4842 const struct usb_audio_control_descriptor *acdp; 4843 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); 4844 const struct usb_descriptor *dp; 4845 const struct usb_audio_unit *au; 4846 struct uaudio_terminal_node *iot = NULL; 4847 uint16_t wTotalLen; 4848 uint8_t ID_max = 0; /* inclusive */ 4849 uint8_t i; 4850 4851 desc = usb_desc_foreach(cd, desc); 4852 4853 if (desc == NULL) { 4854 DPRINTF("no Audio Control header\n"); 4855 goto done; 4856 } 4857 acdp = desc; 4858 4859 if ((acdp->bLength < sizeof(*acdp)) || 4860 (acdp->bDescriptorType != UDESC_CS_INTERFACE) || 4861 (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) { 4862 DPRINTF("invalid Audio Control header\n"); 4863 goto done; 4864 } 4865 /* "wTotalLen" is allowed to be corrupt */ 4866 wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength; 4867 4868 /* get USB audio revision */ 4869 sc->sc_audio_rev = UGETW(acdp->bcdADC); 4870 4871 DPRINTFN(3, "found AC header, vers=%03x, len=%d\n", 4872 sc->sc_audio_rev, wTotalLen); 4873 4874 iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP, 4875 M_WAITOK | M_ZERO); 4876 4877 if (iot == NULL) { 4878 DPRINTF("no memory!\n"); 4879 goto done; 4880 } 4881 while ((desc = usb_desc_foreach(cd, desc))) { 4882 4883 dp = desc; 4884 4885 if (dp->bLength > wTotalLen) { 4886 break; 4887 } else { 4888 wTotalLen -= dp->bLength; 4889 } 4890 4891 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) 4892 au = NULL; 4893 else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) 4894 au = uaudio20_mixer_verify_desc(dp, 0); 4895 else 4896 au = uaudio_mixer_verify_desc(dp, 0); 4897 4898 if (au) { 4899 iot[au->bUnitId].u.desc = (const void *)au; 4900 if (au->bUnitId > ID_max) 4901 ID_max = au->bUnitId; 4902 } 4903 } 4904 4905 DPRINTF("Maximum ID=%d\n", ID_max); 4906 4907 /* 4908 * determine sourcing inputs for 4909 * all nodes in the tree: 4910 */ 4911 i = ID_max; 4912 do { 4913 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) { 4914 /* FALLTHROUGH */ 4915 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) { 4916 uaudio20_mixer_find_inputs_sub(iot, 4917 &i, 1, &((iot + i)->usr)); 4918 4919 sc->sc_mixer_clocks.is_input = 255; 4920 sc->sc_mixer_clocks.recurse_level = 0; 4921 4922 uaudio20_mixer_find_clocks_sub(iot, 4923 &i, 1, &sc->sc_mixer_clocks); 4924 } else { 4925 uaudio_mixer_find_inputs_sub(iot, 4926 &i, 1, &((iot + i)->usr)); 4927 } 4928 } while (i--); 4929 4930 /* set "id_max" and "root" */ 4931 4932 i = ID_max; 4933 do { 4934 (iot + i)->usr.id_max = ID_max; 4935 (iot + i)->root = iot; 4936 } while (i--); 4937 4938 /* 4939 * Scan the config to create a linked list of "mixer" nodes: 4940 */ 4941 4942 i = ID_max; 4943 do { 4944 dp = iot[i].u.desc; 4945 4946 if (dp == NULL) 4947 continue; 4948 4949 DPRINTFN(11, "id=%d subtype=%d\n", 4950 i, dp->bDescriptorSubtype); 4951 4952 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) { 4953 continue; 4954 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) { 4955 4956 switch (dp->bDescriptorSubtype) { 4957 case UDESCSUB_AC_HEADER: 4958 DPRINTF("unexpected AC header\n"); 4959 break; 4960 4961 case UDESCSUB_AC_INPUT: 4962 case UDESCSUB_AC_OUTPUT: 4963 case UDESCSUB_AC_PROCESSING_V2: 4964 case UDESCSUB_AC_EXTENSION_V2: 4965 case UDESCSUB_AC_EFFECT: 4966 case UDESCSUB_AC_CLOCK_SRC: 4967 case UDESCSUB_AC_CLOCK_SEL: 4968 case UDESCSUB_AC_CLOCK_MUL: 4969 case UDESCSUB_AC_SAMPLE_RT: 4970 break; 4971 4972 case UDESCSUB_AC_MIXER: 4973 uaudio20_mixer_add_mixer(sc, iot, i); 4974 break; 4975 4976 case UDESCSUB_AC_SELECTOR: 4977 uaudio20_mixer_add_selector(sc, iot, i); 4978 break; 4979 4980 case UDESCSUB_AC_FEATURE: 4981 uaudio20_mixer_add_feature(sc, iot, i); 4982 break; 4983 4984 default: 4985 DPRINTF("bad AC desc subtype=0x%02x\n", 4986 dp->bDescriptorSubtype); 4987 break; 4988 } 4989 continue; 4990 } 4991 4992 switch (dp->bDescriptorSubtype) { 4993 case UDESCSUB_AC_HEADER: 4994 DPRINTF("unexpected AC header\n"); 4995 break; 4996 4997 case UDESCSUB_AC_INPUT: 4998 case UDESCSUB_AC_OUTPUT: 4999 break; 5000 5001 case UDESCSUB_AC_MIXER: 5002 uaudio_mixer_add_mixer(sc, iot, i); 5003 break; 5004 5005 case UDESCSUB_AC_SELECTOR: 5006 uaudio_mixer_add_selector(sc, iot, i); 5007 break; 5008 5009 case UDESCSUB_AC_FEATURE: 5010 uaudio_mixer_add_feature(sc, iot, i); 5011 break; 5012 5013 case UDESCSUB_AC_PROCESSING: 5014 uaudio_mixer_add_processing(sc, iot, i); 5015 break; 5016 5017 case UDESCSUB_AC_EXTENSION: 5018 uaudio_mixer_add_extension(sc, iot, i); 5019 break; 5020 5021 default: 5022 DPRINTF("bad AC desc subtype=0x%02x\n", 5023 dp->bDescriptorSubtype); 5024 break; 5025 } 5026 5027 } while (i--); 5028 5029 done: 5030 free(iot, M_TEMP); 5031 } 5032 5033 static int 5034 uaudio_mixer_get(struct usb_device *udev, uint16_t audio_rev, 5035 uint8_t what, struct uaudio_mixer_node *mc) 5036 { 5037 struct usb_device_request req; 5038 int val; 5039 uint8_t data[2 + (2 * 3)]; 5040 usb_error_t err; 5041 5042 if (mc->wValue[0] == -1) 5043 return (0); 5044 5045 if (audio_rev >= UAUDIO_VERSION_30) 5046 return (0); 5047 else if (audio_rev >= UAUDIO_VERSION_20) { 5048 if (what == GET_CUR) { 5049 req.bRequest = UA20_CS_CUR; 5050 USETW(req.wLength, 2); 5051 } else { 5052 req.bRequest = UA20_CS_RANGE; 5053 USETW(req.wLength, 8); 5054 } 5055 } else { 5056 uint16_t len = MIX_SIZE(mc->type); 5057 5058 req.bRequest = what; 5059 USETW(req.wLength, len); 5060 } 5061 5062 req.bmRequestType = UT_READ_CLASS_INTERFACE; 5063 USETW(req.wValue, mc->wValue[0]); 5064 USETW(req.wIndex, mc->wIndex); 5065 5066 memset(data, 0, sizeof(data)); 5067 5068 err = usbd_do_request(udev, NULL, &req, data); 5069 if (err) { 5070 DPRINTF("err=%s\n", usbd_errstr(err)); 5071 return (0); 5072 } 5073 5074 if (audio_rev >= UAUDIO_VERSION_30) { 5075 val = 0; 5076 } else if (audio_rev >= UAUDIO_VERSION_20) { 5077 switch (what) { 5078 case GET_CUR: 5079 val = (data[0] | (data[1] << 8)); 5080 break; 5081 case GET_MIN: 5082 val = (data[2] | (data[3] << 8)); 5083 break; 5084 case GET_MAX: 5085 val = (data[4] | (data[5] << 8)); 5086 break; 5087 case GET_RES: 5088 val = (data[6] | (data[7] << 8)); 5089 break; 5090 default: 5091 val = 0; 5092 break; 5093 } 5094 } else { 5095 val = (data[0] | (data[1] << 8)); 5096 } 5097 5098 if (what == GET_CUR || what == GET_MIN || what == GET_MAX) 5099 val = uaudio_mixer_signext(mc->type, val); 5100 5101 DPRINTFN(3, "val=%d\n", val); 5102 5103 return (val); 5104 } 5105 5106 static void 5107 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error) 5108 { 5109 struct usb_device_request req; 5110 struct uaudio_softc *sc = usbd_xfer_softc(xfer); 5111 struct uaudio_mixer_node *mc = sc->sc_mixer_curr; 5112 struct usb_page_cache *pc; 5113 uint16_t len; 5114 uint8_t repeat = 1; 5115 uint8_t update; 5116 uint8_t chan; 5117 uint8_t buf[2]; 5118 5119 DPRINTF("\n"); 5120 5121 switch (USB_GET_STATE(xfer)) { 5122 case USB_ST_TRANSFERRED: 5123 tr_transferred: 5124 case USB_ST_SETUP: 5125 tr_setup: 5126 5127 if (mc == NULL) { 5128 mc = sc->sc_mixer_root; 5129 sc->sc_mixer_curr = mc; 5130 sc->sc_mixer_chan = 0; 5131 repeat = 0; 5132 } 5133 while (mc) { 5134 while (sc->sc_mixer_chan < mc->nchan) { 5135 5136 chan = sc->sc_mixer_chan; 5137 5138 sc->sc_mixer_chan++; 5139 5140 update = ((mc->update[chan / 8] & (1 << (chan % 8))) && 5141 (mc->wValue[chan] != -1)); 5142 5143 mc->update[chan / 8] &= ~(1 << (chan % 8)); 5144 5145 if (update) { 5146 5147 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 5148 USETW(req.wValue, mc->wValue[chan]); 5149 USETW(req.wIndex, mc->wIndex); 5150 5151 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) { 5152 return; 5153 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) { 5154 len = 2; 5155 req.bRequest = UA20_CS_CUR; 5156 USETW(req.wLength, len); 5157 } else { 5158 len = MIX_SIZE(mc->type); 5159 req.bRequest = SET_CUR; 5160 USETW(req.wLength, len); 5161 } 5162 5163 buf[0] = (mc->wData[chan] & 0xFF); 5164 buf[1] = (mc->wData[chan] >> 8) & 0xFF; 5165 5166 pc = usbd_xfer_get_frame(xfer, 0); 5167 usbd_copy_in(pc, 0, &req, sizeof(req)); 5168 pc = usbd_xfer_get_frame(xfer, 1); 5169 usbd_copy_in(pc, 0, buf, len); 5170 5171 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 5172 usbd_xfer_set_frame_len(xfer, 1, len); 5173 usbd_xfer_set_frames(xfer, len ? 2 : 1); 5174 usbd_transfer_submit(xfer); 5175 return; 5176 } 5177 } 5178 5179 mc = mc->next; 5180 sc->sc_mixer_curr = mc; 5181 sc->sc_mixer_chan = 0; 5182 } 5183 5184 if (repeat) { 5185 goto tr_setup; 5186 } 5187 break; 5188 5189 default: /* Error */ 5190 DPRINTF("error=%s\n", usbd_errstr(error)); 5191 if (error == USB_ERR_CANCELLED) { 5192 /* do nothing - we are detaching */ 5193 break; 5194 } 5195 goto tr_transferred; 5196 } 5197 } 5198 5199 static usb_error_t 5200 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed) 5201 { 5202 struct usb_device_request req; 5203 uint8_t data[3]; 5204 5205 DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed); 5206 5207 req.bmRequestType = UT_WRITE_CLASS_ENDPOINT; 5208 req.bRequest = SET_CUR; 5209 USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0); 5210 USETW(req.wIndex, endpt); 5211 USETW(req.wLength, 3); 5212 data[0] = speed; 5213 data[1] = speed >> 8; 5214 data[2] = speed >> 16; 5215 5216 return (usbd_do_request(udev, NULL, &req, data)); 5217 } 5218 5219 static usb_error_t 5220 uaudio20_set_speed(struct usb_device *udev, uint8_t iface_no, 5221 uint8_t clockid, uint32_t speed) 5222 { 5223 struct usb_device_request req; 5224 uint8_t data[4]; 5225 5226 DPRINTFN(6, "ifaceno=%d clockid=%d speed=%u\n", 5227 iface_no, clockid, speed); 5228 5229 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 5230 req.bRequest = UA20_CS_CUR; 5231 USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0); 5232 USETW2(req.wIndex, clockid, iface_no); 5233 USETW(req.wLength, 4); 5234 data[0] = speed; 5235 data[1] = speed >> 8; 5236 data[2] = speed >> 16; 5237 data[3] = speed >> 24; 5238 5239 return (usbd_do_request(udev, NULL, &req, data)); 5240 } 5241 5242 static int 5243 uaudio_mixer_signext(uint8_t type, int val) 5244 { 5245 if (!MIX_UNSIGNED(type)) { 5246 if (MIX_SIZE(type) == 2) { 5247 val = (int16_t)val; 5248 } else { 5249 val = (int8_t)val; 5250 } 5251 } 5252 return (val); 5253 } 5254 5255 static int 5256 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int val) 5257 { 5258 if (mc->type == MIX_ON_OFF) { 5259 val = (val != 0); 5260 } else if (mc->type != MIX_SELECTOR) { 5261 5262 /* compute actual volume */ 5263 val = (val * mc->mul) / 100; 5264 5265 /* add lower offset */ 5266 val = val + mc->minval; 5267 } 5268 /* make sure we don't write a value out of range */ 5269 if (val > mc->maxval) 5270 val = mc->maxval; 5271 else if (val < mc->minval) 5272 val = mc->minval; 5273 5274 DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n", 5275 mc->type, val, mc->minval, mc->maxval, val); 5276 return (val); 5277 } 5278 5279 static void 5280 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc, 5281 uint8_t chan, int val) 5282 { 5283 val = uaudio_mixer_bsd2value(mc, val); 5284 5285 mc->update[chan / 8] |= (1 << (chan % 8)); 5286 mc->wData[chan] = val; 5287 5288 /* start the transfer, if not already started */ 5289 5290 usbd_transfer_start(sc->sc_mixer_xfer[0]); 5291 } 5292 5293 static void 5294 uaudio_mixer_init(struct uaudio_softc *sc) 5295 { 5296 struct uaudio_mixer_node *mc; 5297 int32_t i; 5298 5299 for (mc = sc->sc_mixer_root; mc; mc = mc->next) { 5300 5301 if (mc->ctl != SOUND_MIXER_NRDEVICES) { 5302 /* 5303 * Set device mask bits. See 5304 * /usr/include/machine/soundcard.h 5305 */ 5306 sc->sc_mix_info |= 1U << mc->ctl; 5307 } 5308 if ((mc->ctl == SOUND_MIXER_NRDEVICES) && 5309 (mc->type == MIX_SELECTOR)) { 5310 5311 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 5312 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES) 5313 continue; 5314 sc->sc_recsrc_info |= 1U << mc->slctrtype[i - 1]; 5315 } 5316 } 5317 } 5318 } 5319 5320 int 5321 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m) 5322 { 5323 DPRINTF("\n"); 5324 5325 sc->sc_mixer_lock = mixer_get_lock(m); 5326 sc->sc_mixer_dev = m; 5327 5328 if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index, 5329 sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc, 5330 sc->sc_mixer_lock)) { 5331 DPRINTFN(0, "could not allocate USB " 5332 "transfer for audio mixer!\n"); 5333 return (ENOMEM); 5334 } 5335 5336 if (sc->sc_play_chan.num_alt > 0 && 5337 (sc->sc_mix_info & SOUND_MASK_VOLUME) == 0) { 5338 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM); 5339 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE); 5340 } 5341 mix_setdevs(m, sc->sc_mix_info); 5342 mix_setrecdevs(m, sc->sc_recsrc_info); 5343 return (0); 5344 } 5345 5346 int 5347 uaudio_mixer_uninit_sub(struct uaudio_softc *sc) 5348 { 5349 DPRINTF("\n"); 5350 5351 usbd_transfer_unsetup(sc->sc_mixer_xfer, 1); 5352 5353 sc->sc_mixer_lock = NULL; 5354 5355 return (0); 5356 } 5357 5358 void 5359 uaudio_mixer_set(struct uaudio_softc *sc, unsigned type, 5360 unsigned left, unsigned right) 5361 { 5362 struct uaudio_mixer_node *mc; 5363 int chan; 5364 5365 for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) { 5366 5367 if (mc->ctl == type) { 5368 for (chan = 0; chan < mc->nchan; chan++) { 5369 uaudio_mixer_ctl_set(sc, mc, chan, 5370 chan == 0 ? left : right); 5371 } 5372 } 5373 } 5374 } 5375 5376 uint32_t 5377 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, uint32_t src) 5378 { 5379 struct uaudio_mixer_node *mc; 5380 uint32_t mask; 5381 uint32_t temp; 5382 int32_t i; 5383 5384 for (mc = sc->sc_mixer_root; mc; mc = mc->next) { 5385 5386 if ((mc->ctl == SOUND_MIXER_NRDEVICES) && 5387 (mc->type == MIX_SELECTOR)) { 5388 5389 /* compute selector mask */ 5390 5391 mask = 0; 5392 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) 5393 mask |= 1U << mc->slctrtype[i - 1]; 5394 5395 temp = mask & src; 5396 if (temp == 0) 5397 continue; 5398 5399 /* find the first set bit */ 5400 temp = (-temp) & temp; 5401 5402 /* update "src" */ 5403 src &= ~mask; 5404 src |= temp; 5405 5406 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 5407 if (temp != (1U << mc->slctrtype[i - 1])) 5408 continue; 5409 uaudio_mixer_ctl_set(sc, mc, 0, i); 5410 break; 5411 } 5412 } 5413 } 5414 return (src); 5415 } 5416 5417 /*========================================================================* 5418 * MIDI support routines 5419 *========================================================================*/ 5420 5421 static void 5422 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 5423 { 5424 struct umidi_chan *chan = usbd_xfer_softc(xfer); 5425 struct umidi_sub_chan *sub; 5426 struct usb_page_cache *pc; 5427 uint8_t buf[4]; 5428 uint8_t cmd_len; 5429 uint8_t cn; 5430 uint16_t pos; 5431 int actlen; 5432 5433 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 5434 5435 switch (USB_GET_STATE(xfer)) { 5436 case USB_ST_TRANSFERRED: 5437 5438 DPRINTF("actlen=%d bytes\n", actlen); 5439 5440 pos = 0; 5441 pc = usbd_xfer_get_frame(xfer, 0); 5442 5443 while (actlen >= 4) { 5444 5445 /* copy out the MIDI data */ 5446 usbd_copy_out(pc, pos, buf, 4); 5447 /* command length */ 5448 cmd_len = umidi_cmd_to_len[buf[0] & 0xF]; 5449 /* cable number */ 5450 cn = buf[0] >> 4; 5451 /* 5452 * Lookup sub-channel. The index is range 5453 * checked below. 5454 */ 5455 sub = &chan->sub[cn]; 5456 5457 if ((cmd_len != 0) && (cn < chan->max_emb_jack) && 5458 (sub->read_open != 0)) { 5459 5460 /* Send data to the application */ 5461 usb_fifo_put_data_linear( 5462 sub->fifo.fp[USB_FIFO_RX], 5463 buf + 1, cmd_len, 1); 5464 } 5465 actlen -= 4; 5466 pos += 4; 5467 } 5468 5469 case USB_ST_SETUP: 5470 DPRINTF("start\n"); 5471 tr_setup: 5472 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 5473 usbd_transfer_submit(xfer); 5474 break; 5475 5476 default: 5477 DPRINTF("error=%s\n", usbd_errstr(error)); 5478 5479 if (error != USB_ERR_CANCELLED) { 5480 /* try to clear stall first */ 5481 usbd_xfer_set_stall(xfer); 5482 goto tr_setup; 5483 } 5484 break; 5485 } 5486 } 5487 5488 /* 5489 * The following statemachine, that converts MIDI commands to 5490 * USB MIDI packets, derives from Linux's usbmidi.c, which 5491 * was written by "Clemens Ladisch": 5492 * 5493 * Returns: 5494 * 0: No command 5495 * Else: Command is complete 5496 */ 5497 static uint8_t 5498 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b) 5499 { 5500 uint8_t p0 = (cn << 4); 5501 5502 if (b >= 0xf8) { 5503 sub->temp_0[0] = p0 | 0x0f; 5504 sub->temp_0[1] = b; 5505 sub->temp_0[2] = 0; 5506 sub->temp_0[3] = 0; 5507 sub->temp_cmd = sub->temp_0; 5508 return (1); 5509 5510 } else if (b >= 0xf0) { 5511 switch (b) { 5512 case 0xf0: /* system exclusive begin */ 5513 sub->temp_1[1] = b; 5514 sub->state = UMIDI_ST_SYSEX_1; 5515 break; 5516 case 0xf1: /* MIDI time code */ 5517 case 0xf3: /* song select */ 5518 sub->temp_1[1] = b; 5519 sub->state = UMIDI_ST_1PARAM; 5520 break; 5521 case 0xf2: /* song position pointer */ 5522 sub->temp_1[1] = b; 5523 sub->state = UMIDI_ST_2PARAM_1; 5524 break; 5525 case 0xf4: /* unknown */ 5526 case 0xf5: /* unknown */ 5527 sub->state = UMIDI_ST_UNKNOWN; 5528 break; 5529 case 0xf6: /* tune request */ 5530 sub->temp_1[0] = p0 | 0x05; 5531 sub->temp_1[1] = 0xf6; 5532 sub->temp_1[2] = 0; 5533 sub->temp_1[3] = 0; 5534 sub->temp_cmd = sub->temp_1; 5535 sub->state = UMIDI_ST_UNKNOWN; 5536 return (1); 5537 5538 case 0xf7: /* system exclusive end */ 5539 switch (sub->state) { 5540 case UMIDI_ST_SYSEX_0: 5541 sub->temp_1[0] = p0 | 0x05; 5542 sub->temp_1[1] = 0xf7; 5543 sub->temp_1[2] = 0; 5544 sub->temp_1[3] = 0; 5545 sub->temp_cmd = sub->temp_1; 5546 sub->state = UMIDI_ST_UNKNOWN; 5547 return (1); 5548 case UMIDI_ST_SYSEX_1: 5549 sub->temp_1[0] = p0 | 0x06; 5550 sub->temp_1[2] = 0xf7; 5551 sub->temp_1[3] = 0; 5552 sub->temp_cmd = sub->temp_1; 5553 sub->state = UMIDI_ST_UNKNOWN; 5554 return (1); 5555 case UMIDI_ST_SYSEX_2: 5556 sub->temp_1[0] = p0 | 0x07; 5557 sub->temp_1[3] = 0xf7; 5558 sub->temp_cmd = sub->temp_1; 5559 sub->state = UMIDI_ST_UNKNOWN; 5560 return (1); 5561 } 5562 sub->state = UMIDI_ST_UNKNOWN; 5563 break; 5564 } 5565 } else if (b >= 0x80) { 5566 sub->temp_1[1] = b; 5567 if ((b >= 0xc0) && (b <= 0xdf)) { 5568 sub->state = UMIDI_ST_1PARAM; 5569 } else { 5570 sub->state = UMIDI_ST_2PARAM_1; 5571 } 5572 } else { /* b < 0x80 */ 5573 switch (sub->state) { 5574 case UMIDI_ST_1PARAM: 5575 if (sub->temp_1[1] < 0xf0) { 5576 p0 |= sub->temp_1[1] >> 4; 5577 } else { 5578 p0 |= 0x02; 5579 sub->state = UMIDI_ST_UNKNOWN; 5580 } 5581 sub->temp_1[0] = p0; 5582 sub->temp_1[2] = b; 5583 sub->temp_1[3] = 0; 5584 sub->temp_cmd = sub->temp_1; 5585 return (1); 5586 case UMIDI_ST_2PARAM_1: 5587 sub->temp_1[2] = b; 5588 sub->state = UMIDI_ST_2PARAM_2; 5589 break; 5590 case UMIDI_ST_2PARAM_2: 5591 if (sub->temp_1[1] < 0xf0) { 5592 p0 |= sub->temp_1[1] >> 4; 5593 sub->state = UMIDI_ST_2PARAM_1; 5594 } else { 5595 p0 |= 0x03; 5596 sub->state = UMIDI_ST_UNKNOWN; 5597 } 5598 sub->temp_1[0] = p0; 5599 sub->temp_1[3] = b; 5600 sub->temp_cmd = sub->temp_1; 5601 return (1); 5602 case UMIDI_ST_SYSEX_0: 5603 sub->temp_1[1] = b; 5604 sub->state = UMIDI_ST_SYSEX_1; 5605 break; 5606 case UMIDI_ST_SYSEX_1: 5607 sub->temp_1[2] = b; 5608 sub->state = UMIDI_ST_SYSEX_2; 5609 break; 5610 case UMIDI_ST_SYSEX_2: 5611 sub->temp_1[0] = p0 | 0x04; 5612 sub->temp_1[3] = b; 5613 sub->temp_cmd = sub->temp_1; 5614 sub->state = UMIDI_ST_SYSEX_0; 5615 return (1); 5616 default: 5617 break; 5618 } 5619 } 5620 return (0); 5621 } 5622 5623 static void 5624 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 5625 { 5626 struct umidi_chan *chan = usbd_xfer_softc(xfer); 5627 struct umidi_sub_chan *sub; 5628 struct usb_page_cache *pc; 5629 uint32_t actlen; 5630 uint16_t nframes; 5631 uint8_t buf; 5632 uint8_t start_cable; 5633 uint8_t tr_any; 5634 int len; 5635 5636 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 5637 5638 /* 5639 * NOTE: Some MIDI devices only accept 4 bytes of data per 5640 * short terminated USB transfer. 5641 */ 5642 switch (USB_GET_STATE(xfer)) { 5643 case USB_ST_TRANSFERRED: 5644 DPRINTF("actlen=%d bytes\n", len); 5645 5646 case USB_ST_SETUP: 5647 tr_setup: 5648 DPRINTF("start\n"); 5649 5650 nframes = 0; /* reset */ 5651 start_cable = chan->curr_cable; 5652 tr_any = 0; 5653 pc = usbd_xfer_get_frame(xfer, 0); 5654 5655 while (1) { 5656 5657 /* round robin de-queueing */ 5658 5659 sub = &chan->sub[chan->curr_cable]; 5660 5661 if (sub->write_open) { 5662 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX], 5663 &buf, 1, &actlen, 0); 5664 } else { 5665 actlen = 0; 5666 } 5667 5668 if (actlen) { 5669 5670 tr_any = 1; 5671 5672 DPRINTF("byte=0x%02x from FIFO %u\n", buf, 5673 (unsigned int)chan->curr_cable); 5674 5675 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) { 5676 5677 DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n", 5678 sub->temp_cmd[0], sub->temp_cmd[1], 5679 sub->temp_cmd[2], sub->temp_cmd[3]); 5680 5681 usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4); 5682 5683 nframes++; 5684 5685 if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0)) 5686 break; 5687 } else { 5688 continue; 5689 } 5690 } 5691 5692 chan->curr_cable++; 5693 if (chan->curr_cable >= chan->max_emb_jack) 5694 chan->curr_cable = 0; 5695 5696 if (chan->curr_cable == start_cable) { 5697 if (tr_any == 0) 5698 break; 5699 tr_any = 0; 5700 } 5701 } 5702 5703 if (nframes != 0) { 5704 DPRINTF("Transferring %d frames\n", (int)nframes); 5705 usbd_xfer_set_frame_len(xfer, 0, 4 * nframes); 5706 usbd_transfer_submit(xfer); 5707 } 5708 break; 5709 5710 default: /* Error */ 5711 5712 DPRINTF("error=%s\n", usbd_errstr(error)); 5713 5714 if (error != USB_ERR_CANCELLED) { 5715 /* try to clear stall first */ 5716 usbd_xfer_set_stall(xfer); 5717 goto tr_setup; 5718 } 5719 break; 5720 } 5721 } 5722 5723 static struct umidi_sub_chan * 5724 umidi_sub_by_fifo(struct usb_fifo *fifo) 5725 { 5726 struct umidi_chan *chan = usb_fifo_softc(fifo); 5727 struct umidi_sub_chan *sub; 5728 uint32_t n; 5729 5730 for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) { 5731 sub = &chan->sub[n]; 5732 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) || 5733 (sub->fifo.fp[USB_FIFO_TX] == fifo)) { 5734 return (sub); 5735 } 5736 } 5737 5738 panic("%s:%d cannot find usb_fifo!\n", 5739 __FILE__, __LINE__); 5740 5741 return (NULL); 5742 } 5743 5744 static void 5745 umidi_start_read(struct usb_fifo *fifo) 5746 { 5747 struct umidi_chan *chan = usb_fifo_softc(fifo); 5748 5749 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]); 5750 } 5751 5752 static void 5753 umidi_stop_read(struct usb_fifo *fifo) 5754 { 5755 struct umidi_chan *chan = usb_fifo_softc(fifo); 5756 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 5757 5758 DPRINTF("\n"); 5759 5760 sub->read_open = 0; 5761 5762 if (--(chan->read_open_refcount) == 0) { 5763 /* 5764 * XXX don't stop the read transfer here, hence that causes 5765 * problems with some MIDI adapters 5766 */ 5767 DPRINTF("(stopping read transfer)\n"); 5768 } 5769 } 5770 5771 static void 5772 umidi_start_write(struct usb_fifo *fifo) 5773 { 5774 struct umidi_chan *chan = usb_fifo_softc(fifo); 5775 5776 if (chan->xfer[UMIDI_TX_TRANSFER] == NULL) { 5777 uint8_t buf[1]; 5778 int actlen; 5779 do { 5780 /* dump data */ 5781 usb_fifo_get_data_linear(fifo, buf, 1, &actlen, 0); 5782 } while (actlen > 0); 5783 } else { 5784 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]); 5785 } 5786 } 5787 5788 static void 5789 umidi_stop_write(struct usb_fifo *fifo) 5790 { 5791 struct umidi_chan *chan = usb_fifo_softc(fifo); 5792 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 5793 5794 DPRINTF("\n"); 5795 5796 sub->write_open = 0; 5797 5798 if (--(chan->write_open_refcount) == 0) { 5799 DPRINTF("(stopping write transfer)\n"); 5800 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]); 5801 } 5802 } 5803 5804 static int 5805 umidi_open(struct usb_fifo *fifo, int fflags) 5806 { 5807 struct umidi_chan *chan = usb_fifo_softc(fifo); 5808 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 5809 5810 if (fflags & FREAD) { 5811 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) { 5812 return (ENOMEM); 5813 } 5814 mtx_lock(&chan->mtx); 5815 chan->read_open_refcount++; 5816 sub->read_open = 1; 5817 mtx_unlock(&chan->mtx); 5818 } 5819 if (fflags & FWRITE) { 5820 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) { 5821 return (ENOMEM); 5822 } 5823 /* clear stall first */ 5824 mtx_lock(&chan->mtx); 5825 chan->write_open_refcount++; 5826 sub->write_open = 1; 5827 5828 /* reset */ 5829 sub->state = UMIDI_ST_UNKNOWN; 5830 mtx_unlock(&chan->mtx); 5831 } 5832 return (0); /* success */ 5833 } 5834 5835 static void 5836 umidi_close(struct usb_fifo *fifo, int fflags) 5837 { 5838 if (fflags & FREAD) { 5839 usb_fifo_free_buffer(fifo); 5840 } 5841 if (fflags & FWRITE) { 5842 usb_fifo_free_buffer(fifo); 5843 } 5844 } 5845 5846 5847 static int 5848 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data, 5849 int fflags) 5850 { 5851 return (ENODEV); 5852 } 5853 5854 static void 5855 umidi_init(device_t dev) 5856 { 5857 struct uaudio_softc *sc = device_get_softc(dev); 5858 struct umidi_chan *chan = &sc->sc_midi_chan; 5859 5860 mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE); 5861 } 5862 5863 static struct usb_fifo_methods umidi_fifo_methods = { 5864 .f_start_read = &umidi_start_read, 5865 .f_start_write = &umidi_start_write, 5866 .f_stop_read = &umidi_stop_read, 5867 .f_stop_write = &umidi_stop_write, 5868 .f_open = &umidi_open, 5869 .f_close = &umidi_close, 5870 .f_ioctl = &umidi_ioctl, 5871 .basename[0] = "umidi", 5872 }; 5873 5874 static int 5875 umidi_probe(device_t dev) 5876 { 5877 struct uaudio_softc *sc = device_get_softc(dev); 5878 struct usb_attach_arg *uaa = device_get_ivars(dev); 5879 struct umidi_chan *chan = &sc->sc_midi_chan; 5880 struct umidi_sub_chan *sub; 5881 int unit = device_get_unit(dev); 5882 int error; 5883 uint32_t n; 5884 5885 if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI)) 5886 chan->single_command = 1; 5887 5888 if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index, 5889 chan->iface_alt_index)) { 5890 DPRINTF("setting of alternate index failed!\n"); 5891 goto detach; 5892 } 5893 usbd_set_parent_iface(sc->sc_udev, chan->iface_index, 5894 sc->sc_mixer_iface_index); 5895 5896 error = usbd_transfer_setup(uaa->device, &chan->iface_index, 5897 chan->xfer, umidi_config, UMIDI_N_TRANSFER, 5898 chan, &chan->mtx); 5899 if (error) { 5900 DPRINTF("error=%s\n", usbd_errstr(error)); 5901 goto detach; 5902 } 5903 if (chan->xfer[UMIDI_TX_TRANSFER] == NULL && 5904 chan->xfer[UMIDI_RX_TRANSFER] == NULL) { 5905 DPRINTF("no BULK or INTERRUPT MIDI endpoint(s) found\n"); 5906 goto detach; 5907 } 5908 5909 /* 5910 * Some USB MIDI device makers couldn't resist using 5911 * wMaxPacketSize = 4 for RX and TX BULK endpoints, although 5912 * that size is an unsupported value for FULL speed BULK 5913 * endpoints. The same applies to some HIGH speed MIDI devices 5914 * which are using a wMaxPacketSize different from 512 bytes. 5915 * 5916 * Refer to section 5.8.3 in USB 2.0 PDF: Cite: "All Host 5917 * Controllers are required to have support for 8-, 16-, 32-, 5918 * and 64-byte maximum packet sizes for full-speed bulk 5919 * endpoints and 512 bytes for high-speed bulk endpoints." 5920 */ 5921 if (chan->xfer[UMIDI_TX_TRANSFER] != NULL && 5922 usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER])) 5923 chan->single_command = 1; 5924 5925 if (chan->single_command != 0) 5926 device_printf(dev, "Single command MIDI quirk enabled\n"); 5927 5928 if ((chan->max_emb_jack == 0) || 5929 (chan->max_emb_jack > UMIDI_EMB_JACK_MAX)) { 5930 chan->max_emb_jack = UMIDI_EMB_JACK_MAX; 5931 } 5932 5933 for (n = 0; n < chan->max_emb_jack; n++) { 5934 5935 sub = &chan->sub[n]; 5936 5937 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx, 5938 &umidi_fifo_methods, &sub->fifo, unit, n, 5939 chan->iface_index, 5940 UID_ROOT, GID_OPERATOR, 0644); 5941 if (error) { 5942 goto detach; 5943 } 5944 } 5945 5946 mtx_lock(&chan->mtx); 5947 5948 /* 5949 * NOTE: At least one device will not work properly unless the 5950 * BULK IN pipe is open all the time. This might have to do 5951 * about that the internal queues of the device overflow if we 5952 * don't read them regularly. 5953 */ 5954 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]); 5955 5956 mtx_unlock(&chan->mtx); 5957 5958 return (0); /* success */ 5959 5960 detach: 5961 return (ENXIO); /* failure */ 5962 } 5963 5964 static int 5965 umidi_detach(device_t dev) 5966 { 5967 struct uaudio_softc *sc = device_get_softc(dev); 5968 struct umidi_chan *chan = &sc->sc_midi_chan; 5969 uint32_t n; 5970 5971 for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) 5972 usb_fifo_detach(&chan->sub[n].fifo); 5973 5974 mtx_lock(&chan->mtx); 5975 5976 usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]); 5977 5978 mtx_unlock(&chan->mtx); 5979 5980 usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER); 5981 5982 mtx_destroy(&chan->mtx); 5983 5984 return (0); 5985 } 5986 5987 static void 5988 uaudio_hid_rx_callback(struct usb_xfer *xfer, usb_error_t error) 5989 { 5990 struct uaudio_softc *sc = usbd_xfer_softc(xfer); 5991 const uint8_t *buffer = usbd_xfer_get_frame_buffer(xfer, 0); 5992 struct snd_mixer *m; 5993 uint8_t id; 5994 int actlen; 5995 5996 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 5997 5998 switch (USB_GET_STATE(xfer)) { 5999 case USB_ST_TRANSFERRED: 6000 DPRINTF("actlen=%d\n", actlen); 6001 6002 if (actlen != 0 && 6003 (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) { 6004 id = *buffer; 6005 buffer++; 6006 actlen--; 6007 } else { 6008 id = 0; 6009 } 6010 6011 m = sc->sc_mixer_dev; 6012 6013 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) && 6014 (sc->sc_hid.mute_id == id) && 6015 hid_get_data(buffer, actlen, 6016 &sc->sc_hid.mute_loc)) { 6017 6018 DPRINTF("Mute toggle\n"); 6019 6020 mixer_hwvol_mute_locked(m); 6021 } 6022 6023 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) && 6024 (sc->sc_hid.volume_up_id == id) && 6025 hid_get_data(buffer, actlen, 6026 &sc->sc_hid.volume_up_loc)) { 6027 6028 DPRINTF("Volume Up\n"); 6029 6030 mixer_hwvol_step_locked(m, 1, 1); 6031 } 6032 6033 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) && 6034 (sc->sc_hid.volume_down_id == id) && 6035 hid_get_data(buffer, actlen, 6036 &sc->sc_hid.volume_down_loc)) { 6037 6038 DPRINTF("Volume Down\n"); 6039 6040 mixer_hwvol_step_locked(m, -1, -1); 6041 } 6042 6043 case USB_ST_SETUP: 6044 tr_setup: 6045 /* check if we can put more data into the FIFO */ 6046 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 6047 usbd_transfer_submit(xfer); 6048 break; 6049 6050 default: /* Error */ 6051 6052 DPRINTF("error=%s\n", usbd_errstr(error)); 6053 6054 if (error != USB_ERR_CANCELLED) { 6055 /* try to clear stall first */ 6056 usbd_xfer_set_stall(xfer); 6057 goto tr_setup; 6058 } 6059 break; 6060 } 6061 } 6062 6063 static int 6064 uaudio_hid_probe(struct uaudio_softc *sc, 6065 struct usb_attach_arg *uaa) 6066 { 6067 void *d_ptr; 6068 uint32_t flags; 6069 uint16_t d_len; 6070 uint8_t id; 6071 int error; 6072 6073 if (!(sc->sc_hid.flags & UAUDIO_HID_VALID)) 6074 return (-1); 6075 6076 if (sc->sc_mixer_lock == NULL) 6077 return (-1); 6078 6079 /* Get HID descriptor */ 6080 error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr, 6081 &d_len, M_TEMP, sc->sc_hid.iface_index); 6082 6083 if (error) { 6084 DPRINTF("error reading report description\n"); 6085 return (-1); 6086 } 6087 6088 /* check if there is an ID byte */ 6089 hid_report_size(d_ptr, d_len, hid_input, &id); 6090 6091 if (id != 0) 6092 sc->sc_hid.flags |= UAUDIO_HID_HAS_ID; 6093 6094 if (hid_locate(d_ptr, d_len, 6095 HID_USAGE2(HUP_CONSUMER, 0xE9 /* Volume Increment */), 6096 hid_input, 0, &sc->sc_hid.volume_up_loc, &flags, 6097 &sc->sc_hid.volume_up_id)) { 6098 if (flags & HIO_VARIABLE) 6099 sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP; 6100 DPRINTFN(1, "Found Volume Up key\n"); 6101 } 6102 6103 if (hid_locate(d_ptr, d_len, 6104 HID_USAGE2(HUP_CONSUMER, 0xEA /* Volume Decrement */), 6105 hid_input, 0, &sc->sc_hid.volume_down_loc, &flags, 6106 &sc->sc_hid.volume_down_id)) { 6107 if (flags & HIO_VARIABLE) 6108 sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN; 6109 DPRINTFN(1, "Found Volume Down key\n"); 6110 } 6111 6112 if (hid_locate(d_ptr, d_len, 6113 HID_USAGE2(HUP_CONSUMER, 0xE2 /* Mute */), 6114 hid_input, 0, &sc->sc_hid.mute_loc, &flags, 6115 &sc->sc_hid.mute_id)) { 6116 if (flags & HIO_VARIABLE) 6117 sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE; 6118 DPRINTFN(1, "Found Mute key\n"); 6119 } 6120 6121 free(d_ptr, M_TEMP); 6122 6123 if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP | 6124 UAUDIO_HID_HAS_VOLUME_DOWN | 6125 UAUDIO_HID_HAS_MUTE))) { 6126 DPRINTFN(1, "Did not find any volume related keys\n"); 6127 return (-1); 6128 } 6129 6130 /* prevent the uhid driver from attaching */ 6131 usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index, 6132 sc->sc_mixer_iface_index); 6133 6134 /* allocate USB transfers */ 6135 error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index, 6136 sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER, 6137 sc, sc->sc_mixer_lock); 6138 if (error) { 6139 DPRINTF("error=%s\n", usbd_errstr(error)); 6140 return (-1); 6141 } 6142 return (0); 6143 } 6144 6145 static void 6146 uaudio_hid_detach(struct uaudio_softc *sc) 6147 { 6148 usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER); 6149 } 6150 6151 DRIVER_MODULE_ORDERED(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0, SI_ORDER_ANY); 6152 MODULE_DEPEND(uaudio, usb, 1, 1, 1); 6153 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 6154 MODULE_VERSION(uaudio, 1); 6155 USB_PNP_HOST_INFO(uaudio_devs); 6156 USB_PNP_HOST_INFO(uaudio_vendor_midi); 6157