sys/dev/sound/usb/uaudio.c

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