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