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