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