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