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