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