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