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