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