sys/dev/sound/usb/uaudio.c

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