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