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