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