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