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