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