sys/bus/u4b/audio/uaudio.c

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