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