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