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