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