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 = 2 * uaudio_get_buffer_size(ch, ch->set_alt); 2796 sndbuf_setup(ch->pcm_buf, ch->buf, temp); 2797 return (temp / 2); 2798 } 2799 2800 int 2801 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize, 2802 uint32_t blockcount) 2803 { 2804 return (1); 2805 } 2806 2807 int 2808 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed) 2809 { 2810 struct uaudio_softc *sc; 2811 uint8_t x, y; 2812 2813 sc = ch->priv_sc; 2814 2815 for (x = 0, y = 1; y < ch->num_alt; y++) { 2816 /* prefer sample rate closer to and greater than requested */ 2817 if ((ch->usb_alt[x].sample_rate < speed && 2818 ch->usb_alt[x].sample_rate < ch->usb_alt[y].sample_rate) || 2819 (speed <= ch->usb_alt[y].sample_rate && 2820 ch->usb_alt[y].sample_rate < ch->usb_alt[x].sample_rate)) 2821 x = y; 2822 } 2823 2824 usb_proc_explore_lock(sc->sc_udev); 2825 ch->set_alt = x; 2826 usb_proc_explore_unlock(sc->sc_udev); 2827 2828 DPRINTF("Selecting alt %d\n", (int)x); 2829 2830 return (ch->usb_alt[x].sample_rate); 2831 } 2832 2833 int 2834 uaudio_chan_getptr(struct uaudio_chan *ch) 2835 { 2836 return (ch->cur - ch->start); 2837 } 2838 2839 struct pcmchan_caps * 2840 uaudio_chan_getcaps(struct uaudio_chan *ch) 2841 { 2842 return (&ch->pcm_cap); 2843 } 2844 2845 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = { 2846 .id = SND_CHN_MATRIX_DRV, 2847 .channels = 2, 2848 .ext = 0, 2849 .map = { 2850 /* Right */ 2851 [0] = { 2852 .type = SND_CHN_T_FR, 2853 .members = 2854 SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC | 2855 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR | 2856 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR 2857 }, 2858 /* Left */ 2859 [1] = { 2860 .type = SND_CHN_T_FL, 2861 .members = 2862 SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC | 2863 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL | 2864 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL 2865 }, 2866 [2] = { 2867 .type = SND_CHN_T_MAX, 2868 .members = 0 2869 } 2870 }, 2871 .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL, 2872 .offset = { 1, 0, -1, -1, -1, -1, -1, -1, -1, 2873 -1, -1, -1, -1, -1, -1, -1, -1, -1 } 2874 }; 2875 2876 struct pcmchan_matrix * 2877 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format) 2878 { 2879 struct uaudio_softc *sc; 2880 2881 sc = ch->priv_sc; 2882 2883 if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 && 2884 AFMT_CHANNEL(format) == 2) 2885 return (&uaudio_chan_matrix_swap_2_0); 2886 2887 return (feeder_matrix_format_map(format)); 2888 } 2889 2890 int 2891 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format) 2892 { 2893 DPRINTF("Selecting format 0x%08x\n", (unsigned int)format); 2894 return (0); 2895 } 2896 2897 static void 2898 uaudio_chan_reconfigure(struct uaudio_chan *ch, uint8_t operation) 2899 { 2900 struct uaudio_softc *sc = ch->priv_sc; 2901 2902 /* Check for shutdown. */ 2903 if (ch->operation == CHAN_OP_DRAIN) 2904 return; 2905 2906 /* Set next operation. */ 2907 ch->operation = operation; 2908 2909 /* 2910 * Because changing the alternate setting modifies the USB 2911 * configuration, this part must be executed from the USB 2912 * explore process. 2913 */ 2914 (void)usb_proc_explore_msignal(sc->sc_udev, 2915 &sc->sc_config_msg[0], &sc->sc_config_msg[1]); 2916 } 2917 2918 static int 2919 uaudio_chan_need_both(struct uaudio_chan *pchan, struct uaudio_chan *rchan) 2920 { 2921 return (pchan->num_alt > 0 && 2922 pchan->running != 0 && 2923 uaudio_chan_is_async(pchan, pchan->set_alt) != 0 && 2924 rchan->num_alt > 0 && 2925 rchan->running == 0); 2926 } 2927 2928 static int 2929 uaudio_chan_need_none(struct uaudio_chan *pchan, struct uaudio_chan *rchan) 2930 { 2931 return (pchan->num_alt > 0 && 2932 pchan->running == 0 && 2933 rchan->num_alt > 0 && 2934 rchan->running == 0); 2935 } 2936 2937 void 2938 uaudio_chan_start(struct uaudio_chan *ch) 2939 { 2940 struct uaudio_softc *sc = ch->priv_sc; 2941 unsigned i = uaudio_get_child_index_by_chan(sc, ch); 2942 2943 /* make operation atomic */ 2944 usb_proc_explore_lock(sc->sc_udev); 2945 2946 /* check if not running */ 2947 if (ch->running == 0) { 2948 uint32_t temp; 2949 2950 /* get current buffer size */ 2951 temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt); 2952 2953 /* set running flag */ 2954 ch->running = 1; 2955 2956 /* ensure the hardware buffer is reset */ 2957 ch->start = ch->buf; 2958 ch->end = ch->buf + temp; 2959 ch->cur = ch->buf; 2960 2961 if (uaudio_chan_need_both( 2962 &sc->sc_play_chan[i], 2963 &sc->sc_rec_chan[i])) { 2964 struct uaudio_chan *ch_play = &sc->sc_play_chan[i]; 2965 struct uaudio_chan *ch_rec = &sc->sc_rec_chan[i]; 2966 uint8_t rec_alt; 2967 2968 /* 2969 * The recording channel is only being started as a 2970 * source of jitter information for the playback 2971 * stream. Align its nominal rate with the 2972 * playback rate so that (a) it does not reprogram 2973 * a sample clock shared with the playback path to 2974 * a conflicting rate, and (b) its expected frame 2975 * sizes match what the device actually produces, 2976 * keeping the derived jitter information valid. 2977 * The USB explore lock is held here, which also 2978 * serializes against uaudio_chan_set_param_speed(). 2979 */ 2980 if (uaudio_chan_match_rate(ch_rec, 2981 ch_play->usb_alt[ch_play->set_alt].sample_rate, 2982 &rec_alt)) 2983 ch_rec->set_alt = rec_alt; 2984 2985 /* 2986 * Start both endpoints because of need for 2987 * jitter information: 2988 */ 2989 uaudio_chan_reconfigure(ch_rec, CHAN_OP_START); 2990 uaudio_chan_reconfigure(ch_play, CHAN_OP_START); 2991 } else { 2992 uaudio_chan_reconfigure(ch, CHAN_OP_START); 2993 } 2994 } 2995 2996 /* exit atomic operation */ 2997 usb_proc_explore_unlock(sc->sc_udev); 2998 } 2999 3000 void 3001 uaudio_chan_stop(struct uaudio_chan *ch) 3002 { 3003 struct uaudio_softc *sc = ch->priv_sc; 3004 unsigned i = uaudio_get_child_index_by_chan(sc, ch); 3005 3006 /* make operation atomic */ 3007 usb_proc_explore_lock(sc->sc_udev); 3008 3009 /* check if running */ 3010 if (ch->running != 0) { 3011 /* clear running flag */ 3012 ch->running = 0; 3013 3014 if (uaudio_chan_need_both( 3015 &sc->sc_play_chan[i], 3016 &sc->sc_rec_chan[i])) { 3017 /* 3018 * Leave the endpoints running because we need 3019 * information about jitter! 3020 */ 3021 } else if (uaudio_chan_need_none( 3022 &sc->sc_play_chan[i], 3023 &sc->sc_rec_chan[i])) { 3024 /* 3025 * Stop both endpoints in case the one was used for 3026 * jitter information: 3027 */ 3028 uaudio_chan_reconfigure(&sc->sc_rec_chan[i], CHAN_OP_STOP); 3029 uaudio_chan_reconfigure(&sc->sc_play_chan[i], CHAN_OP_STOP); 3030 } else { 3031 uaudio_chan_reconfigure(ch, CHAN_OP_STOP); 3032 } 3033 } 3034 3035 /* exit atomic operation */ 3036 usb_proc_explore_unlock(sc->sc_udev); 3037 } 3038 3039 /*========================================================================* 3040 * AC - Audio Controller - routines 3041 *========================================================================*/ 3042 3043 static int 3044 uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS) 3045 { 3046 struct uaudio_softc *sc; 3047 struct uaudio_mixer_node *pmc; 3048 int hint; 3049 int error; 3050 int temp = 0; 3051 int chan = 0; 3052 3053 sc = (struct uaudio_softc *)oidp->oid_arg1; 3054 hint = oidp->oid_arg2; 3055 3056 /* lookup mixer node */ 3057 3058 mtx_lock(&sc->sc_child[0].mixer_lock); 3059 for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) { 3060 for (chan = 0; chan != (int)pmc->nchan; chan++) { 3061 if (pmc->wValue[chan] != -1 && 3062 pmc->wValue[chan] == hint) { 3063 temp = pmc->wData[chan]; 3064 goto found; 3065 } 3066 } 3067 } 3068 found: 3069 mtx_unlock(&sc->sc_child[0].mixer_lock); 3070 3071 error = sysctl_handle_int(oidp, &temp, 0, req); 3072 if (error != 0 || req->newptr == NULL) 3073 return (error); 3074 3075 /* update mixer value */ 3076 3077 mtx_lock(&sc->sc_child[0].mixer_lock); 3078 if (pmc != NULL && 3079 temp >= pmc->minval && 3080 temp <= pmc->maxval) { 3081 pmc->wData[chan] = temp; 3082 pmc->update[(chan / 8)] |= (1 << (chan % 8)); 3083 3084 /* start the transfer, if not already started */ 3085 usbd_transfer_start(sc->sc_mixer_xfer[0]); 3086 } 3087 mtx_unlock(&sc->sc_child[0].mixer_lock); 3088 3089 return (0); 3090 } 3091 3092 static void 3093 uaudio_mixer_ctl_free(struct uaudio_softc *sc) 3094 { 3095 struct uaudio_mixer_node *p_mc; 3096 3097 while ((p_mc = sc->sc_mixer_root) != NULL) { 3098 sc->sc_mixer_root = p_mc->next; 3099 free(p_mc, M_USBDEV); 3100 } 3101 } 3102 3103 static void 3104 uaudio_mixer_register_sysctl(struct uaudio_softc *sc, device_t dev, 3105 unsigned index) 3106 { 3107 struct uaudio_mixer_node *pmc; 3108 struct sysctl_oid *mixer_tree; 3109 struct sysctl_oid *control_tree; 3110 char buf[32]; 3111 int chan; 3112 int n; 3113 3114 if (index != 0) 3115 return; 3116 3117 mixer_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev), 3118 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "mixer", 3119 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, ""); 3120 3121 if (mixer_tree == NULL) 3122 return; 3123 3124 for (n = 0, pmc = sc->sc_mixer_root; pmc != NULL; 3125 pmc = pmc->next, n++) { 3126 for (chan = 0; chan < pmc->nchan; chan++) { 3127 if (pmc->nchan > 1) { 3128 snprintf(buf, sizeof(buf), "%s_%d_%d", 3129 pmc->name, n, chan); 3130 } else { 3131 snprintf(buf, sizeof(buf), "%s_%d", 3132 pmc->name, n); 3133 } 3134 3135 control_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev), 3136 SYSCTL_CHILDREN(mixer_tree), OID_AUTO, buf, 3137 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 3138 "Mixer control nodes"); 3139 3140 if (control_tree == NULL) 3141 continue; 3142 3143 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 3144 SYSCTL_CHILDREN(control_tree), 3145 OID_AUTO, "val", 3146 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 3147 sc, pmc->wValue[chan], 3148 uaudio_mixer_sysctl_handler, "I", "Current value"); 3149 3150 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 3151 SYSCTL_CHILDREN(control_tree), 3152 OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval, 3153 "Minimum value"); 3154 3155 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 3156 SYSCTL_CHILDREN(control_tree), 3157 OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval, 3158 "Maximum value"); 3159 3160 SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev), 3161 SYSCTL_CHILDREN(control_tree), 3162 OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0, 3163 "Description"); 3164 } 3165 } 3166 } 3167 3168 /* M-Audio FastTrack Ultra Mixer Description */ 3169 /* Origin: Linux USB Audio driver */ 3170 static void 3171 uaudio_mixer_controls_create_ftu(struct uaudio_softc *sc) 3172 { 3173 int chx; 3174 int chy; 3175 3176 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3177 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no); 3178 MIX(sc).wValue[0] = MAKE_WORD(8, 0); 3179 MIX(sc).type = MIX_UNSIGNED_16; 3180 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3181 MIX(sc).name = "effect"; 3182 MIX(sc).minval = 0; 3183 MIX(sc).maxval = 7; 3184 MIX(sc).mul = 7; 3185 MIX(sc).nchan = 1; 3186 MIX(sc).update[0] = 1; 3187 strlcpy(MIX(sc).desc, "Room1,2,3,Hall1,2,Plate,Delay,Echo", sizeof(MIX(sc).desc)); 3188 uaudio_mixer_add_ctl_sub(sc, &MIX(sc)); 3189 3190 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3191 MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no); 3192 3193 for (chx = 0; chx != 8; chx++) { 3194 for (chy = 0; chy != 8; chy++) { 3195 MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1); 3196 MIX(sc).type = MIX_SIGNED_16; 3197 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3198 MIX(sc).name = "mix_rec"; 3199 MIX(sc).nchan = 1; 3200 MIX(sc).update[0] = 1; 3201 MIX(sc).val_default = 0; 3202 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 3203 "AIn%d - Out%d Record Volume", chy + 1, chx + 1); 3204 3205 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3206 3207 MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1 + 8); 3208 MIX(sc).type = MIX_SIGNED_16; 3209 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3210 MIX(sc).name = "mix_play"; 3211 MIX(sc).nchan = 1; 3212 MIX(sc).update[0] = 1; 3213 MIX(sc).val_default = (chx == chy) ? 2 : 0; 3214 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 3215 "DIn%d - Out%d Playback Volume", chy + 1, chx + 1); 3216 3217 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3218 } 3219 } 3220 3221 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3222 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no); 3223 MIX(sc).wValue[0] = MAKE_WORD(2, 0); 3224 MIX(sc).type = MIX_SIGNED_8; 3225 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3226 MIX(sc).name = "effect_vol"; 3227 MIX(sc).nchan = 1; 3228 MIX(sc).update[0] = 1; 3229 MIX(sc).minval = 0; 3230 MIX(sc).maxval = 0x7f; 3231 MIX(sc).mul = 0x7f; 3232 MIX(sc).nchan = 1; 3233 MIX(sc).update[0] = 1; 3234 strlcpy(MIX(sc).desc, "Effect Volume", sizeof(MIX(sc).desc)); 3235 uaudio_mixer_add_ctl_sub(sc, &MIX(sc)); 3236 3237 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3238 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no); 3239 MIX(sc).wValue[0] = MAKE_WORD(3, 0); 3240 MIX(sc).type = MIX_SIGNED_16; 3241 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3242 MIX(sc).name = "effect_dur"; 3243 MIX(sc).nchan = 1; 3244 MIX(sc).update[0] = 1; 3245 MIX(sc).minval = 0; 3246 MIX(sc).maxval = 0x7f00; 3247 MIX(sc).mul = 0x7f00; 3248 MIX(sc).nchan = 1; 3249 MIX(sc).update[0] = 1; 3250 strlcpy(MIX(sc).desc, "Effect Duration", sizeof(MIX(sc).desc)); 3251 uaudio_mixer_add_ctl_sub(sc, &MIX(sc)); 3252 3253 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3254 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no); 3255 MIX(sc).wValue[0] = MAKE_WORD(4, 0); 3256 MIX(sc).type = MIX_SIGNED_8; 3257 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3258 MIX(sc).name = "effect_fb"; 3259 MIX(sc).nchan = 1; 3260 MIX(sc).update[0] = 1; 3261 MIX(sc).minval = 0; 3262 MIX(sc).maxval = 0x7f; 3263 MIX(sc).mul = 0x7f; 3264 MIX(sc).nchan = 1; 3265 MIX(sc).update[0] = 1; 3266 strlcpy(MIX(sc).desc, "Effect Feedback Volume", sizeof(MIX(sc).desc)); 3267 uaudio_mixer_add_ctl_sub(sc, &MIX(sc)); 3268 3269 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3270 MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no); 3271 for (chy = 0; chy != 4; chy++) { 3272 MIX(sc).wValue[0] = MAKE_WORD(7, chy + 1); 3273 MIX(sc).type = MIX_SIGNED_16; 3274 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3275 MIX(sc).name = "effect_ret"; 3276 MIX(sc).nchan = 1; 3277 MIX(sc).update[0] = 1; 3278 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 3279 "Effect Return %d Volume", chy + 1); 3280 3281 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3282 } 3283 3284 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3285 MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no); 3286 3287 for (chy = 0; chy != 8; chy++) { 3288 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1); 3289 MIX(sc).type = MIX_SIGNED_16; 3290 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3291 MIX(sc).name = "effect_send"; 3292 MIX(sc).nchan = 1; 3293 MIX(sc).update[0] = 1; 3294 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 3295 "Effect Send AIn%d Volume", chy + 1); 3296 3297 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3298 3299 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1 + 8); 3300 MIX(sc).type = MIX_SIGNED_16; 3301 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3302 MIX(sc).name = "effect_send"; 3303 MIX(sc).nchan = 1; 3304 MIX(sc).update[0] = 1; 3305 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc), 3306 "Effect Send DIn%d Volume", chy + 1); 3307 3308 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3309 } 3310 } 3311 3312 static void 3313 uaudio_mixer_reload_all(struct uaudio_softc *sc) 3314 { 3315 struct uaudio_mixer_node *pmc; 3316 int chan; 3317 3318 mtx_lock(&sc->sc_child[0].mixer_lock); 3319 for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) { 3320 /* use reset defaults for non-oss controlled settings */ 3321 if (pmc->ctl == SOUND_MIXER_NRDEVICES) 3322 continue; 3323 for (chan = 0; chan < pmc->nchan; chan++) 3324 pmc->update[chan / 8] |= (1 << (chan % 8)); 3325 } 3326 usbd_transfer_start(sc->sc_mixer_xfer[0]); 3327 3328 /* start HID volume keys, if any */ 3329 usbd_transfer_start(sc->sc_hid.xfer[0]); 3330 mtx_unlock(&sc->sc_child[0].mixer_lock); 3331 } 3332 3333 static void 3334 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc) 3335 { 3336 struct uaudio_mixer_node *p_mc_new = 3337 malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK); 3338 int ch; 3339 3340 memcpy(p_mc_new, mc, sizeof(*p_mc_new)); 3341 p_mc_new->next = sc->sc_mixer_root; 3342 sc->sc_mixer_root = p_mc_new; 3343 sc->sc_mixer_count++; 3344 3345 /* set default value for all channels */ 3346 for (ch = 0; ch < p_mc_new->nchan; ch++) { 3347 switch (p_mc_new->val_default) { 3348 case 1: 3349 /* 50% */ 3350 p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2; 3351 break; 3352 case 2: 3353 /* 100% */ 3354 p_mc_new->wData[ch] = p_mc_new->maxval; 3355 break; 3356 default: 3357 /* 0% */ 3358 p_mc_new->wData[ch] = p_mc_new->minval; 3359 break; 3360 } 3361 } 3362 } 3363 3364 static void 3365 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc) 3366 { 3367 int32_t res; 3368 3369 DPRINTF("adding %d\n", mc->ctl); 3370 3371 if (mc->type == MIX_ON_OFF) { 3372 mc->minval = 0; 3373 mc->maxval = 1; 3374 } else if (mc->type == MIX_SELECTOR) { 3375 } else { 3376 /* determine min and max values */ 3377 3378 mc->minval = uaudio_mixer_get(sc->sc_udev, 3379 sc->sc_audio_rev, GET_MIN, mc); 3380 mc->maxval = uaudio_mixer_get(sc->sc_udev, 3381 sc->sc_audio_rev, GET_MAX, mc); 3382 3383 /* check if max and min was swapped */ 3384 3385 if (mc->maxval < mc->minval) { 3386 res = mc->maxval; 3387 mc->maxval = mc->minval; 3388 mc->minval = res; 3389 } 3390 3391 /* compute value range */ 3392 mc->mul = mc->maxval - mc->minval; 3393 if (mc->mul == 0) 3394 mc->mul = 1; 3395 3396 /* compute value alignment */ 3397 res = uaudio_mixer_get(sc->sc_udev, 3398 sc->sc_audio_rev, GET_RES, mc); 3399 3400 DPRINTF("Resolution = %d\n", (int)res); 3401 } 3402 3403 uaudio_mixer_add_ctl_sub(sc, mc); 3404 3405 #ifdef USB_DEBUG 3406 if (uaudio_debug > 2) { 3407 uint8_t i; 3408 3409 for (i = 0; i < mc->nchan; i++) { 3410 DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]); 3411 } 3412 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' " 3413 "min=%d max=%d\n", 3414 mc->wIndex, mc->type, mc->ctl, 3415 mc->minval, mc->maxval); 3416 } 3417 #endif 3418 } 3419 3420 static void 3421 uaudio_mixer_add_mixer(struct uaudio_softc *sc, 3422 const struct uaudio_terminal_node *iot, int id) 3423 { 3424 const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu_v1; 3425 const struct usb_audio_mixer_unit_1 *d1; 3426 3427 uint32_t bno; /* bit number */ 3428 uint32_t p; /* bit number accumulator */ 3429 uint32_t mo; /* matching outputs */ 3430 uint32_t mc; /* matching channels */ 3431 uint32_t ichs; /* input channels */ 3432 uint32_t ochs; /* output channels */ 3433 uint32_t c; 3434 uint32_t chs; /* channels */ 3435 uint32_t i; 3436 uint32_t o; 3437 3438 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3439 d0->bUnitId, d0->bNrInPins); 3440 3441 /* compute the number of input channels */ 3442 3443 ichs = 0; 3444 for (i = 0; i < d0->bNrInPins; i++) { 3445 ichs += uaudio_mixer_get_cluster( 3446 d0->baSourceId[i], iot).bNrChannels; 3447 } 3448 3449 d1 = (const void *)(d0->baSourceId + d0->bNrInPins); 3450 3451 /* and the number of output channels */ 3452 3453 ochs = d1->bNrChannels; 3454 3455 DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs); 3456 3457 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3458 3459 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 3460 MIX(sc).type = MIX_SIGNED_16; 3461 3462 if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL) 3463 return; 3464 3465 for (p = i = 0; i < d0->bNrInPins; i++) { 3466 chs = uaudio_mixer_get_cluster( 3467 d0->baSourceId[i], iot).bNrChannels; 3468 mc = 0; 3469 for (c = 0; c < chs; c++) { 3470 mo = 0; 3471 for (o = 0; o < ochs; o++) { 3472 bno = ((p + c) * ochs) + o; 3473 if (BIT_TEST(d1->bmControls, bno)) 3474 mo++; 3475 } 3476 if (mo == 1) 3477 mc++; 3478 } 3479 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) { 3480 /* repeat bit-scan */ 3481 3482 mc = 0; 3483 for (c = 0; c < chs; c++) { 3484 for (o = 0; o < ochs; o++) { 3485 bno = ((p + c) * ochs) + o; 3486 if (BIT_TEST(d1->bmControls, bno)) 3487 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1); 3488 } 3489 } 3490 MIX(sc).nchan = chs; 3491 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3492 } 3493 p += chs; 3494 } 3495 } 3496 3497 static void 3498 uaudio20_mixer_add_mixer(struct uaudio_softc *sc, 3499 const struct uaudio_terminal_node *iot, int id) 3500 { 3501 const struct usb_audio20_mixer_unit_0 *d0 = iot[id].u.mu_v2; 3502 const struct usb_audio20_mixer_unit_1 *d1; 3503 3504 uint32_t bno; /* bit number */ 3505 uint32_t p; /* bit number accumulator */ 3506 uint32_t mo; /* matching outputs */ 3507 uint32_t mc; /* matching channels */ 3508 uint32_t ichs; /* input channels */ 3509 uint32_t ochs; /* output channels */ 3510 uint32_t c; 3511 uint32_t chs; /* channels */ 3512 uint32_t i; 3513 uint32_t o; 3514 3515 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3516 d0->bUnitId, d0->bNrInPins); 3517 3518 /* compute the number of input channels */ 3519 3520 ichs = 0; 3521 for (i = 0; i < d0->bNrInPins; i++) { 3522 ichs += uaudio20_mixer_get_cluster( 3523 d0->baSourceId[i], iot).bNrChannels; 3524 } 3525 3526 d1 = (const void *)(d0->baSourceId + d0->bNrInPins); 3527 3528 /* and the number of output channels */ 3529 3530 ochs = d1->bNrChannels; 3531 3532 DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs); 3533 3534 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3535 3536 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 3537 MIX(sc).type = MIX_SIGNED_16; 3538 3539 if (uaudio20_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL) 3540 return; 3541 3542 for (p = i = 0; i < d0->bNrInPins; i++) { 3543 chs = uaudio20_mixer_get_cluster( 3544 d0->baSourceId[i], iot).bNrChannels; 3545 mc = 0; 3546 for (c = 0; c < chs; c++) { 3547 mo = 0; 3548 for (o = 0; o < ochs; o++) { 3549 bno = ((p + c) * ochs) + o; 3550 if (BIT_TEST(d1->bmControls, bno)) 3551 mo++; 3552 } 3553 if (mo == 1) 3554 mc++; 3555 } 3556 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) { 3557 /* repeat bit-scan */ 3558 3559 mc = 0; 3560 for (c = 0; c < chs; c++) { 3561 for (o = 0; o < ochs; o++) { 3562 bno = ((p + c) * ochs) + o; 3563 if (BIT_TEST(d1->bmControls, bno)) 3564 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1); 3565 } 3566 } 3567 MIX(sc).nchan = chs; 3568 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3569 } 3570 p += chs; 3571 } 3572 } 3573 3574 static void 3575 uaudio_mixer_check_selectors(struct uaudio_softc *sc) 3576 { 3577 uint8_t reserve_feature[] = { 3578 SOUND_MIXER_LINE, 3579 SOUND_MIXER_LINE1, 3580 SOUND_MIXER_LINE2, 3581 SOUND_MIXER_LINE3, 3582 SOUND_MIXER_DIGITAL1, 3583 SOUND_MIXER_DIGITAL2, 3584 SOUND_MIXER_DIGITAL3, 3585 }; 3586 const uint16_t reserve_max = 3587 sizeof(reserve_feature) / sizeof(reserve_feature[0]); 3588 uint16_t i; 3589 uint16_t j; 3590 uint16_t k; 3591 3592 /* remove existing selector types from the reserve */ 3593 for (i = 0; i < MIX(sc).maxval; i++) { 3594 if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES) 3595 continue; 3596 for (j = 0; j != reserve_max; j++) { 3597 if (reserve_feature[j] == MIX(sc).slctrtype[i]) 3598 reserve_feature[j] = SOUND_MIXER_NRDEVICES; 3599 } 3600 } 3601 3602 /* make sure selector types are not overlapping */ 3603 for (i = 0; i < MIX(sc).maxval; i++) { 3604 if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES) 3605 continue; 3606 for (j = i + 1; j < MIX(sc).maxval; j++) { 3607 if (MIX(sc).slctrtype[j] == SOUND_MIXER_NRDEVICES) 3608 continue; 3609 if (MIX(sc).slctrtype[i] != MIX(sc).slctrtype[j]) 3610 continue; 3611 for (k = 0; k != reserve_max; k++) { 3612 if (reserve_feature[k] == SOUND_MIXER_NRDEVICES) 3613 continue; 3614 MIX(sc).slctrtype[j] = reserve_feature[k]; 3615 reserve_feature[k] = SOUND_MIXER_NRDEVICES; 3616 break; 3617 } 3618 if (k == reserve_max) { 3619 DPRINTF("Selector type %d is not selectable!\n", j); 3620 MIX(sc).slctrtype[j] = SOUND_MIXER_NRDEVICES; 3621 } 3622 } 3623 } 3624 } 3625 3626 static void 3627 uaudio_mixer_add_selector(struct uaudio_softc *sc, 3628 const struct uaudio_terminal_node *iot, int id) 3629 { 3630 const struct usb_audio_selector_unit *d = iot[id].u.su_v1; 3631 uint16_t i; 3632 3633 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3634 d->bUnitId, d->bNrInPins); 3635 3636 if (d->bNrInPins == 0) 3637 return; 3638 3639 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3640 3641 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 3642 MIX(sc).wValue[0] = MAKE_WORD(0, 0); 3643 MIX(sc).nchan = 1; 3644 MIX(sc).type = MIX_SELECTOR; 3645 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3646 MIX(sc).minval = 1; 3647 MIX(sc).maxval = d->bNrInPins; 3648 MIX(sc).name = "selector"; 3649 3650 i = d->baSourceId[d->bNrInPins]; 3651 if (i == 0 || 3652 usbd_req_get_string_any(sc->sc_udev, NULL, 3653 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) { 3654 MIX(sc).desc[0] = 0; 3655 } 3656 3657 if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN) 3658 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN; 3659 3660 MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval; 3661 3662 for (i = 0; i < MIX(sc).maxval; i++) { 3663 MIX(sc).slctrtype[i] = 3664 uaudio_mixer_determine_class(&iot[d->baSourceId[i]]); 3665 } 3666 for (; i < MAX_SELECTOR_INPUT_PIN; i++) 3667 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES; 3668 3669 uaudio_mixer_check_selectors(sc); 3670 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3671 } 3672 3673 static void 3674 uaudio20_mixer_add_selector(struct uaudio_softc *sc, 3675 const struct uaudio_terminal_node *iot, int id) 3676 { 3677 const struct usb_audio20_selector_unit *d = iot[id].u.su_v2; 3678 uint16_t i; 3679 3680 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 3681 d->bUnitId, d->bNrInPins); 3682 3683 if (d->bNrInPins == 0) 3684 return; 3685 3686 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3687 3688 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 3689 MIX(sc).wValue[0] = MAKE_WORD(0, 0); 3690 MIX(sc).nchan = 1; 3691 MIX(sc).type = MIX_SELECTOR; 3692 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; 3693 MIX(sc).minval = 1; 3694 MIX(sc).maxval = d->bNrInPins; 3695 MIX(sc).name = "selector"; 3696 3697 i = d->baSourceId[d->bNrInPins]; 3698 if (i == 0 || 3699 usbd_req_get_string_any(sc->sc_udev, NULL, 3700 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) { 3701 MIX(sc).desc[0] = 0; 3702 } 3703 3704 if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN) 3705 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN; 3706 3707 MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval; 3708 3709 for (i = 0; i < MIX(sc).maxval; i++) { 3710 MIX(sc).slctrtype[i] = 3711 uaudio20_mixer_determine_class(&iot[d->baSourceId[i]]); 3712 } 3713 for (; i < MAX_SELECTOR_INPUT_PIN; i++) 3714 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES; 3715 3716 uaudio_mixer_check_selectors(sc); 3717 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3718 } 3719 3720 static uint32_t 3721 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d, 3722 uint8_t i) 3723 { 3724 uint32_t temp = 0; 3725 uint32_t offset = (i * d->bControlSize); 3726 3727 if (d->bControlSize > 0) { 3728 temp |= d->bmaControls[offset]; 3729 if (d->bControlSize > 1) { 3730 temp |= d->bmaControls[offset + 1] << 8; 3731 if (d->bControlSize > 2) { 3732 temp |= d->bmaControls[offset + 2] << 16; 3733 if (d->bControlSize > 3) { 3734 temp |= d->bmaControls[offset + 3] << 24; 3735 } 3736 } 3737 } 3738 } 3739 return (temp); 3740 } 3741 3742 static void 3743 uaudio_mixer_add_feature(struct uaudio_softc *sc, 3744 const struct uaudio_terminal_node *iot, int id) 3745 { 3746 const struct usb_audio_feature_unit *d = iot[id].u.fu_v1; 3747 uint32_t fumask; 3748 uint32_t mmask; 3749 uint32_t cmask; 3750 uint16_t mixernumber; 3751 uint8_t nchan; 3752 uint8_t chan; 3753 uint8_t ctl; 3754 uint8_t i; 3755 3756 if (d->bControlSize == 0) 3757 return; 3758 3759 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3760 3761 nchan = (d->bLength - 7) / d->bControlSize; 3762 mmask = uaudio_mixer_feature_get_bmaControls(d, 0); 3763 cmask = 0; 3764 3765 if (nchan == 0) 3766 return; 3767 3768 /* figure out what we can control */ 3769 3770 for (chan = 1; chan < nchan; chan++) { 3771 DPRINTFN(10, "chan=%d mask=%x\n", 3772 chan, uaudio_mixer_feature_get_bmaControls(d, chan)); 3773 3774 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan); 3775 } 3776 3777 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 3778 3779 i = d->bmaControls[nchan * d->bControlSize]; 3780 if (i == 0 || 3781 usbd_req_get_string_any(sc->sc_udev, NULL, 3782 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) { 3783 MIX(sc).desc[0] = 0; 3784 } 3785 3786 if (nchan > MIX_MAX_CHAN) 3787 nchan = MIX_MAX_CHAN; 3788 3789 for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) { 3790 fumask = FU_MASK(ctl); 3791 3792 DPRINTFN(5, "ctl=%d fumask=0x%04x\n", 3793 ctl, fumask); 3794 3795 if (mmask & fumask) { 3796 MIX(sc).nchan = 1; 3797 MIX(sc).wValue[0] = MAKE_WORD(ctl, 0); 3798 } else if (cmask & fumask) { 3799 MIX(sc).nchan = nchan - 1; 3800 for (i = 1; i < nchan; i++) { 3801 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask) 3802 MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i); 3803 else 3804 MIX(sc).wValue[i - 1] = -1; 3805 } 3806 } else { 3807 continue; 3808 } 3809 3810 mixernumber = uaudio_mixer_determine_class(&iot[id]); 3811 3812 switch (ctl) { 3813 case MUTE_CONTROL: 3814 MIX(sc).type = MIX_ON_OFF; 3815 MIX(sc).ctl = SOUND_MIXER_MUTE; 3816 MIX(sc).name = "mute"; 3817 break; 3818 3819 case VOLUME_CONTROL: 3820 MIX(sc).type = MIX_SIGNED_16; 3821 MIX(sc).ctl = mixernumber; 3822 MIX(sc).name = "vol"; 3823 break; 3824 3825 case BASS_CONTROL: 3826 MIX(sc).type = MIX_SIGNED_8; 3827 MIX(sc).ctl = SOUND_MIXER_BASS; 3828 MIX(sc).name = "bass"; 3829 break; 3830 3831 case MID_CONTROL: 3832 MIX(sc).type = MIX_SIGNED_8; 3833 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3834 MIX(sc).name = "mid"; 3835 break; 3836 3837 case TREBLE_CONTROL: 3838 MIX(sc).type = MIX_SIGNED_8; 3839 MIX(sc).ctl = SOUND_MIXER_TREBLE; 3840 MIX(sc).name = "treble"; 3841 break; 3842 3843 case GRAPHIC_EQUALIZER_CONTROL: 3844 continue; /* XXX don't add anything */ 3845 3846 case AGC_CONTROL: 3847 MIX(sc).type = MIX_ON_OFF; 3848 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3849 MIX(sc).name = "agc"; 3850 break; 3851 3852 case DELAY_CONTROL: 3853 MIX(sc).type = MIX_UNSIGNED_16; 3854 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3855 MIX(sc).name = "delay"; 3856 break; 3857 3858 case BASS_BOOST_CONTROL: 3859 MIX(sc).type = MIX_ON_OFF; 3860 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3861 MIX(sc).name = "boost"; 3862 break; 3863 3864 case LOUDNESS_CONTROL: 3865 MIX(sc).type = MIX_ON_OFF; 3866 MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */ 3867 MIX(sc).name = "loudness"; 3868 break; 3869 3870 default: 3871 MIX(sc).type = MIX_UNKNOWN; 3872 break; 3873 } 3874 3875 if (MIX(sc).type != MIX_UNKNOWN) 3876 uaudio_mixer_add_ctl(sc, &MIX(sc)); 3877 } 3878 } 3879 3880 static void 3881 uaudio20_mixer_add_feature(struct uaudio_softc *sc, 3882 const struct uaudio_terminal_node *iot, int id) 3883 { 3884 const struct usb_audio20_feature_unit *d = iot[id].u.fu_v2; 3885 uint32_t ctl; 3886 uint32_t mmask; 3887 uint32_t cmask; 3888 uint16_t mixernumber; 3889 uint8_t nchan; 3890 uint8_t chan; 3891 uint8_t i; 3892 uint8_t what; 3893 3894 if (UGETDW(d->bmaControls[0]) == 0) 3895 return; 3896 3897 memset(&MIX(sc), 0, sizeof(MIX(sc))); 3898 3899 nchan = (d->bLength - 6) / 4; 3900 mmask = UGETDW(d->bmaControls[0]); 3901 cmask = 0; 3902 3903 if (nchan == 0) 3904 return; 3905 3906 /* figure out what we can control */ 3907 3908 for (chan = 1; chan < nchan; chan++) 3909 cmask |= UGETDW(d->bmaControls[chan]); 3910 3911 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 3912 3913 i = d->bmaControls[nchan][0]; 3914 if (i == 0 || 3915 usbd_req_get_string_any(sc->sc_udev, NULL, 3916 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) { 3917 MIX(sc).desc[0] = 0; 3918 } 3919 3920 if (nchan > MIX_MAX_CHAN) 3921 nchan = MIX_MAX_CHAN; 3922 3923 for (ctl = 3; ctl != 0; ctl <<= 2) { 3924 mixernumber = uaudio20_mixer_determine_class(&iot[id]); 3925 3926 switch (ctl) { 3927 case (3 << 0): 3928 MIX(sc).type = MIX_ON_OFF; 3929 MIX(sc).ctl = SOUND_MIXER_MUTE; 3930 MIX(sc).name = "mute"; 3931 what = MUTE_CONTROL; 3932 break; 3933 case (3 << 2): 3934 MIX(sc).type = MIX_SIGNED_16; 3935 MIX(sc).ctl = mixernumber; 3936 MIX(sc).name = "vol"; 3937 what = VOLUME_CONTROL; 3938 break; 3939 case (3 << 4): 3940 MIX(sc).type = MIX_SIGNED_8; 3941 MIX(sc).ctl = SOUND_MIXER_BASS; 3942 MIX(sc).name = "bass"; 3943 what = BASS_CONTROL; 3944 break; 3945 case (3 << 6): 3946 MIX(sc).type = MIX_SIGNED_8; 3947 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3948 MIX(sc).name = "mid"; 3949 what = MID_CONTROL; 3950 break; 3951 case (3 << 8): 3952 MIX(sc).type = MIX_SIGNED_8; 3953 MIX(sc).ctl = SOUND_MIXER_TREBLE; 3954 MIX(sc).name = "treble"; 3955 what = TREBLE_CONTROL; 3956 break; 3957 case (3 << 12): 3958 MIX(sc).type = MIX_ON_OFF; 3959 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3960 MIX(sc).name = "agc"; 3961 what = AGC_CONTROL; 3962 break; 3963 case (3 << 14): 3964 MIX(sc).type = MIX_UNSIGNED_16; 3965 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3966 MIX(sc).name = "delay"; 3967 what = DELAY_CONTROL; 3968 break; 3969 case (3 << 16): 3970 MIX(sc).type = MIX_ON_OFF; 3971 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 3972 MIX(sc).name = "boost"; 3973 what = BASS_BOOST_CONTROL; 3974 break; 3975 case (3 << 18): 3976 MIX(sc).type = MIX_ON_OFF; 3977 MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */ 3978 MIX(sc).name = "loudness"; 3979 what = LOUDNESS_CONTROL; 3980 break; 3981 case (3 << 20): 3982 MIX(sc).type = MIX_SIGNED_16; 3983 MIX(sc).ctl = mixernumber; 3984 MIX(sc).name = "igain"; 3985 what = INPUT_GAIN_CONTROL; 3986 break; 3987 case (3 << 22): 3988 MIX(sc).type = MIX_SIGNED_16; 3989 MIX(sc).ctl = mixernumber; 3990 MIX(sc).name = "igainpad"; 3991 what = INPUT_GAIN_PAD_CONTROL; 3992 break; 3993 default: 3994 continue; 3995 } 3996 3997 if ((mmask & ctl) == ctl) { 3998 MIX(sc).nchan = 1; 3999 MIX(sc).wValue[0] = MAKE_WORD(what, 0); 4000 } else if ((cmask & ctl) == ctl) { 4001 MIX(sc).nchan = nchan - 1; 4002 for (i = 1; i < nchan; i++) { 4003 if ((UGETDW(d->bmaControls[i]) & ctl) == ctl) 4004 MIX(sc).wValue[i - 1] = MAKE_WORD(what, i); 4005 else 4006 MIX(sc).wValue[i - 1] = -1; 4007 } 4008 } else { 4009 continue; 4010 } 4011 4012 if (MIX(sc).type != MIX_UNKNOWN) 4013 uaudio_mixer_add_ctl(sc, &MIX(sc)); 4014 } 4015 } 4016 4017 static void 4018 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc, 4019 const struct uaudio_terminal_node *iot, int id) 4020 { 4021 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1; 4022 const struct usb_audio_processing_unit_1 *d1 = 4023 (const void *)(d0->baSourceId + d0->bNrInPins); 4024 const struct usb_audio_processing_unit_updown *ud = 4025 (const void *)(d1->bmControls + d1->bControlSize); 4026 uint8_t i; 4027 4028 if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) { 4029 return; 4030 } 4031 if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes)) 4032 == NULL) { 4033 return; 4034 } 4035 DPRINTFN(3, "bUnitId=%d bNrModes=%d\n", 4036 d0->bUnitId, ud->bNrModes); 4037 4038 if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) { 4039 DPRINTF("no mode select\n"); 4040 return; 4041 } 4042 memset(&MIX(sc), 0, sizeof(MIX(sc))); 4043 4044 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 4045 MIX(sc).nchan = 1; 4046 MIX(sc).wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0); 4047 MIX(sc).type = MIX_ON_OFF; /* XXX */ 4048 4049 for (i = 0; i < ud->bNrModes; i++) { 4050 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i])); 4051 /* XXX */ 4052 } 4053 4054 uaudio_mixer_add_ctl(sc, &MIX(sc)); 4055 } 4056 4057 static void 4058 uaudio_mixer_add_processing(struct uaudio_softc *sc, 4059 const struct uaudio_terminal_node *iot, int id) 4060 { 4061 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1; 4062 const struct usb_audio_processing_unit_1 *d1 = 4063 (const void *)(d0->baSourceId + d0->bNrInPins); 4064 uint16_t ptype; 4065 4066 memset(&MIX(sc), 0, sizeof(MIX(sc))); 4067 4068 ptype = UGETW(d0->wProcessType); 4069 4070 DPRINTFN(3, "wProcessType=%d bUnitId=%d " 4071 "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins); 4072 4073 if (d1->bControlSize == 0) { 4074 return; 4075 } 4076 if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) { 4077 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 4078 MIX(sc).nchan = 1; 4079 MIX(sc).wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0); 4080 MIX(sc).type = MIX_ON_OFF; 4081 uaudio_mixer_add_ctl(sc, &MIX(sc)); 4082 } 4083 switch (ptype) { 4084 case UPDOWNMIX_PROCESS: 4085 uaudio_mixer_add_processing_updown(sc, iot, id); 4086 break; 4087 4088 case DOLBY_PROLOGIC_PROCESS: 4089 case P3D_STEREO_EXTENDER_PROCESS: 4090 case REVERBATION_PROCESS: 4091 case CHORUS_PROCESS: 4092 case DYN_RANGE_COMP_PROCESS: 4093 default: 4094 DPRINTF("unit %d, type=%d is not implemented\n", 4095 d0->bUnitId, ptype); 4096 break; 4097 } 4098 } 4099 4100 static void 4101 uaudio_mixer_add_extension(struct uaudio_softc *sc, 4102 const struct uaudio_terminal_node *iot, int id) 4103 { 4104 const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu_v1; 4105 const struct usb_audio_extension_unit_1 *d1 = 4106 (const void *)(d0->baSourceId + d0->bNrInPins); 4107 4108 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 4109 d0->bUnitId, d0->bNrInPins); 4110 4111 if (sc->sc_uq_au_no_xu) { 4112 return; 4113 } 4114 if (d1->bControlSize == 0) { 4115 return; 4116 } 4117 if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) { 4118 memset(&MIX(sc), 0, sizeof(MIX(sc))); 4119 4120 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 4121 MIX(sc).nchan = 1; 4122 MIX(sc).wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0); 4123 MIX(sc).type = MIX_ON_OFF; 4124 4125 uaudio_mixer_add_ctl(sc, &MIX(sc)); 4126 } 4127 } 4128 4129 static const void * 4130 uaudio_mixer_verify_desc(const void *arg, uint32_t len) 4131 { 4132 const struct usb_audio_mixer_unit_1 *d1; 4133 const struct usb_audio_extension_unit_1 *e1; 4134 const struct usb_audio_processing_unit_1 *u1; 4135 4136 union { 4137 const struct usb_descriptor *desc; 4138 const struct usb_audio_input_terminal *it; 4139 const struct usb_audio_output_terminal *ot; 4140 const struct usb_audio_mixer_unit_0 *mu; 4141 const struct usb_audio_selector_unit *su; 4142 const struct usb_audio_feature_unit *fu; 4143 const struct usb_audio_processing_unit_0 *pu; 4144 const struct usb_audio_extension_unit_0 *eu; 4145 } u; 4146 4147 u.desc = arg; 4148 4149 if (u.desc == NULL) { 4150 goto error; 4151 } 4152 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) { 4153 goto error; 4154 } 4155 switch (u.desc->bDescriptorSubtype) { 4156 case UDESCSUB_AC_INPUT: 4157 len += sizeof(*u.it); 4158 break; 4159 4160 case UDESCSUB_AC_OUTPUT: 4161 len += sizeof(*u.ot); 4162 break; 4163 4164 case UDESCSUB_AC_MIXER: 4165 len += sizeof(*u.mu); 4166 4167 if (u.desc->bLength < len) { 4168 goto error; 4169 } 4170 len += u.mu->bNrInPins; 4171 4172 if (u.desc->bLength < len) { 4173 goto error; 4174 } 4175 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins); 4176 4177 len += sizeof(*d1); 4178 break; 4179 4180 case UDESCSUB_AC_SELECTOR: 4181 len += sizeof(*u.su); 4182 4183 if (u.desc->bLength < len) { 4184 goto error; 4185 } 4186 len += u.su->bNrInPins + 1; 4187 break; 4188 4189 case UDESCSUB_AC_FEATURE: 4190 len += sizeof(*u.fu) + 1; 4191 4192 if (u.desc->bLength < len) 4193 goto error; 4194 4195 len += u.fu->bControlSize; 4196 break; 4197 4198 case UDESCSUB_AC_PROCESSING: 4199 len += sizeof(*u.pu); 4200 4201 if (u.desc->bLength < len) { 4202 goto error; 4203 } 4204 len += u.pu->bNrInPins; 4205 4206 if (u.desc->bLength < len) { 4207 goto error; 4208 } 4209 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins); 4210 4211 len += sizeof(*u1); 4212 4213 if (u.desc->bLength < len) { 4214 goto error; 4215 } 4216 len += u1->bControlSize; 4217 4218 break; 4219 4220 case UDESCSUB_AC_EXTENSION: 4221 len += sizeof(*u.eu); 4222 4223 if (u.desc->bLength < len) { 4224 goto error; 4225 } 4226 len += u.eu->bNrInPins; 4227 4228 if (u.desc->bLength < len) { 4229 goto error; 4230 } 4231 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins); 4232 4233 len += sizeof(*e1); 4234 4235 if (u.desc->bLength < len) { 4236 goto error; 4237 } 4238 len += e1->bControlSize; 4239 break; 4240 4241 default: 4242 goto error; 4243 } 4244 4245 if (u.desc->bLength < len) { 4246 goto error; 4247 } 4248 return (u.desc); 4249 4250 error: 4251 if (u.desc) { 4252 DPRINTF("invalid descriptor, type=%d, " 4253 "sub_type=%d, len=%d of %d bytes\n", 4254 u.desc->bDescriptorType, 4255 u.desc->bDescriptorSubtype, 4256 u.desc->bLength, len); 4257 } 4258 return (NULL); 4259 } 4260 4261 static const void * 4262 uaudio20_mixer_verify_desc(const void *arg, uint32_t len) 4263 { 4264 const struct usb_audio20_mixer_unit_1 *d1; 4265 const struct usb_audio20_extension_unit_1 *e1; 4266 const struct usb_audio20_processing_unit_1 *u1; 4267 const struct usb_audio20_clock_selector_unit_1 *c1; 4268 4269 union { 4270 const struct usb_descriptor *desc; 4271 const struct usb_audio20_clock_source_unit *csrc; 4272 const struct usb_audio20_clock_selector_unit_0 *csel; 4273 const struct usb_audio20_clock_multiplier_unit *cmul; 4274 const struct usb_audio20_input_terminal *it; 4275 const struct usb_audio20_output_terminal *ot; 4276 const struct usb_audio20_mixer_unit_0 *mu; 4277 const struct usb_audio20_selector_unit *su; 4278 const struct usb_audio20_feature_unit *fu; 4279 const struct usb_audio20_sample_rate_unit *ru; 4280 const struct usb_audio20_processing_unit_0 *pu; 4281 const struct usb_audio20_extension_unit_0 *eu; 4282 const struct usb_audio20_effect_unit *ef; 4283 } u; 4284 4285 u.desc = arg; 4286 4287 if (u.desc == NULL) 4288 goto error; 4289 4290 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) 4291 goto error; 4292 4293 switch (u.desc->bDescriptorSubtype) { 4294 case UDESCSUB_AC_INPUT: 4295 len += sizeof(*u.it); 4296 break; 4297 4298 case UDESCSUB_AC_OUTPUT: 4299 len += sizeof(*u.ot); 4300 break; 4301 4302 case UDESCSUB_AC_MIXER: 4303 len += sizeof(*u.mu); 4304 4305 if (u.desc->bLength < len) 4306 goto error; 4307 len += u.mu->bNrInPins; 4308 4309 if (u.desc->bLength < len) 4310 goto error; 4311 4312 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins); 4313 4314 len += sizeof(*d1) + d1->bNrChannels; 4315 break; 4316 4317 case UDESCSUB_AC_SELECTOR: 4318 len += sizeof(*u.su); 4319 4320 if (u.desc->bLength < len) 4321 goto error; 4322 4323 len += u.su->bNrInPins + 1; 4324 break; 4325 4326 case UDESCSUB_AC_FEATURE: 4327 len += sizeof(*u.fu) + 1; 4328 break; 4329 4330 case UDESCSUB_AC_EFFECT: 4331 len += sizeof(*u.ef) + 4; 4332 break; 4333 4334 case UDESCSUB_AC_PROCESSING_V2: 4335 len += sizeof(*u.pu); 4336 4337 if (u.desc->bLength < len) 4338 goto error; 4339 4340 len += u.pu->bNrInPins; 4341 4342 if (u.desc->bLength < len) 4343 goto error; 4344 4345 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins); 4346 4347 len += sizeof(*u1); 4348 break; 4349 4350 case UDESCSUB_AC_EXTENSION_V2: 4351 len += sizeof(*u.eu); 4352 4353 if (u.desc->bLength < len) 4354 goto error; 4355 4356 len += u.eu->bNrInPins; 4357 4358 if (u.desc->bLength < len) 4359 goto error; 4360 4361 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins); 4362 4363 len += sizeof(*e1); 4364 break; 4365 4366 case UDESCSUB_AC_CLOCK_SRC: 4367 len += sizeof(*u.csrc); 4368 break; 4369 4370 case UDESCSUB_AC_CLOCK_SEL: 4371 len += sizeof(*u.csel); 4372 4373 if (u.desc->bLength < len) 4374 goto error; 4375 4376 len += u.csel->bNrInPins; 4377 4378 if (u.desc->bLength < len) 4379 goto error; 4380 4381 c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins); 4382 4383 len += sizeof(*c1); 4384 break; 4385 4386 case UDESCSUB_AC_CLOCK_MUL: 4387 len += sizeof(*u.cmul); 4388 break; 4389 4390 case UDESCSUB_AC_SAMPLE_RT: 4391 len += sizeof(*u.ru); 4392 break; 4393 4394 default: 4395 goto error; 4396 } 4397 4398 if (u.desc->bLength < len) 4399 goto error; 4400 4401 return (u.desc); 4402 4403 error: 4404 if (u.desc) { 4405 DPRINTF("invalid descriptor, type=%d, " 4406 "sub_type=%d, len=%d of %d bytes\n", 4407 u.desc->bDescriptorType, 4408 u.desc->bDescriptorSubtype, 4409 u.desc->bLength, len); 4410 } 4411 return (NULL); 4412 } 4413 4414 static struct usb_audio_cluster 4415 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot) 4416 { 4417 struct usb_audio_cluster r; 4418 const struct usb_descriptor *dp; 4419 uint8_t i; 4420 4421 for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) { /* avoid infinite loops */ 4422 dp = iot[id].u.desc; 4423 if (dp == NULL) { 4424 goto error; 4425 } 4426 switch (dp->bDescriptorSubtype) { 4427 case UDESCSUB_AC_INPUT: 4428 r.bNrChannels = iot[id].u.it_v1->bNrChannels; 4429 r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0]; 4430 r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1]; 4431 r.iChannelNames = iot[id].u.it_v1->iChannelNames; 4432 goto done; 4433 4434 case UDESCSUB_AC_OUTPUT: 4435 id = iot[id].u.ot_v1->bSourceId; 4436 break; 4437 4438 case UDESCSUB_AC_MIXER: 4439 r = *(const struct usb_audio_cluster *) 4440 &iot[id].u.mu_v1->baSourceId[ 4441 iot[id].u.mu_v1->bNrInPins]; 4442 goto done; 4443 4444 case UDESCSUB_AC_SELECTOR: 4445 if (iot[id].u.su_v1->bNrInPins > 0) { 4446 /* XXX This is not really right */ 4447 id = iot[id].u.su_v1->baSourceId[0]; 4448 } 4449 break; 4450 4451 case UDESCSUB_AC_FEATURE: 4452 id = iot[id].u.fu_v1->bSourceId; 4453 break; 4454 4455 case UDESCSUB_AC_PROCESSING: 4456 r = *((const struct usb_audio_cluster *) 4457 &iot[id].u.pu_v1->baSourceId[ 4458 iot[id].u.pu_v1->bNrInPins]); 4459 goto done; 4460 4461 case UDESCSUB_AC_EXTENSION: 4462 r = *((const struct usb_audio_cluster *) 4463 &iot[id].u.eu_v1->baSourceId[ 4464 iot[id].u.eu_v1->bNrInPins]); 4465 goto done; 4466 4467 default: 4468 goto error; 4469 } 4470 } 4471 error: 4472 DPRINTF("bad data\n"); 4473 memset(&r, 0, sizeof(r)); 4474 done: 4475 return (r); 4476 } 4477 4478 static struct usb_audio20_cluster 4479 uaudio20_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot) 4480 { 4481 struct usb_audio20_cluster r; 4482 const struct usb_descriptor *dp; 4483 uint8_t i; 4484 4485 for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) { /* avoid infinite loops */ 4486 dp = iot[id].u.desc; 4487 if (dp == NULL) 4488 goto error; 4489 4490 switch (dp->bDescriptorSubtype) { 4491 case UDESCSUB_AC_INPUT: 4492 r.bNrChannels = iot[id].u.it_v2->bNrChannels; 4493 r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0]; 4494 r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1]; 4495 r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2]; 4496 r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3]; 4497 r.iChannelNames = iot[id].u.it_v2->iTerminal; 4498 goto done; 4499 4500 case UDESCSUB_AC_OUTPUT: 4501 id = iot[id].u.ot_v2->bSourceId; 4502 break; 4503 4504 case UDESCSUB_AC_MIXER: 4505 r = *(const struct usb_audio20_cluster *) 4506 &iot[id].u.mu_v2->baSourceId[ 4507 iot[id].u.mu_v2->bNrInPins]; 4508 goto done; 4509 4510 case UDESCSUB_AC_SELECTOR: 4511 if (iot[id].u.su_v2->bNrInPins > 0) { 4512 /* XXX This is not really right */ 4513 id = iot[id].u.su_v2->baSourceId[0]; 4514 } 4515 break; 4516 4517 case UDESCSUB_AC_SAMPLE_RT: 4518 id = iot[id].u.ru_v2->bSourceId; 4519 break; 4520 4521 case UDESCSUB_AC_EFFECT: 4522 id = iot[id].u.ef_v2->bSourceId; 4523 break; 4524 4525 case UDESCSUB_AC_FEATURE: 4526 id = iot[id].u.fu_v2->bSourceId; 4527 break; 4528 4529 case UDESCSUB_AC_PROCESSING_V2: 4530 r = *((const struct usb_audio20_cluster *) 4531 &iot[id].u.pu_v2->baSourceId[ 4532 iot[id].u.pu_v2->bNrInPins]); 4533 goto done; 4534 4535 case UDESCSUB_AC_EXTENSION_V2: 4536 r = *((const struct usb_audio20_cluster *) 4537 &iot[id].u.eu_v2->baSourceId[ 4538 iot[id].u.eu_v2->bNrInPins]); 4539 goto done; 4540 4541 default: 4542 goto error; 4543 } 4544 } 4545 error: 4546 DPRINTF("Bad data!\n"); 4547 memset(&r, 0, sizeof(r)); 4548 done: 4549 return (r); 4550 } 4551 4552 static bool 4553 uaudio_mixer_foreach_input(const struct uaudio_terminal_node *iot, uint8_t *pindex) 4554 { 4555 uint8_t n; 4556 4557 n = *pindex; 4558 4559 while (1) { 4560 if (!n--) 4561 n = iot->usr.id_max; 4562 if (n == 0) 4563 return (false); 4564 if (iot->usr.bit_input[n / 8] & (1 << (n % 8))) 4565 break; 4566 } 4567 *pindex = n; 4568 return (true); 4569 } 4570 4571 static bool 4572 uaudio_mixer_foreach_output(const struct uaudio_terminal_node *iot, uint8_t *pindex) 4573 { 4574 uint8_t n; 4575 4576 n = *pindex; 4577 4578 while (1) { 4579 if (!n--) 4580 n = iot->usr.id_max; 4581 if (n == 0) 4582 return (false); 4583 if (iot->usr.bit_output[n / 8] & (1 << (n % 8))) 4584 break; 4585 } 4586 *pindex = n; 4587 return (true); 4588 } 4589 4590 struct uaudio_tt_to_feature { 4591 uint16_t terminal_type; 4592 uint16_t feature; 4593 }; 4594 4595 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = { 4596 {UATI_MICROPHONE, SOUND_MIXER_MIC}, 4597 {UATI_DESKMICROPHONE, SOUND_MIXER_MIC}, 4598 {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC}, 4599 {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC}, 4600 {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC}, 4601 {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC}, 4602 4603 {UATE_ANALOGCONN, SOUND_MIXER_LINE}, 4604 {UATE_LINECONN, SOUND_MIXER_LINE}, 4605 {UATE_LEGACYCONN, SOUND_MIXER_LINE}, 4606 4607 {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM}, 4608 {UATE_SPDIF, SOUND_MIXER_ALTPCM}, 4609 {UATE_1394DA, SOUND_MIXER_ALTPCM}, 4610 {UATE_1394DV, SOUND_MIXER_ALTPCM}, 4611 4612 {UATF_CDPLAYER, SOUND_MIXER_CD}, 4613 4614 {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH}, 4615 4616 {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO}, 4617 {UATF_DVDAUDIO, SOUND_MIXER_VIDEO}, 4618 {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO}, 4619 4620 {UATF_RADIORECV, SOUND_MIXER_RADIO}, 4621 {UATF_RADIOXMIT, SOUND_MIXER_RADIO}, 4622 4623 {} /* END */ 4624 }; 4625 4626 static uint16_t 4627 uaudio_mixer_get_feature_by_tt(uint16_t terminal_type, uint16_t default_type) 4628 { 4629 const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature; 4630 uint16_t retval; 4631 4632 if (terminal_type == 0) { 4633 retval = default_type; 4634 } else while (1) { 4635 if (uat->terminal_type == 0) { 4636 switch (terminal_type >> 8) { 4637 case UATI_UNDEFINED >> 8: 4638 retval = SOUND_MIXER_RECLEV; 4639 goto done; 4640 case UATO_UNDEFINED >> 8: 4641 retval = SOUND_MIXER_PCM; 4642 goto done; 4643 case UATT_UNDEFINED >> 8: 4644 retval = SOUND_MIXER_PHONEIN; 4645 goto done; 4646 default: 4647 retval = default_type; 4648 goto done; 4649 } 4650 } else if (uat->terminal_type == terminal_type) { 4651 retval = uat->feature; 4652 goto done; 4653 } 4654 uat++; 4655 } 4656 done: 4657 DPRINTF("terminal_type=0x%04x RET=%d DEF=%d\n", 4658 terminal_type, retval, default_type); 4659 return (retval); 4660 } 4661 4662 static uint16_t 4663 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot) 4664 { 4665 const struct uaudio_terminal_node *ptr; 4666 uint16_t terminal_type_input = 0; 4667 uint16_t terminal_type_output = 0; 4668 uint16_t temp; 4669 uint8_t match = 0; 4670 uint8_t i; 4671 4672 for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) { 4673 ptr = iot->root + i; 4674 temp = UGETW(ptr->u.it_v1->wTerminalType); 4675 4676 if (temp == 0) 4677 continue; 4678 else if (temp == UAT_STREAM) 4679 match |= 1; 4680 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00)) 4681 terminal_type_input = temp; 4682 } 4683 4684 for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) { 4685 ptr = iot->root + i; 4686 temp = UGETW(ptr->u.ot_v1->wTerminalType); 4687 4688 if (temp == 0) 4689 continue; 4690 else if (temp == UAT_STREAM) 4691 match |= 2; 4692 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00)) 4693 terminal_type_output = temp; 4694 } 4695 4696 DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n", 4697 match, terminal_type_input, terminal_type_output); 4698 4699 switch (match) { 4700 case 0: /* not connected to USB */ 4701 /* 4702 * Some devices have a hardware sidetone that will show up here 4703 * as connecting the microphone to the speaker. If we look at 4704 * the output first, then we are more likely to get a PCM type 4705 * and accidentally tie it to playback when we really should 4706 * treat it as a monitor control. 4707 */ 4708 if (terminal_type_input != 0 && terminal_type_output != 0) { 4709 return (SOUND_MIXER_MONITOR); 4710 } else if (terminal_type_output != 0) { 4711 return (uaudio_mixer_get_feature_by_tt( 4712 terminal_type_output, SOUND_MIXER_MONITOR)); 4713 } else { 4714 return (uaudio_mixer_get_feature_by_tt( 4715 terminal_type_input, SOUND_MIXER_MONITOR)); 4716 } 4717 case 3: /* connected to both USB input and USB output */ 4718 return (SOUND_MIXER_IMIX); 4719 case 2: /* connected to USB output */ 4720 return (uaudio_mixer_get_feature_by_tt( 4721 terminal_type_input, SOUND_MIXER_RECLEV)); 4722 case 1: /* connected to USB input */ 4723 return (uaudio_mixer_get_feature_by_tt( 4724 terminal_type_output, SOUND_MIXER_PCM)); 4725 default: 4726 return (SOUND_MIXER_NRDEVICES); 4727 } 4728 } 4729 4730 static uint16_t 4731 uaudio20_mixer_determine_class(const struct uaudio_terminal_node *iot) 4732 { 4733 const struct uaudio_terminal_node *ptr; 4734 uint16_t terminal_type_input = 0; 4735 uint16_t terminal_type_output = 0; 4736 uint16_t temp; 4737 uint8_t match = 0; 4738 uint8_t i; 4739 4740 for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) { 4741 ptr = iot->root + i; 4742 temp = UGETW(ptr->u.it_v2->wTerminalType); 4743 4744 if (temp == 0) 4745 continue; 4746 else if (temp == UAT_STREAM) 4747 match |= 1; 4748 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00)) 4749 terminal_type_input = temp; 4750 } 4751 4752 for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) { 4753 ptr = iot->root + i; 4754 temp = UGETW(ptr->u.ot_v2->wTerminalType); 4755 4756 if (temp == 0) 4757 continue; 4758 else if (temp == UAT_STREAM) 4759 match |= 2; 4760 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00)) 4761 terminal_type_output = temp; 4762 } 4763 4764 DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n", 4765 match, terminal_type_input, terminal_type_output); 4766 4767 switch (match) { 4768 case 0: /* not connected to USB */ 4769 /* 4770 * Some devices have a hardware sidetone that will show up here 4771 * as connecting the microphone to the speaker. If we look at 4772 * the output first, then we are more likely to get a PCM type 4773 * and accidentally tie it to playback when we really should 4774 * treat it as a monitor control. 4775 */ 4776 if (terminal_type_input != 0 && terminal_type_output != 0) { 4777 return (SOUND_MIXER_MONITOR); 4778 } else if (terminal_type_output != 0) { 4779 return (uaudio_mixer_get_feature_by_tt( 4780 terminal_type_output, SOUND_MIXER_MONITOR)); 4781 } else { 4782 return (uaudio_mixer_get_feature_by_tt( 4783 terminal_type_input, SOUND_MIXER_MONITOR)); 4784 } 4785 case 3: /* connected to both USB input and USB output */ 4786 return (SOUND_MIXER_IMIX); 4787 case 2: /* connected to USB output */ 4788 return (uaudio_mixer_get_feature_by_tt( 4789 terminal_type_input, SOUND_MIXER_RECLEV)); 4790 case 1: /* connected to USB input */ 4791 return (uaudio_mixer_get_feature_by_tt( 4792 terminal_type_output, SOUND_MIXER_PCM)); 4793 default: 4794 return (SOUND_MIXER_NRDEVICES); 4795 } 4796 } 4797 4798 static void 4799 uaudio_mixer_merge_outputs(struct uaudio_search_result *dst, 4800 const struct uaudio_search_result *src) 4801 { 4802 const uint8_t max = sizeof(src->bit_output) / sizeof(src->bit_output[0]); 4803 uint8_t x; 4804 4805 for (x = 0; x != max; x++) 4806 dst->bit_output[x] |= src->bit_output[x]; 4807 } 4808 4809 static void 4810 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root, 4811 const uint8_t *p_id, uint8_t n_id, 4812 struct uaudio_search_result *info) 4813 { 4814 struct uaudio_terminal_node *iot; 4815 uint8_t n; 4816 uint8_t i; 4817 4818 for (n = 0; n < n_id; n++) { 4819 i = p_id[n]; 4820 4821 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) { 4822 DPRINTF("avoided going into a circle at id=%d!\n", i); 4823 return; 4824 } 4825 4826 info->recurse_level++; 4827 4828 iot = (root + i); 4829 4830 if (iot->u.desc == NULL) 4831 continue; 4832 4833 switch (iot->u.desc->bDescriptorSubtype) { 4834 case UDESCSUB_AC_INPUT: 4835 uaudio_mixer_merge_outputs(&iot->usr, info); 4836 info->bit_input[i / 8] |= (1 << (i % 8)); 4837 break; 4838 4839 case UDESCSUB_AC_FEATURE: 4840 uaudio_mixer_merge_outputs(&iot->usr, info); 4841 uaudio_mixer_find_inputs_sub( 4842 root, &iot->u.fu_v1->bSourceId, 1, info); 4843 break; 4844 4845 case UDESCSUB_AC_OUTPUT: 4846 info->bit_output[i / 8] |= (1 << (i % 8)); 4847 uaudio_mixer_find_inputs_sub( 4848 root, &iot->u.ot_v1->bSourceId, 1, info); 4849 info->bit_output[i / 8] &= ~(1 << (i % 8)); 4850 break; 4851 4852 case UDESCSUB_AC_MIXER: 4853 uaudio_mixer_merge_outputs(&iot->usr, info); 4854 uaudio_mixer_find_inputs_sub( 4855 root, iot->u.mu_v1->baSourceId, 4856 iot->u.mu_v1->bNrInPins, info); 4857 break; 4858 4859 case UDESCSUB_AC_SELECTOR: 4860 uaudio_mixer_merge_outputs(&iot->usr, info); 4861 uaudio_mixer_find_inputs_sub( 4862 root, iot->u.su_v1->baSourceId, 4863 iot->u.su_v1->bNrInPins, info); 4864 break; 4865 4866 case UDESCSUB_AC_PROCESSING: 4867 uaudio_mixer_merge_outputs(&iot->usr, info); 4868 uaudio_mixer_find_inputs_sub( 4869 root, iot->u.pu_v1->baSourceId, 4870 iot->u.pu_v1->bNrInPins, info); 4871 break; 4872 4873 case UDESCSUB_AC_EXTENSION: 4874 uaudio_mixer_merge_outputs(&iot->usr, info); 4875 uaudio_mixer_find_inputs_sub( 4876 root, iot->u.eu_v1->baSourceId, 4877 iot->u.eu_v1->bNrInPins, info); 4878 break; 4879 4880 default: 4881 break; 4882 } 4883 } 4884 } 4885 4886 static void 4887 uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *root, 4888 const uint8_t *p_id, uint8_t n_id, 4889 struct uaudio_search_result *info) 4890 { 4891 struct uaudio_terminal_node *iot; 4892 uint8_t n; 4893 uint8_t i; 4894 4895 for (n = 0; n < n_id; n++) { 4896 i = p_id[n]; 4897 4898 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) { 4899 DPRINTF("avoided going into a circle at id=%d!\n", i); 4900 return; 4901 } 4902 4903 info->recurse_level++; 4904 4905 iot = (root + i); 4906 4907 if (iot->u.desc == NULL) 4908 continue; 4909 4910 switch (iot->u.desc->bDescriptorSubtype) { 4911 case UDESCSUB_AC_INPUT: 4912 uaudio_mixer_merge_outputs(&iot->usr, info); 4913 info->bit_input[i / 8] |= (1 << (i % 8)); 4914 break; 4915 4916 case UDESCSUB_AC_OUTPUT: 4917 info->bit_output[i / 8] |= (1 << (i % 8)); 4918 uaudio20_mixer_find_inputs_sub( 4919 root, &iot->u.ot_v2->bSourceId, 1, info); 4920 info->bit_output[i / 8] &= ~(1 << (i % 8)); 4921 break; 4922 4923 case UDESCSUB_AC_MIXER: 4924 uaudio_mixer_merge_outputs(&iot->usr, info); 4925 uaudio20_mixer_find_inputs_sub( 4926 root, iot->u.mu_v2->baSourceId, 4927 iot->u.mu_v2->bNrInPins, info); 4928 break; 4929 4930 case UDESCSUB_AC_SELECTOR: 4931 uaudio_mixer_merge_outputs(&iot->usr, info); 4932 uaudio20_mixer_find_inputs_sub( 4933 root, iot->u.su_v2->baSourceId, 4934 iot->u.su_v2->bNrInPins, info); 4935 break; 4936 4937 case UDESCSUB_AC_SAMPLE_RT: 4938 uaudio_mixer_merge_outputs(&iot->usr, info); 4939 uaudio20_mixer_find_inputs_sub( 4940 root, &iot->u.ru_v2->bSourceId, 4941 1, info); 4942 break; 4943 4944 case UDESCSUB_AC_EFFECT: 4945 uaudio_mixer_merge_outputs(&iot->usr, info); 4946 uaudio20_mixer_find_inputs_sub( 4947 root, &iot->u.ef_v2->bSourceId, 4948 1, info); 4949 break; 4950 4951 case UDESCSUB_AC_FEATURE: 4952 uaudio_mixer_merge_outputs(&iot->usr, info); 4953 uaudio20_mixer_find_inputs_sub( 4954 root, &iot->u.fu_v2->bSourceId, 1, info); 4955 break; 4956 4957 case UDESCSUB_AC_PROCESSING_V2: 4958 uaudio_mixer_merge_outputs(&iot->usr, info); 4959 uaudio20_mixer_find_inputs_sub( 4960 root, iot->u.pu_v2->baSourceId, 4961 iot->u.pu_v2->bNrInPins, info); 4962 break; 4963 4964 case UDESCSUB_AC_EXTENSION_V2: 4965 uaudio_mixer_merge_outputs(&iot->usr, info); 4966 uaudio20_mixer_find_inputs_sub( 4967 root, iot->u.eu_v2->baSourceId, 4968 iot->u.eu_v2->bNrInPins, info); 4969 break; 4970 default: 4971 break; 4972 } 4973 } 4974 } 4975 4976 static void 4977 uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root, 4978 const uint8_t *p_id, uint8_t n_id, 4979 struct uaudio_search_result *info) 4980 { 4981 struct uaudio_terminal_node *iot; 4982 uint8_t n; 4983 uint8_t i; 4984 uint8_t is_last; 4985 uint8_t id; 4986 4987 top: 4988 for (n = 0; n < n_id; n++) { 4989 i = p_id[n]; 4990 4991 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) { 4992 DPRINTF("avoided going into a circle at id=%d!\n", i); 4993 return; 4994 } 4995 4996 info->recurse_level++; 4997 4998 iot = (root + i); 4999 5000 if (iot->u.desc == NULL) 5001 continue; 5002 5003 is_last = ((n + 1) == n_id); 5004 5005 switch (iot->u.desc->bDescriptorSubtype) { 5006 case UDESCSUB_AC_INPUT: 5007 info->is_input = 1; 5008 if (is_last) { 5009 p_id = &iot->u.it_v2->bCSourceId; 5010 n_id = 1; 5011 goto top; 5012 } 5013 uaudio20_mixer_find_clocks_sub(root, 5014 &iot->u.it_v2->bCSourceId, 1, info); 5015 break; 5016 5017 case UDESCSUB_AC_OUTPUT: 5018 info->is_input = 0; 5019 if (is_last) { 5020 p_id = &iot->u.ot_v2->bCSourceId; 5021 n_id = 1; 5022 goto top; 5023 } 5024 uaudio20_mixer_find_clocks_sub(root, 5025 &iot->u.ot_v2->bCSourceId, 1, info); 5026 break; 5027 5028 case UDESCSUB_AC_CLOCK_SEL: 5029 if (is_last) { 5030 p_id = iot->u.csel_v2->baCSourceId; 5031 n_id = iot->u.csel_v2->bNrInPins; 5032 goto top; 5033 } 5034 uaudio20_mixer_find_clocks_sub(root, 5035 iot->u.csel_v2->baCSourceId, 5036 iot->u.csel_v2->bNrInPins, info); 5037 break; 5038 5039 case UDESCSUB_AC_CLOCK_MUL: 5040 if (is_last) { 5041 p_id = &iot->u.cmul_v2->bCSourceId; 5042 n_id = 1; 5043 goto top; 5044 } 5045 uaudio20_mixer_find_clocks_sub(root, 5046 &iot->u.cmul_v2->bCSourceId, 5047 1, info); 5048 break; 5049 5050 case UDESCSUB_AC_CLOCK_SRC: 5051 5052 id = iot->u.csrc_v2->bClockId; 5053 5054 switch (info->is_input) { 5055 case 0: 5056 info->bit_output[id / 8] |= (1 << (id % 8)); 5057 break; 5058 case 1: 5059 info->bit_input[id / 8] |= (1 << (id % 8)); 5060 break; 5061 default: 5062 break; 5063 } 5064 break; 5065 5066 default: 5067 break; 5068 } 5069 } 5070 } 5071 5072 static void 5073 uaudio_mixer_fill_info(struct uaudio_softc *sc, 5074 struct usb_device *udev, void *desc) 5075 { 5076 const struct usb_audio_control_descriptor *acdp; 5077 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); 5078 const struct usb_descriptor *dp; 5079 const struct usb_audio_unit *au; 5080 struct uaudio_terminal_node *iot = NULL; 5081 uint16_t wTotalLen; 5082 uint8_t ID_max = 0; /* inclusive */ 5083 uint8_t i; 5084 5085 desc = usb_desc_foreach(cd, desc); 5086 5087 if (desc == NULL) { 5088 DPRINTF("no Audio Control header\n"); 5089 goto done; 5090 } 5091 acdp = desc; 5092 5093 if ((acdp->bLength < sizeof(*acdp)) || 5094 (acdp->bDescriptorType != UDESC_CS_INTERFACE) || 5095 (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) { 5096 DPRINTF("invalid Audio Control header\n"); 5097 goto done; 5098 } 5099 /* "wTotalLen" is allowed to be corrupt */ 5100 wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength; 5101 5102 /* get USB audio revision */ 5103 sc->sc_audio_rev = UGETW(acdp->bcdADC); 5104 5105 DPRINTFN(3, "found AC header, vers=%03x, len=%d\n", 5106 sc->sc_audio_rev, wTotalLen); 5107 5108 iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP, 5109 M_WAITOK | M_ZERO); 5110 5111 while ((desc = usb_desc_foreach(cd, desc))) { 5112 dp = desc; 5113 5114 if (dp->bLength > wTotalLen) { 5115 break; 5116 } else { 5117 wTotalLen -= dp->bLength; 5118 } 5119 5120 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) 5121 au = NULL; 5122 else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) 5123 au = uaudio20_mixer_verify_desc(dp, 0); 5124 else 5125 au = uaudio_mixer_verify_desc(dp, 0); 5126 5127 if (au) { 5128 iot[au->bUnitId].u.desc = (const void *)au; 5129 if (au->bUnitId > ID_max) 5130 ID_max = au->bUnitId; 5131 } 5132 } 5133 5134 DPRINTF("Maximum ID=%d\n", ID_max); 5135 5136 /* 5137 * determine sourcing inputs for 5138 * all nodes in the tree: 5139 */ 5140 i = ID_max; 5141 do { 5142 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) { 5143 /* FALLTHROUGH */ 5144 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) { 5145 uaudio20_mixer_find_inputs_sub(iot, 5146 &i, 1, &((iot + i)->usr)); 5147 5148 sc->sc_mixer_clocks.is_input = 255; 5149 sc->sc_mixer_clocks.recurse_level = 0; 5150 5151 uaudio20_mixer_find_clocks_sub(iot, 5152 &i, 1, &sc->sc_mixer_clocks); 5153 } else { 5154 uaudio_mixer_find_inputs_sub(iot, 5155 &i, 1, &((iot + i)->usr)); 5156 } 5157 } while (i--); 5158 5159 /* set "id_max" and "root" */ 5160 5161 i = ID_max; 5162 do { 5163 (iot + i)->usr.id_max = ID_max; 5164 (iot + i)->root = iot; 5165 } while (i--); 5166 5167 /* 5168 * Scan the config to create a linked list of "mixer" nodes: 5169 */ 5170 5171 i = ID_max; 5172 do { 5173 dp = iot[i].u.desc; 5174 5175 if (dp == NULL) 5176 continue; 5177 5178 DPRINTFN(11, "id=%d subtype=%d\n", 5179 i, dp->bDescriptorSubtype); 5180 5181 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) { 5182 continue; 5183 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) { 5184 switch (dp->bDescriptorSubtype) { 5185 case UDESCSUB_AC_HEADER: 5186 DPRINTF("unexpected AC header\n"); 5187 break; 5188 5189 case UDESCSUB_AC_INPUT: 5190 case UDESCSUB_AC_OUTPUT: 5191 case UDESCSUB_AC_PROCESSING_V2: 5192 case UDESCSUB_AC_EXTENSION_V2: 5193 case UDESCSUB_AC_EFFECT: 5194 case UDESCSUB_AC_CLOCK_SRC: 5195 case UDESCSUB_AC_CLOCK_SEL: 5196 case UDESCSUB_AC_CLOCK_MUL: 5197 case UDESCSUB_AC_SAMPLE_RT: 5198 break; 5199 5200 case UDESCSUB_AC_MIXER: 5201 uaudio20_mixer_add_mixer(sc, iot, i); 5202 break; 5203 5204 case UDESCSUB_AC_SELECTOR: 5205 uaudio20_mixer_add_selector(sc, iot, i); 5206 break; 5207 5208 case UDESCSUB_AC_FEATURE: 5209 uaudio20_mixer_add_feature(sc, iot, i); 5210 break; 5211 5212 default: 5213 DPRINTF("bad AC desc subtype=0x%02x\n", 5214 dp->bDescriptorSubtype); 5215 break; 5216 } 5217 continue; 5218 } 5219 5220 switch (dp->bDescriptorSubtype) { 5221 case UDESCSUB_AC_HEADER: 5222 DPRINTF("unexpected AC header\n"); 5223 break; 5224 5225 case UDESCSUB_AC_INPUT: 5226 case UDESCSUB_AC_OUTPUT: 5227 break; 5228 5229 case UDESCSUB_AC_MIXER: 5230 uaudio_mixer_add_mixer(sc, iot, i); 5231 break; 5232 5233 case UDESCSUB_AC_SELECTOR: 5234 uaudio_mixer_add_selector(sc, iot, i); 5235 break; 5236 5237 case UDESCSUB_AC_FEATURE: 5238 uaudio_mixer_add_feature(sc, iot, i); 5239 break; 5240 5241 case UDESCSUB_AC_PROCESSING: 5242 uaudio_mixer_add_processing(sc, iot, i); 5243 break; 5244 5245 case UDESCSUB_AC_EXTENSION: 5246 uaudio_mixer_add_extension(sc, iot, i); 5247 break; 5248 5249 default: 5250 DPRINTF("bad AC desc subtype=0x%02x\n", 5251 dp->bDescriptorSubtype); 5252 break; 5253 } 5254 5255 } while (i--); 5256 5257 done: 5258 free(iot, M_TEMP); 5259 } 5260 5261 static int 5262 uaudio_mixer_get(struct usb_device *udev, uint16_t audio_rev, 5263 uint8_t what, struct uaudio_mixer_node *mc) 5264 { 5265 struct usb_device_request req; 5266 int val; 5267 uint8_t data[2 + (2 * 3)]; 5268 usb_error_t err; 5269 5270 if (mc->wValue[0] == -1) 5271 return (0); 5272 5273 if (audio_rev >= UAUDIO_VERSION_30) 5274 return (0); 5275 else if (audio_rev >= UAUDIO_VERSION_20) { 5276 if (what == GET_CUR) { 5277 req.bRequest = UA20_CS_CUR; 5278 USETW(req.wLength, 2); 5279 } else { 5280 req.bRequest = UA20_CS_RANGE; 5281 USETW(req.wLength, 8); 5282 } 5283 } else { 5284 uint16_t len = MIX_SIZE(mc->type); 5285 5286 req.bRequest = what; 5287 USETW(req.wLength, len); 5288 } 5289 5290 req.bmRequestType = UT_READ_CLASS_INTERFACE; 5291 USETW(req.wValue, mc->wValue[0]); 5292 USETW(req.wIndex, mc->wIndex); 5293 5294 memset(data, 0, sizeof(data)); 5295 5296 err = usbd_do_request(udev, NULL, &req, data); 5297 if (err) { 5298 DPRINTF("err=%s\n", usbd_errstr(err)); 5299 return (0); 5300 } 5301 5302 if (audio_rev >= UAUDIO_VERSION_30) { 5303 val = 0; 5304 } else if (audio_rev >= UAUDIO_VERSION_20) { 5305 switch (what) { 5306 case GET_CUR: 5307 val = (data[0] | (data[1] << 8)); 5308 break; 5309 case GET_MIN: 5310 val = (data[2] | (data[3] << 8)); 5311 break; 5312 case GET_MAX: 5313 val = (data[4] | (data[5] << 8)); 5314 break; 5315 case GET_RES: 5316 val = (data[6] | (data[7] << 8)); 5317 break; 5318 default: 5319 val = 0; 5320 break; 5321 } 5322 } else { 5323 val = (data[0] | (data[1] << 8)); 5324 } 5325 5326 if (what == GET_CUR || what == GET_MIN || what == GET_MAX) 5327 val = uaudio_mixer_signext(mc->type, val); 5328 5329 DPRINTFN(3, "val=%d\n", val); 5330 5331 return (val); 5332 } 5333 5334 static void 5335 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error) 5336 { 5337 struct usb_device_request req; 5338 struct uaudio_softc *sc = usbd_xfer_softc(xfer); 5339 struct uaudio_mixer_node *mc = sc->sc_mixer_curr; 5340 struct usb_page_cache *pc; 5341 uint16_t len; 5342 uint8_t repeat = 1; 5343 uint8_t update; 5344 uint8_t chan; 5345 uint8_t buf[2]; 5346 5347 DPRINTF("\n"); 5348 5349 switch (USB_GET_STATE(xfer)) { 5350 case USB_ST_TRANSFERRED: 5351 tr_transferred: 5352 case USB_ST_SETUP: 5353 tr_setup: 5354 5355 if (mc == NULL) { 5356 mc = sc->sc_mixer_root; 5357 sc->sc_mixer_curr = mc; 5358 sc->sc_mixer_chan = 0; 5359 repeat = 0; 5360 } 5361 while (mc) { 5362 while (sc->sc_mixer_chan < mc->nchan) { 5363 chan = sc->sc_mixer_chan; 5364 5365 sc->sc_mixer_chan++; 5366 5367 update = ((mc->update[chan / 8] & (1 << (chan % 8))) && 5368 (mc->wValue[chan] != -1)); 5369 5370 mc->update[chan / 8] &= ~(1 << (chan % 8)); 5371 5372 if (update) { 5373 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 5374 USETW(req.wValue, mc->wValue[chan]); 5375 USETW(req.wIndex, mc->wIndex); 5376 5377 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) { 5378 return; 5379 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) { 5380 len = 2; 5381 req.bRequest = UA20_CS_CUR; 5382 USETW(req.wLength, len); 5383 } else { 5384 len = MIX_SIZE(mc->type); 5385 req.bRequest = SET_CUR; 5386 USETW(req.wLength, len); 5387 } 5388 5389 buf[0] = (mc->wData[chan] & 0xFF); 5390 buf[1] = (mc->wData[chan] >> 8) & 0xFF; 5391 5392 pc = usbd_xfer_get_frame(xfer, 0); 5393 usbd_copy_in(pc, 0, &req, sizeof(req)); 5394 pc = usbd_xfer_get_frame(xfer, 1); 5395 usbd_copy_in(pc, 0, buf, len); 5396 5397 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 5398 usbd_xfer_set_frame_len(xfer, 1, len); 5399 usbd_xfer_set_frames(xfer, len ? 2 : 1); 5400 usbd_transfer_submit(xfer); 5401 return; 5402 } 5403 } 5404 5405 mc = mc->next; 5406 sc->sc_mixer_curr = mc; 5407 sc->sc_mixer_chan = 0; 5408 } 5409 5410 if (repeat) { 5411 goto tr_setup; 5412 } 5413 break; 5414 5415 default: /* Error */ 5416 DPRINTF("error=%s\n", usbd_errstr(error)); 5417 if (error == USB_ERR_CANCELLED) { 5418 /* do nothing - we are detaching */ 5419 break; 5420 } 5421 goto tr_transferred; 5422 } 5423 } 5424 5425 static usb_error_t 5426 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed) 5427 { 5428 struct usb_device_request req; 5429 uint8_t data[3]; 5430 5431 DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed); 5432 5433 req.bmRequestType = UT_WRITE_CLASS_ENDPOINT; 5434 req.bRequest = SET_CUR; 5435 USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0); 5436 USETW(req.wIndex, endpt); 5437 USETW(req.wLength, 3); 5438 data[0] = speed; 5439 data[1] = speed >> 8; 5440 data[2] = speed >> 16; 5441 5442 return (usbd_do_request(udev, NULL, &req, data)); 5443 } 5444 5445 static usb_error_t 5446 uaudio20_set_speed(struct usb_device *udev, uint8_t iface_no, 5447 uint8_t clockid, uint32_t speed) 5448 { 5449 struct usb_device_request req; 5450 usb_error_t err; 5451 uDWord data; 5452 5453 DPRINTFN(6, "ifaceno=%d clockid=%d speed=%u\n", 5454 iface_no, clockid, speed); 5455 5456 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 5457 req.bRequest = UA20_CS_CUR; 5458 USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0); 5459 USETW2(req.wIndex, clockid, iface_no); 5460 USETW(req.wLength, sizeof(data)); 5461 USETDW(data, speed); 5462 5463 err = usbd_do_request(udev, NULL, &req, data); 5464 if (err != USB_ERR_NORMAL_COMPLETION) 5465 return (err); 5466 5467 /* 5468 * Read the rate back, because some devices only apply it once it has 5469 * been read, and produce no sound otherwise. 5470 */ 5471 req.bmRequestType = UT_READ_CLASS_INTERFACE; 5472 USETDW(data, 0); 5473 5474 err = usbd_do_request(udev, NULL, &req, data); 5475 if (err != USB_ERR_NORMAL_COMPLETION) { 5476 DPRINTF("could not read sample rate back: %s\n", 5477 usbd_errstr(err)); 5478 } else if (UGETDW(data) != speed) { 5479 DPRINTF("sample rate is %u Hz, expected %u Hz\n", 5480 UGETDW(data), speed); 5481 } 5482 5483 return (USB_ERR_NORMAL_COMPLETION); 5484 } 5485 5486 static int 5487 uaudio_mixer_signext(uint8_t type, int val) 5488 { 5489 if (!MIX_UNSIGNED(type)) { 5490 if (MIX_SIZE(type) == 2) { 5491 val = (int16_t)val; 5492 } else { 5493 val = (int8_t)val; 5494 } 5495 } 5496 return (val); 5497 } 5498 5499 static int 5500 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int val) 5501 { 5502 if (mc->type == MIX_ON_OFF) { 5503 val = (val != 0); 5504 } else if (mc->type != MIX_SELECTOR) { 5505 /* compute actual volume */ 5506 val = (val * mc->mul) / 100; 5507 5508 /* add lower offset */ 5509 val = val + mc->minval; 5510 } 5511 /* make sure we don't write a value out of range */ 5512 if (val > mc->maxval) 5513 val = mc->maxval; 5514 else if (val < mc->minval) 5515 val = mc->minval; 5516 5517 DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n", 5518 mc->type, val, mc->minval, mc->maxval, val); 5519 return (val); 5520 } 5521 5522 static void 5523 uaudio_mixer_ctl_set(struct uaudio_softc *sc, unsigned index, 5524 struct uaudio_mixer_node *mc, uint8_t chan, int val) 5525 { 5526 val = uaudio_mixer_bsd2value(mc, val); 5527 5528 mc->update[chan / 8] |= (1 << (chan % 8)); 5529 mc->wData[chan] = val; 5530 5531 /* start the transfer, if not already started */ 5532 5533 mtx_lock(&sc->sc_child[index].mixer_lock); 5534 usbd_transfer_start(sc->sc_mixer_xfer[0]); 5535 mtx_unlock(&sc->sc_child[index].mixer_lock); 5536 } 5537 5538 static void 5539 uaudio_mixer_init(struct uaudio_softc *sc, unsigned index) 5540 { 5541 struct uaudio_mixer_node *mc; 5542 int32_t i; 5543 5544 if (index != 0) 5545 return; 5546 for (mc = sc->sc_mixer_root; mc; mc = mc->next) { 5547 if (mc->ctl != SOUND_MIXER_NRDEVICES) { 5548 /* 5549 * Set device mask bits. See 5550 * /usr/include/machine/soundcard.h 5551 */ 5552 sc->sc_child[index].mix_info |= 1U << mc->ctl; 5553 } 5554 if ((mc->ctl == SOUND_MIXER_NRDEVICES) && 5555 (mc->type == MIX_SELECTOR)) { 5556 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 5557 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES) 5558 continue; 5559 sc->sc_child[index].recsrc_info |= 1U << mc->slctrtype[i - 1]; 5560 } 5561 } 5562 } 5563 } 5564 5565 int 5566 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m) 5567 { 5568 unsigned i = uaudio_get_child_index_by_dev(sc, mix_get_dev(m)); 5569 5570 DPRINTF("child=%u\n", i); 5571 5572 /* 5573 * Initialize the mutex with MTX_RECURSE so that functions like 5574 * uaudio_mixer_ctl_set() do not panic when they recurse on the lock, 5575 * as a result of a callback function (e.g., uaudio_hid_rx_callback()) 5576 * also having acquired it. 5577 */ 5578 mtx_init(&sc->sc_child[i].mixer_lock, "uaudio mixer lock", NULL, 5579 MTX_RECURSE); 5580 sc->sc_child[i].mixer_dev = m; 5581 5582 if (i == 0 && 5583 usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index, 5584 sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc, 5585 &sc->sc_child[i].mixer_lock)) { 5586 DPRINTFN(0, "could not allocate USB transfer for mixer!\n"); 5587 return (ENOMEM); 5588 } 5589 5590 if (sc->sc_play_chan[i].num_alt > 0 && 5591 (sc->sc_child[i].mix_info & SOUND_MASK_VOLUME) == 0) { 5592 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM); 5593 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE); 5594 } 5595 mix_setdevs(m, sc->sc_child[i].mix_info); 5596 mix_setrecdevs(m, sc->sc_child[i].recsrc_info); 5597 return (0); 5598 } 5599 5600 int 5601 uaudio_mixer_uninit_sub(struct uaudio_softc *sc, struct snd_mixer *m) 5602 { 5603 unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m)); 5604 5605 DPRINTF("child=%u\n", index); 5606 5607 if (index == 0) 5608 usbd_transfer_unsetup(sc->sc_mixer_xfer, 1); 5609 5610 mtx_destroy(&sc->sc_child[index].mixer_lock); 5611 5612 return (0); 5613 } 5614 5615 void 5616 uaudio_mixer_set(struct uaudio_softc *sc, struct snd_mixer *m, 5617 unsigned type, unsigned left, unsigned right) 5618 { 5619 unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m)); 5620 struct uaudio_mixer_node *mc; 5621 int chan; 5622 5623 if (index != 0) 5624 return; 5625 for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) { 5626 if (mc->ctl == type) { 5627 for (chan = 0; chan < mc->nchan; chan++) { 5628 uaudio_mixer_ctl_set(sc, index, mc, chan, 5629 chan == 0 ? left : right); 5630 } 5631 } 5632 } 5633 } 5634 5635 uint32_t 5636 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, struct snd_mixer *m, uint32_t src) 5637 { 5638 unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m)); 5639 struct uaudio_mixer_node *mc; 5640 uint32_t mask; 5641 uint32_t temp; 5642 int32_t i; 5643 5644 if (index != 0) 5645 return (0); 5646 for (mc = sc->sc_mixer_root; mc; mc = mc->next) { 5647 if ((mc->ctl == SOUND_MIXER_NRDEVICES) && 5648 (mc->type == MIX_SELECTOR)) { 5649 /* compute selector mask */ 5650 5651 mask = 0; 5652 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) 5653 mask |= 1U << mc->slctrtype[i - 1]; 5654 5655 temp = mask & src; 5656 if (temp == 0) 5657 continue; 5658 5659 /* find the first set bit */ 5660 temp = (-temp) & temp; 5661 5662 /* update "src" */ 5663 src &= ~mask; 5664 src |= temp; 5665 5666 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 5667 if (temp != (1U << mc->slctrtype[i - 1])) 5668 continue; 5669 uaudio_mixer_ctl_set(sc, index, mc, 0, i); 5670 break; 5671 } 5672 } 5673 } 5674 return (src); 5675 } 5676 5677 /*========================================================================* 5678 * MIDI support routines 5679 *========================================================================*/ 5680 5681 static void 5682 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 5683 { 5684 struct umidi_chan *chan = usbd_xfer_softc(xfer); 5685 struct umidi_sub_chan *sub; 5686 struct usb_page_cache *pc; 5687 uint8_t buf[4]; 5688 uint8_t cmd_len; 5689 uint8_t cn; 5690 uint16_t pos; 5691 int actlen; 5692 5693 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 5694 5695 switch (USB_GET_STATE(xfer)) { 5696 case USB_ST_TRANSFERRED: 5697 5698 DPRINTF("actlen=%d bytes\n", actlen); 5699 5700 pos = 0; 5701 pc = usbd_xfer_get_frame(xfer, 0); 5702 5703 while (actlen >= 4) { 5704 /* copy out the MIDI data */ 5705 usbd_copy_out(pc, pos, buf, 4); 5706 /* command length */ 5707 cmd_len = umidi_cmd_to_len[buf[0] & 0xF]; 5708 /* cable number */ 5709 cn = buf[0] >> 4; 5710 /* 5711 * Lookup sub-channel. The index is range 5712 * checked below. 5713 */ 5714 sub = &chan->sub[cn]; 5715 5716 if ((cmd_len != 0) && (cn < chan->max_emb_jack) && 5717 (sub->read_open != 0)) { 5718 /* Send data to the application */ 5719 usb_fifo_put_data_linear( 5720 sub->fifo.fp[USB_FIFO_RX], 5721 buf + 1, cmd_len, 1); 5722 } 5723 actlen -= 4; 5724 pos += 4; 5725 } 5726 5727 case USB_ST_SETUP: 5728 DPRINTF("start\n"); 5729 tr_setup: 5730 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 5731 usbd_transfer_submit(xfer); 5732 break; 5733 5734 default: 5735 DPRINTF("error=%s\n", usbd_errstr(error)); 5736 5737 if (error != USB_ERR_CANCELLED) { 5738 /* try to clear stall first */ 5739 usbd_xfer_set_stall(xfer); 5740 goto tr_setup; 5741 } 5742 break; 5743 } 5744 } 5745 5746 /* 5747 * The following statemachine, that converts MIDI commands to 5748 * USB MIDI packets, derives from Linux's usbmidi.c, which 5749 * was written by "Clemens Ladisch": 5750 * 5751 * Returns: 5752 * 0: No command 5753 * Else: Command is complete 5754 */ 5755 static uint8_t 5756 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b) 5757 { 5758 uint8_t p0 = (cn << 4); 5759 5760 if (b >= 0xf8) { 5761 sub->temp_0[0] = p0 | 0x0f; 5762 sub->temp_0[1] = b; 5763 sub->temp_0[2] = 0; 5764 sub->temp_0[3] = 0; 5765 sub->temp_cmd = sub->temp_0; 5766 return (1); 5767 5768 } else if (b >= 0xf0) { 5769 switch (b) { 5770 case 0xf0: /* system exclusive begin */ 5771 sub->temp_1[1] = b; 5772 sub->state = UMIDI_ST_SYSEX_1; 5773 break; 5774 case 0xf1: /* MIDI time code */ 5775 case 0xf3: /* song select */ 5776 sub->temp_1[1] = b; 5777 sub->state = UMIDI_ST_1PARAM; 5778 break; 5779 case 0xf2: /* song position pointer */ 5780 sub->temp_1[1] = b; 5781 sub->state = UMIDI_ST_2PARAM_1; 5782 break; 5783 case 0xf4: /* unknown */ 5784 case 0xf5: /* unknown */ 5785 sub->state = UMIDI_ST_UNKNOWN; 5786 break; 5787 case 0xf6: /* tune request */ 5788 sub->temp_1[0] = p0 | 0x05; 5789 sub->temp_1[1] = 0xf6; 5790 sub->temp_1[2] = 0; 5791 sub->temp_1[3] = 0; 5792 sub->temp_cmd = sub->temp_1; 5793 sub->state = UMIDI_ST_UNKNOWN; 5794 return (1); 5795 5796 case 0xf7: /* system exclusive end */ 5797 switch (sub->state) { 5798 case UMIDI_ST_SYSEX_0: 5799 sub->temp_1[0] = p0 | 0x05; 5800 sub->temp_1[1] = 0xf7; 5801 sub->temp_1[2] = 0; 5802 sub->temp_1[3] = 0; 5803 sub->temp_cmd = sub->temp_1; 5804 sub->state = UMIDI_ST_UNKNOWN; 5805 return (1); 5806 case UMIDI_ST_SYSEX_1: 5807 sub->temp_1[0] = p0 | 0x06; 5808 sub->temp_1[2] = 0xf7; 5809 sub->temp_1[3] = 0; 5810 sub->temp_cmd = sub->temp_1; 5811 sub->state = UMIDI_ST_UNKNOWN; 5812 return (1); 5813 case UMIDI_ST_SYSEX_2: 5814 sub->temp_1[0] = p0 | 0x07; 5815 sub->temp_1[3] = 0xf7; 5816 sub->temp_cmd = sub->temp_1; 5817 sub->state = UMIDI_ST_UNKNOWN; 5818 return (1); 5819 } 5820 sub->state = UMIDI_ST_UNKNOWN; 5821 break; 5822 } 5823 } else if (b >= 0x80) { 5824 sub->temp_1[1] = b; 5825 if ((b >= 0xc0) && (b <= 0xdf)) { 5826 sub->state = UMIDI_ST_1PARAM; 5827 } else { 5828 sub->state = UMIDI_ST_2PARAM_1; 5829 } 5830 } else { /* b < 0x80 */ 5831 switch (sub->state) { 5832 case UMIDI_ST_1PARAM: 5833 if (sub->temp_1[1] < 0xf0) { 5834 p0 |= sub->temp_1[1] >> 4; 5835 } else { 5836 p0 |= 0x02; 5837 sub->state = UMIDI_ST_UNKNOWN; 5838 } 5839 sub->temp_1[0] = p0; 5840 sub->temp_1[2] = b; 5841 sub->temp_1[3] = 0; 5842 sub->temp_cmd = sub->temp_1; 5843 return (1); 5844 case UMIDI_ST_2PARAM_1: 5845 sub->temp_1[2] = b; 5846 sub->state = UMIDI_ST_2PARAM_2; 5847 break; 5848 case UMIDI_ST_2PARAM_2: 5849 if (sub->temp_1[1] < 0xf0) { 5850 p0 |= sub->temp_1[1] >> 4; 5851 sub->state = UMIDI_ST_2PARAM_1; 5852 } else { 5853 p0 |= 0x03; 5854 sub->state = UMIDI_ST_UNKNOWN; 5855 } 5856 sub->temp_1[0] = p0; 5857 sub->temp_1[3] = b; 5858 sub->temp_cmd = sub->temp_1; 5859 return (1); 5860 case UMIDI_ST_SYSEX_0: 5861 sub->temp_1[1] = b; 5862 sub->state = UMIDI_ST_SYSEX_1; 5863 break; 5864 case UMIDI_ST_SYSEX_1: 5865 sub->temp_1[2] = b; 5866 sub->state = UMIDI_ST_SYSEX_2; 5867 break; 5868 case UMIDI_ST_SYSEX_2: 5869 sub->temp_1[0] = p0 | 0x04; 5870 sub->temp_1[3] = b; 5871 sub->temp_cmd = sub->temp_1; 5872 sub->state = UMIDI_ST_SYSEX_0; 5873 return (1); 5874 default: 5875 break; 5876 } 5877 } 5878 return (0); 5879 } 5880 5881 static void 5882 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 5883 { 5884 struct umidi_chan *chan = usbd_xfer_softc(xfer); 5885 struct umidi_sub_chan *sub; 5886 struct usb_page_cache *pc; 5887 uint32_t actlen; 5888 uint16_t nframes; 5889 uint8_t buf; 5890 uint8_t start_cable; 5891 uint8_t tr_any; 5892 int len; 5893 5894 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 5895 5896 /* 5897 * NOTE: Some MIDI devices only accept 4 bytes of data per 5898 * short terminated USB transfer. 5899 */ 5900 switch (USB_GET_STATE(xfer)) { 5901 case USB_ST_TRANSFERRED: 5902 DPRINTF("actlen=%d bytes\n", len); 5903 5904 case USB_ST_SETUP: 5905 tr_setup: 5906 DPRINTF("start\n"); 5907 5908 nframes = 0; /* reset */ 5909 start_cable = chan->curr_cable; 5910 tr_any = 0; 5911 pc = usbd_xfer_get_frame(xfer, 0); 5912 5913 while (1) { 5914 /* round robin de-queueing */ 5915 5916 sub = &chan->sub[chan->curr_cable]; 5917 5918 if (sub->write_open) { 5919 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX], 5920 &buf, 1, &actlen, 0); 5921 } else { 5922 actlen = 0; 5923 } 5924 5925 if (actlen) { 5926 tr_any = 1; 5927 5928 DPRINTF("byte=0x%02x from FIFO %u\n", buf, 5929 (unsigned int)chan->curr_cable); 5930 5931 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) { 5932 DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n", 5933 sub->temp_cmd[0], sub->temp_cmd[1], 5934 sub->temp_cmd[2], sub->temp_cmd[3]); 5935 5936 usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4); 5937 5938 nframes++; 5939 5940 if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0)) 5941 break; 5942 } else { 5943 continue; 5944 } 5945 } 5946 5947 chan->curr_cable %= chan->max_emb_jack; 5948 5949 if (chan->curr_cable == start_cable) { 5950 if (tr_any == 0) 5951 break; 5952 tr_any = 0; 5953 } 5954 } 5955 5956 if (nframes != 0) { 5957 DPRINTF("Transferring %d frames\n", (int)nframes); 5958 usbd_xfer_set_frame_len(xfer, 0, 4 * nframes); 5959 usbd_transfer_submit(xfer); 5960 } 5961 break; 5962 5963 default: /* Error */ 5964 5965 DPRINTF("error=%s\n", usbd_errstr(error)); 5966 5967 if (error != USB_ERR_CANCELLED) { 5968 /* try to clear stall first */ 5969 usbd_xfer_set_stall(xfer); 5970 goto tr_setup; 5971 } 5972 break; 5973 } 5974 } 5975 5976 static struct umidi_sub_chan * 5977 umidi_sub_by_fifo(struct usb_fifo *fifo) 5978 { 5979 struct umidi_chan *chan = usb_fifo_softc(fifo); 5980 struct umidi_sub_chan *sub; 5981 uint32_t n; 5982 5983 for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) { 5984 sub = &chan->sub[n]; 5985 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) || 5986 (sub->fifo.fp[USB_FIFO_TX] == fifo)) { 5987 return (sub); 5988 } 5989 } 5990 5991 panic("%s:%d cannot find usb_fifo!\n", 5992 __FILE__, __LINE__); 5993 5994 return (NULL); 5995 } 5996 5997 static void 5998 umidi_start_read(struct usb_fifo *fifo) 5999 { 6000 struct umidi_chan *chan = usb_fifo_softc(fifo); 6001 6002 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]); 6003 } 6004 6005 static void 6006 umidi_stop_read(struct usb_fifo *fifo) 6007 { 6008 struct umidi_chan *chan = usb_fifo_softc(fifo); 6009 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 6010 6011 DPRINTF("\n"); 6012 6013 sub->read_open = 0; 6014 6015 if (--(chan->read_open_refcount) == 0) { 6016 /* 6017 * XXX don't stop the read transfer here, hence that causes 6018 * problems with some MIDI adapters 6019 */ 6020 DPRINTF("(stopping read transfer)\n"); 6021 } 6022 } 6023 6024 static void 6025 umidi_start_write(struct usb_fifo *fifo) 6026 { 6027 struct umidi_chan *chan = usb_fifo_softc(fifo); 6028 6029 if (chan->xfer[UMIDI_TX_TRANSFER] == NULL) { 6030 uint8_t buf[1]; 6031 int actlen; 6032 do { 6033 /* dump data */ 6034 usb_fifo_get_data_linear(fifo, buf, 1, &actlen, 0); 6035 } while (actlen > 0); 6036 } else { 6037 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]); 6038 } 6039 } 6040 6041 static void 6042 umidi_stop_write(struct usb_fifo *fifo) 6043 { 6044 struct umidi_chan *chan = usb_fifo_softc(fifo); 6045 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 6046 6047 DPRINTF("\n"); 6048 6049 sub->write_open = 0; 6050 6051 if (--(chan->write_open_refcount) == 0) { 6052 DPRINTF("(stopping write transfer)\n"); 6053 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]); 6054 } 6055 } 6056 6057 static int 6058 umidi_open(struct usb_fifo *fifo, int fflags) 6059 { 6060 struct umidi_chan *chan = usb_fifo_softc(fifo); 6061 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 6062 6063 if (fflags & FREAD) { 6064 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) { 6065 return (ENOMEM); 6066 } 6067 mtx_lock(&chan->mtx); 6068 chan->read_open_refcount++; 6069 sub->read_open = 1; 6070 mtx_unlock(&chan->mtx); 6071 } 6072 if (fflags & FWRITE) { 6073 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) { 6074 return (ENOMEM); 6075 } 6076 /* clear stall first */ 6077 mtx_lock(&chan->mtx); 6078 chan->write_open_refcount++; 6079 sub->write_open = 1; 6080 6081 /* reset */ 6082 sub->state = UMIDI_ST_UNKNOWN; 6083 mtx_unlock(&chan->mtx); 6084 } 6085 return (0); /* success */ 6086 } 6087 6088 static void 6089 umidi_close(struct usb_fifo *fifo, int fflags) 6090 { 6091 if (fflags & FREAD) { 6092 usb_fifo_free_buffer(fifo); 6093 } 6094 if (fflags & FWRITE) { 6095 usb_fifo_free_buffer(fifo); 6096 } 6097 } 6098 6099 static int 6100 umidi_ioctl(struct usb_fifo *fifo, unsigned long cmd, void *data, 6101 int fflags) 6102 { 6103 return (ENODEV); 6104 } 6105 6106 static void 6107 umidi_init(device_t dev) 6108 { 6109 struct uaudio_softc *sc = device_get_softc(dev); 6110 struct umidi_chan *chan = &sc->sc_midi_chan; 6111 6112 mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE); 6113 } 6114 6115 static struct usb_fifo_methods umidi_fifo_methods = { 6116 .f_start_read = &umidi_start_read, 6117 .f_start_write = &umidi_start_write, 6118 .f_stop_read = &umidi_stop_read, 6119 .f_stop_write = &umidi_stop_write, 6120 .f_open = &umidi_open, 6121 .f_close = &umidi_close, 6122 .f_ioctl = &umidi_ioctl, 6123 .basename[0] = "umidi", 6124 }; 6125 6126 static int 6127 umidi_attach(device_t dev) 6128 { 6129 struct uaudio_softc *sc = device_get_softc(dev); 6130 struct usb_attach_arg *uaa = device_get_ivars(dev); 6131 struct umidi_chan *chan = &sc->sc_midi_chan; 6132 struct umidi_sub_chan *sub; 6133 int unit = device_get_unit(dev); 6134 int error; 6135 uint32_t n; 6136 6137 if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI)) 6138 chan->single_command = 1; 6139 6140 error = usbd_set_alt_interface_index(sc->sc_udev, 6141 chan->iface_index, chan->iface_alt_index); 6142 if (error) { 6143 DPRINTF("setting of alternate index failed: %s\n", 6144 usbd_errstr(error)); 6145 goto detach; 6146 } 6147 usbd_set_parent_iface(sc->sc_udev, chan->iface_index, 6148 sc->sc_mixer_iface_index); 6149 6150 error = usbd_transfer_setup(uaa->device, &chan->iface_index, 6151 chan->xfer, umidi_config, UMIDI_N_TRANSFER, 6152 chan, &chan->mtx); 6153 if (error) { 6154 DPRINTF("error=%s\n", usbd_errstr(error)); 6155 goto detach; 6156 } 6157 if (chan->xfer[UMIDI_TX_TRANSFER] == NULL && 6158 chan->xfer[UMIDI_RX_TRANSFER] == NULL) { 6159 DPRINTF("no BULK or INTERRUPT MIDI endpoint(s) found\n"); 6160 goto detach; 6161 } 6162 6163 /* 6164 * Some USB MIDI device makers couldn't resist using 6165 * wMaxPacketSize = 4 for RX and TX BULK endpoints, although 6166 * that size is an unsupported value for FULL speed BULK 6167 * endpoints. The same applies to some HIGH speed MIDI devices 6168 * which are using a wMaxPacketSize different from 512 bytes. 6169 * 6170 * Refer to section 5.8.3 in USB 2.0 PDF: Cite: "All Host 6171 * Controllers are required to have support for 8-, 16-, 32-, 6172 * and 64-byte maximum packet sizes for full-speed bulk 6173 * endpoints and 512 bytes for high-speed bulk endpoints." 6174 */ 6175 if (chan->xfer[UMIDI_TX_TRANSFER] != NULL && 6176 usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER])) 6177 chan->single_command = 1; 6178 6179 if (chan->single_command != 0) 6180 device_printf(dev, "Single command MIDI quirk enabled\n"); 6181 6182 if ((chan->max_emb_jack == 0) || 6183 (chan->max_emb_jack > UMIDI_EMB_JACK_MAX)) { 6184 chan->max_emb_jack = UMIDI_EMB_JACK_MAX; 6185 } 6186 6187 for (n = 0; n < chan->max_emb_jack; n++) { 6188 sub = &chan->sub[n]; 6189 6190 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx, 6191 &umidi_fifo_methods, &sub->fifo, unit, n, 6192 chan->iface_index, 6193 UID_ROOT, GID_AUDIO, 0660); 6194 if (error) { 6195 goto detach; 6196 } 6197 } 6198 6199 mtx_lock(&chan->mtx); 6200 6201 /* 6202 * NOTE: At least one device will not work properly unless the 6203 * BULK IN pipe is open all the time. This might have to do 6204 * about that the internal queues of the device overflow if we 6205 * don't read them regularly. 6206 */ 6207 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]); 6208 6209 mtx_unlock(&chan->mtx); 6210 6211 return (0); /* success */ 6212 6213 detach: 6214 return (ENXIO); /* failure */ 6215 } 6216 6217 static int 6218 umidi_detach(device_t dev) 6219 { 6220 struct uaudio_softc *sc = device_get_softc(dev); 6221 struct umidi_chan *chan = &sc->sc_midi_chan; 6222 uint32_t n; 6223 6224 for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) 6225 usb_fifo_detach(&chan->sub[n].fifo); 6226 6227 mtx_lock(&chan->mtx); 6228 6229 usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]); 6230 6231 mtx_unlock(&chan->mtx); 6232 6233 usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER); 6234 6235 mtx_destroy(&chan->mtx); 6236 6237 return (0); 6238 } 6239 6240 static void 6241 uaudio_hid_rx_callback(struct usb_xfer *xfer, usb_error_t error) 6242 { 6243 struct uaudio_softc *sc = usbd_xfer_softc(xfer); 6244 const uint8_t *buffer = usbd_xfer_get_frame_buffer(xfer, 0); 6245 struct snd_mixer *m; 6246 uint8_t id; 6247 int actlen; 6248 bool mute, volume_up, volume_down; 6249 6250 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 6251 6252 m = NULL; 6253 mute = volume_up = volume_down = false; 6254 6255 switch (USB_GET_STATE(xfer)) { 6256 case USB_ST_TRANSFERRED: 6257 DPRINTF("actlen=%d\n", actlen); 6258 6259 if (actlen != 0 && 6260 (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) { 6261 id = *buffer; 6262 buffer++; 6263 actlen--; 6264 } else { 6265 id = 0; 6266 } 6267 6268 m = sc->sc_child[0].mixer_dev; 6269 6270 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) && 6271 (sc->sc_hid.mute_id == id) && 6272 hid_get_data(buffer, actlen, 6273 &sc->sc_hid.mute_loc)) { 6274 DPRINTF("Mute toggle\n"); 6275 6276 mute = true; 6277 } 6278 6279 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) && 6280 (sc->sc_hid.volume_up_id == id) && 6281 hid_get_data(buffer, actlen, 6282 &sc->sc_hid.volume_up_loc)) { 6283 DPRINTF("Volume Up\n"); 6284 6285 volume_up = true; 6286 } 6287 6288 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) && 6289 (sc->sc_hid.volume_down_id == id) && 6290 hid_get_data(buffer, actlen, 6291 &sc->sc_hid.volume_down_loc)) { 6292 DPRINTF("Volume Down\n"); 6293 6294 volume_down = true; 6295 } 6296 6297 case USB_ST_SETUP: 6298 tr_setup: 6299 /* check if we can put more data into the FIFO */ 6300 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 6301 usbd_transfer_submit(xfer); 6302 break; 6303 6304 default: /* Error */ 6305 6306 DPRINTF("error=%s\n", usbd_errstr(error)); 6307 6308 if (error != USB_ERR_CANCELLED) { 6309 /* try to clear stall first */ 6310 usbd_xfer_set_stall(xfer); 6311 goto tr_setup; 6312 } 6313 break; 6314 } 6315 6316 if (!mute && !volume_up && !volume_down) 6317 return; 6318 6319 /* 6320 * The mixer_hwvol_*() functions take the mixer lock, which is the PCM 6321 * lock, and end up in uaudio_mixer_ctl_set(), which takes the 6322 * mixer_lock this callback is entered with. Acquiring the two in that 6323 * order here would reverse the order taken by the mixer ioctl path 6324 * (PCM lock first, then mixer_lock), so drop mixer_lock for the 6325 * duration. The USB stack explicitly allows a callback to drop its 6326 * transfer mutex, and usbd_transfer_drain() accounts for it. 6327 */ 6328 mtx_unlock(&sc->sc_child[0].mixer_lock); 6329 if (mute) 6330 mixer_hwvol_mute(m->dev); 6331 if (volume_up) 6332 mixer_hwvol_step(m->dev, 1, 1); 6333 if (volume_down) 6334 mixer_hwvol_step(m->dev, -1, -1); 6335 mtx_lock(&sc->sc_child[0].mixer_lock); 6336 } 6337 6338 static int 6339 uaudio_hid_attach(struct uaudio_softc *sc, 6340 struct usb_attach_arg *uaa) 6341 { 6342 void *d_ptr; 6343 uint32_t flags; 6344 uint16_t d_len; 6345 uint8_t id; 6346 int error; 6347 6348 if (!(sc->sc_hid.flags & UAUDIO_HID_VALID)) 6349 return (-1); 6350 6351 /* Get HID descriptor */ 6352 error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr, 6353 &d_len, M_TEMP, sc->sc_hid.iface_index); 6354 6355 if (error) { 6356 DPRINTF("error reading report description\n"); 6357 return (-1); 6358 } 6359 6360 /* check if there is an ID byte */ 6361 hid_report_size_max(d_ptr, d_len, hid_input, &id); 6362 6363 if (id != 0) 6364 sc->sc_hid.flags |= UAUDIO_HID_HAS_ID; 6365 6366 if (hid_locate(d_ptr, d_len, 6367 HID_USAGE2(HUP_CONSUMER, 0xE9 /* Volume Increment */), 6368 hid_input, 0, &sc->sc_hid.volume_up_loc, &flags, 6369 &sc->sc_hid.volume_up_id)) { 6370 if (flags & HIO_VARIABLE) 6371 sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP; 6372 DPRINTFN(1, "Found Volume Up key\n"); 6373 } 6374 6375 if (hid_locate(d_ptr, d_len, 6376 HID_USAGE2(HUP_CONSUMER, 0xEA /* Volume Decrement */), 6377 hid_input, 0, &sc->sc_hid.volume_down_loc, &flags, 6378 &sc->sc_hid.volume_down_id)) { 6379 if (flags & HIO_VARIABLE) 6380 sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN; 6381 DPRINTFN(1, "Found Volume Down key\n"); 6382 } 6383 6384 if (hid_locate(d_ptr, d_len, 6385 HID_USAGE2(HUP_CONSUMER, 0xE2 /* Mute */), 6386 hid_input, 0, &sc->sc_hid.mute_loc, &flags, 6387 &sc->sc_hid.mute_id)) { 6388 if (flags & HIO_VARIABLE) 6389 sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE; 6390 DPRINTFN(1, "Found Mute key\n"); 6391 } 6392 6393 free(d_ptr, M_TEMP); 6394 6395 if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP | 6396 UAUDIO_HID_HAS_VOLUME_DOWN | 6397 UAUDIO_HID_HAS_MUTE))) { 6398 DPRINTFN(1, "Did not find any volume related keys\n"); 6399 return (-1); 6400 } 6401 6402 /* prevent the uhid driver from attaching */ 6403 usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index, 6404 sc->sc_mixer_iface_index); 6405 6406 /* allocate USB transfers */ 6407 error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index, 6408 sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER, 6409 sc, &sc->sc_child[0].mixer_lock); 6410 if (error) { 6411 DPRINTF("error=%s\n", usbd_errstr(error)); 6412 return (-1); 6413 } 6414 return (0); 6415 } 6416 6417 static void 6418 uaudio_hid_detach(struct uaudio_softc *sc) 6419 { 6420 usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER); 6421 } 6422 6423 DRIVER_MODULE_ORDERED(snd_uaudio, uhub, uaudio_driver, NULL, NULL, SI_ORDER_ANY); 6424 MODULE_DEPEND(snd_uaudio, usb, 1, 1, 1); 6425 MODULE_DEPEND(snd_uaudio, sound, 1, 1, 1); 6426 MODULE_DEPEND(snd_uaudio, hid, 1, 1, 1); 6427 MODULE_VERSION(snd_uaudio, 1); 6428 USB_PNP_HOST_INFO(uaudio_devs); 6429 USB_PNP_HOST_INFO(uaudio_vendor_audio); 6430 USB_PNP_HOST_INFO(uaudio_vendor_midi); 6431