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