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