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