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