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