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