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