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         uint8_t data[255];
1528         uint16_t actlen;
1529         uint16_t rates;
1530         uint16_t x;
1531
1532         DPRINTFN(6, "ifaceno=%d clockid=%d rate=%u\n",
1533             iface_no, clockid, rate);
1534
1535         req.bmRequestType = UT_READ_CLASS_INTERFACE;
1536         req.bRequest = UA20_CS_RANGE;
1537         USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
1538         USETW2(req.wIndex, clockid, iface_no);
1539         USETW(req.wLength, 255);
1540
1541         error = usbd_do_request_flags(udev, NULL, &req, data,
1542             USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT);
1543
1544         if (error != 0 || actlen < 2)
1545                 return (USB_ERR_INVAL);
1546
1547         rates = data[0] | (data[1] << 8);
1548         actlen = (actlen - 2) / 12;
1549
1550         if (rates > actlen) {
1551                 DPRINTF("Too many rates\n");
1552                 rates = actlen;
1553         }
1554
1555         for (x = 0; x != rates; x++) {
1556                 uint32_t min = UGETDW(data + 2 + (12 * x));
1557                 uint32_t max = UGETDW(data + 6 + (12 * x));
1558                 uint32_t res = UGETDW(data + 10 + (12 * x));
1559
1560                 if (res == 0) {
1561                         DPRINTF("Zero residue\n");
1562                         res = 1;
1563                 }
1564
1565                 if (min > max) {
1566                         DPRINTF("Swapped max and min\n");
1567                         uint32_t temp;
1568                         temp = min;
1569                         min = max;
1570                         max = temp;
1571                 }
1572
1573                 if (rate >= min && rate <= max &&
1574                     (((rate - min) % res) == 0)) {
1575                         return (0);
1576                 }
1577         }
1578         return (USB_ERR_INVAL);
1579 }
1580
1581 static void
1582 uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev,
1583     uint32_t rate, uint8_t channels, uint8_t bit_resolution)
1584 {
1585         struct usb_descriptor *desc = NULL;
1586         union uaudio_asid asid = { NULL };
1587         union uaudio_asf1d asf1d = { NULL };
1588         union uaudio_sed sed = { NULL };
1589         struct usb_midi_streaming_endpoint_descriptor *msid = NULL;
1590         usb_endpoint_descriptor_audio_t *ed1 = NULL;
1591         const struct usb_audio_control_descriptor *acdp = NULL;
1592         struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
1593         struct usb_interface_descriptor *id;
1594         const struct uaudio_format *p_fmt = NULL;
1595         struct uaudio_chan *chan;
1596         struct uaudio_chan_alt *chan_alt;
1597         uint32_t format;
1598         uint16_t curidx = 0xFFFF;
1599         uint16_t lastidx = 0xFFFF;
1600         uint16_t alt_index = 0;
1601         uint16_t audio_rev = 0;
1602         uint16_t x;
1603         uint8_t ep_dir;
1604         uint8_t bChannels;
1605         uint8_t bBitResolution;
1606         uint8_t audio_if = 0;
1607         uint8_t midi_if = 0;
1608         uint8_t uma_if_class;
1609
1610         while ((desc = usb_desc_foreach(cd, desc))) {
1611
1612                 if ((desc->bDescriptorType == UDESC_INTERFACE) &&
1613                     (desc->bLength >= sizeof(*id))) {
1614
1615                         id = (void *)desc;
1616
1617                         if (id->bInterfaceNumber != lastidx) {
1618                                 lastidx = id->bInterfaceNumber;
1619                                 curidx++;
1620                                 alt_index = 0;
1621
1622                         } else {
1623                                 alt_index++;
1624                         }
1625
1626                         if ((!(sc->sc_hid.flags & UAUDIO_HID_VALID)) &&
1627                             (id->bInterfaceClass == UICLASS_HID) &&
1628                             (id->bInterfaceSubClass == 0) &&
1629                             (id->bInterfaceProtocol == 0) &&
1630                             (alt_index == 0) &&
1631                             usbd_get_iface(udev, curidx) != NULL) {
1632                                 DPRINTF("Found HID interface at %d\n",
1633                                     curidx);
1634                                 sc->sc_hid.flags |= UAUDIO_HID_VALID;
1635                                 sc->sc_hid.iface_index = curidx;
1636                         }
1637
1638                         uma_if_class =
1639                             ((id->bInterfaceClass == UICLASS_AUDIO) ||
1640                             ((id->bInterfaceClass == UICLASS_VENDOR) &&
1641                             (sc->sc_uq_au_vendor_class != 0)));
1642
1643                         if ((uma_if_class != 0) &&
1644                             (id->bInterfaceSubClass == UISUBCLASS_AUDIOSTREAM)) {
1645                                 audio_if = 1;
1646                         } else {
1647                                 audio_if = 0;
1648                         }
1649
1650                         if ((uma_if_class != 0) &&
1651                             (id->bInterfaceSubClass == UISUBCLASS_MIDISTREAM)) {
1652
1653                                 /*
1654                                  * XXX could allow multiple MIDI interfaces
1655                                  */
1656                                 midi_if = 1;
1657
1658                                 if ((sc->sc_midi_chan.valid == 0) &&
1659                                     (usbd_get_iface(udev, curidx) != NULL)) {
1660                                         sc->sc_midi_chan.iface_index = curidx;
1661                                         sc->sc_midi_chan.iface_alt_index = alt_index;
1662                                         sc->sc_midi_chan.valid = 1;
1663                                 }
1664                         } else {
1665                                 midi_if = 0;
1666                         }
1667                         asid.v1 = NULL;
1668                         asf1d.v1 = NULL;
1669                         ed1 = NULL;
1670                         sed.v1 = NULL;
1671
1672                         /*
1673                          * There can only be one USB audio instance
1674                          * per USB device. Grab all USB audio
1675                          * interfaces on this USB device so that we
1676                          * don't attach USB audio twice:
1677                          */
1678                         if (alt_index == 0 && curidx != sc->sc_mixer_iface_index &&
1679                             (id->bInterfaceClass == UICLASS_AUDIO || audio_if != 0 ||
1680                             midi_if != 0)) {
1681                                 usbd_set_parent_iface(sc->sc_udev, curidx,
1682                                     sc->sc_mixer_iface_index);
1683                         }
1684                 }
1685
1686                 if (audio_if == 0) {
1687                         if (midi_if == 0) {
1688                                 if ((acdp == NULL) &&
1689                                     (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1690                                     (desc->bDescriptorSubtype == UDESCSUB_AC_HEADER) &&
1691                                     (desc->bLength >= sizeof(*acdp))) {
1692                                         acdp = (void *)desc;
1693                                         audio_rev = UGETW(acdp->bcdADC);
1694                                 }
1695                         } else {
1696                                 msid = (void *)desc;
1697
1698                                 /* get the maximum number of embedded jacks in use, if any */
1699                                 if (msid->bLength >= sizeof(*msid) &&
1700                                     msid->bDescriptorType == UDESC_CS_ENDPOINT &&
1701                                     msid->bDescriptorSubtype == MS_GENERAL &&
1702                                     msid->bNumEmbMIDIJack > sc->sc_midi_chan.max_emb_jack) {
1703                                         sc->sc_midi_chan.max_emb_jack = msid->bNumEmbMIDIJack;
1704                                 }
1705                         }
1706                         /*
1707                          * Don't collect any USB audio descriptors if
1708                          * this is not an USB audio stream interface.
1709                          */
1710                         continue;
1711                 }
1712
1713                 if ((acdp != NULL) &&
1714                     (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1715                     (desc->bDescriptorSubtype == AS_GENERAL) &&
1716                     (asid.v1 == NULL)) {
1717                         if (audio_rev >= UAUDIO_VERSION_30) {
1718                                 /* FALLTHROUGH */
1719                         } else if (audio_rev >= UAUDIO_VERSION_20) {
1720                                 if (desc->bLength >= sizeof(*asid.v2)) {
1721                                         asid.v2 = (void *)desc;
1722                                 }
1723                         } else {
1724                                 if (desc->bLength >= sizeof(*asid.v1)) {
1725                                         asid.v1 = (void *)desc;
1726                                 }
1727                         }
1728                 }
1729                 if ((acdp != NULL) &&
1730                     (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1731                     (desc->bDescriptorSubtype == FORMAT_TYPE) &&
1732                     (asf1d.v1 == NULL)) {
1733                         if (audio_rev >= UAUDIO_VERSION_30) {
1734                                 /* FALLTHROUGH */
1735                         } else if (audio_rev >= UAUDIO_VERSION_20) {
1736                                 if (desc->bLength >= sizeof(*asf1d.v2))
1737                                         asf1d.v2 = (void *)desc;
1738                         } else {
1739                                 if (desc->bLength >= sizeof(*asf1d.v1)) {
1740                                         asf1d.v1 = (void *)desc;
1741
1742                                         if (asf1d.v1->bFormatType != FORMAT_TYPE_I) {
1743                                                 DPRINTFN(11, "ignored bFormatType = %d\n",
1744                                                     asf1d.v1->bFormatType);
1745                                                 asf1d.v1 = NULL;
1746                                                 continue;
1747                                         }
1748                                         if (desc->bLength < (sizeof(*asf1d.v1) +
1749                                             ((asf1d.v1->bSamFreqType == 0) ? 6 :
1750                                             (asf1d.v1->bSamFreqType * 3)))) {
1751                                                 DPRINTFN(11, "invalid descriptor, "
1752                                                     "too short\n");
1753                                                 asf1d.v1 = NULL;
1754                                                 continue;
1755                                         }
1756                                 }
1757                         }
1758                 }
1759                 if ((desc->bDescriptorType == UDESC_ENDPOINT) &&
1760                     (desc->bLength >= UEP_MINSIZE) &&
1761                     (ed1 == NULL)) {
1762                         ed1 = (void *)desc;
1763                         if (UE_GET_XFERTYPE(ed1->bmAttributes) != UE_ISOCHRONOUS) {
1764                                 ed1 = NULL;
1765                                 continue;
1766                         }
1767                 }
1768                 if ((acdp != NULL) &&
1769                     (desc->bDescriptorType == UDESC_CS_ENDPOINT) &&
1770                     (desc->bDescriptorSubtype == AS_GENERAL) &&
1771                     (sed.v1 == NULL)) {
1772                         if (audio_rev >= UAUDIO_VERSION_30) {
1773                                 /* FALLTHROUGH */
1774                         } else if (audio_rev >= UAUDIO_VERSION_20) {
1775                                 if (desc->bLength >= sizeof(*sed.v2))
1776                                         sed.v2 = (void *)desc;
1777                         } else {
1778                                 if (desc->bLength >= sizeof(*sed.v1))
1779                                         sed.v1 = (void *)desc;
1780                         }
1781                 }
1782                 if (asid.v1 == NULL || asf1d.v1 == NULL ||
1783                     ed1 == NULL || sed.v1 == NULL) {
1784                         /* need more descriptors */
1785                         continue;
1786                 }
1787
1788                 ep_dir = UE_GET_DIR(ed1->bEndpointAddress);
1789
1790                 /* We ignore sync endpoint information until further. */
1791
1792                 if (audio_rev >= UAUDIO_VERSION_30) {
1793                         goto next_ep;
1794                 } else if (audio_rev >= UAUDIO_VERSION_20) {
1795
1796                         uint32_t dwFormat;
1797
1798                         dwFormat = UGETDW(asid.v2->bmFormats);
1799                         bChannels = asid.v2->bNrChannels;
1800                         bBitResolution = asf1d.v2->bSubslotSize * 8;
1801
1802                         if ((bChannels != channels) ||
1803                             (bBitResolution != bit_resolution)) {
1804                                 DPRINTF("Wrong number of channels\n");
1805                                 goto next_ep;
1806                         }
1807
1808                         for (p_fmt = uaudio20_formats;
1809                             p_fmt->wFormat != 0; p_fmt++) {
1810                                 if ((p_fmt->wFormat & dwFormat) &&
1811                                     (p_fmt->bPrecision == bBitResolution))
1812                                         break;
1813                         }
1814
1815                         if (p_fmt->wFormat == 0) {
1816                                 DPRINTF("Unsupported audio format\n");
1817                                 goto next_ep;
1818                         }
1819
1820                         for (x = 0; x != 256; x++) {
1821                                 if (ep_dir == UE_DIR_OUT) {
1822                                         if (!(sc->sc_mixer_clocks.bit_output[x / 8] &
1823                                             (1 << (x % 8)))) {
1824                                                 continue;
1825                                         }
1826                                 } else {
1827                                         if (!(sc->sc_mixer_clocks.bit_input[x / 8] &
1828                                             (1 << (x % 8)))) {
1829                                                 continue;
1830                                         }
1831                                 }
1832
1833                                 DPRINTF("Checking clock ID=%d\n", x);
1834
1835                                 if (uaudio20_check_rate(udev,
1836                                     sc->sc_mixer_iface_no, x, rate)) {
1837                                         DPRINTF("Unsupported sampling "
1838                                             "rate, id=%d\n", x);
1839                                         goto next_ep;
1840                                 }
1841                         }
1842                 } else {
1843                         uint16_t wFormat;
1844
1845                         wFormat = UGETW(asid.v1->wFormatTag);
1846                         bChannels = UAUDIO_MAX_CHAN(asf1d.v1->bNrChannels);
1847                         bBitResolution = asf1d.v1->bSubFrameSize * 8;
1848
1849                         if (asf1d.v1->bSamFreqType == 0) {
1850                                 DPRINTFN(16, "Sample rate: %d-%dHz\n",
1851                                     UA_SAMP_LO(asf1d.v1),
1852                                     UA_SAMP_HI(asf1d.v1));
1853
1854                                 if ((rate >= UA_SAMP_LO(asf1d.v1)) &&
1855                                     (rate <= UA_SAMP_HI(asf1d.v1)))
1856                                         goto found_rate;
1857                         } else {
1858
1859                                 for (x = 0; x < asf1d.v1->bSamFreqType; x++) {
1860                                         DPRINTFN(16, "Sample rate = %dHz\n",
1861                                             UA_GETSAMP(asf1d.v1, x));
1862
1863                                         if (rate == UA_GETSAMP(asf1d.v1, x))
1864                                                 goto found_rate;
1865                                 }
1866                         }
1867                         goto next_ep;
1868
1869         found_rate:
1870                         for (p_fmt = uaudio10_formats;
1871                             p_fmt->wFormat != 0; p_fmt++) {
1872                                 if ((p_fmt->wFormat == wFormat) &&
1873                                     (p_fmt->bPrecision == bBitResolution))
1874                                         break;
1875                         }
1876                         if (p_fmt->wFormat == 0) {
1877                                 DPRINTF("Unsupported audio format\n");
1878                                 goto next_ep;
1879                         }
1880
1881                         if ((bChannels != channels) ||
1882                             (bBitResolution != bit_resolution)) {
1883                                 DPRINTF("Wrong number of channels\n");
1884                                 goto next_ep;
1885                         }
1886                 }
1887
1888                 chan = (ep_dir == UE_DIR_IN) ?
1889                     &sc->sc_rec_chan : &sc->sc_play_chan;
1890
1891                 if (usbd_get_iface(udev, curidx) == NULL) {
1892                         DPRINTF("Interface is not valid\n");
1893                         goto next_ep;
1894                 }
1895                 if (chan->num_alt == CHAN_MAX_ALT) {
1896                         DPRINTF("Too many alternate settings\n");
1897                         goto next_ep;
1898                 }
1899                 chan->set_alt = 0;
1900                 chan->cur_alt = CHAN_MAX_ALT;
1901
1902                 chan_alt = &chan->usb_alt[chan->num_alt++];
1903
1904 #ifdef USB_DEBUG
1905                 uaudio_chan_dump_ep_desc(ed1);
1906 #endif
1907                 DPRINTF("Sample rate = %dHz, channels = %d, "
1908                     "bits = %d, format = %s\n", rate, channels,
1909                     bit_resolution, p_fmt->description);
1910
1911                 chan_alt->sample_rate = rate;
1912                 chan_alt->p_asf1d = asf1d;
1913                 chan_alt->p_ed1 = ed1;
1914                 chan_alt->p_fmt = p_fmt;
1915                 chan_alt->p_sed = sed;
1916                 chan_alt->iface_index = curidx;
1917                 chan_alt->iface_alt_index = alt_index;
1918
1919                 if (ep_dir == UE_DIR_IN)
1920                         chan_alt->usb_cfg = uaudio_cfg_record;
1921                 else
1922                         chan_alt->usb_cfg = uaudio_cfg_play;
1923
1924                 chan_alt->sample_size = (UAUDIO_MAX_CHAN(channels) *
1925                     p_fmt->bPrecision) / 8;
1926                 chan_alt->channels = channels;
1927
1928                 if (ep_dir == UE_DIR_IN &&
1929                     usbd_get_speed(udev) == USB_SPEED_FULL) {
1930                         uaudio_record_fix_fs(ed1,
1931                             chan_alt->sample_size * (rate / 1000),
1932                             chan_alt->sample_size * (rate / 4000));
1933                 }
1934
1935                 /* setup play/record format */
1936
1937                 format = chan_alt->p_fmt->freebsd_fmt;
1938
1939                 /* get default SND_FORMAT() */
1940                 format = SND_FORMAT(format, chan_alt->channels, 0);
1941
1942                 switch (chan_alt->channels) {
1943                 uint32_t temp_fmt;
1944                 case 1:
1945                 case 2:
1946                         /* mono and stereo */
1947                         break;
1948                 default:
1949                         /* surround and more */
1950                         temp_fmt = feeder_matrix_default_format(format);
1951                         /* if multichannel, then format can be zero */
1952                         if (temp_fmt != 0)
1953                                 format = temp_fmt;
1954                         break;
1955                 }
1956
1957                 /* check if format is not supported */
1958                 if (format == 0) {
1959                         DPRINTF("The selected audio format is not supported\n");
1960                         chan->num_alt--;
1961                         goto next_ep;
1962                 }
1963                 if (chan->num_alt > 1) {
1964                         /* we only accumulate one format at different sample rates */
1965                         if (chan->pcm_format[0] != format) {
1966                                 DPRINTF("Multiple formats is not supported\n");
1967                                 chan->num_alt--;
1968                                 goto next_ep;
1969                         }
1970                         /* ignore if duplicate sample rate entry */
1971                         if (rate == chan->usb_alt[chan->num_alt - 2].sample_rate) {
1972                                 DPRINTF("Duplicate sample rate detected\n");
1973                                 chan->num_alt--;
1974                                 goto next_ep;
1975                         }
1976                 }
1977                 chan->pcm_cap.fmtlist = chan->pcm_format;
1978                 chan->pcm_cap.fmtlist[0] = format;
1979
1980                 /* check if device needs bitperfect */
1981                 if (chan_alt->channels > UAUDIO_MATRIX_MAX)
1982                         sc->sc_pcm_bitperfect = 1;
1983
1984                 if (rate < chan->pcm_cap.minspeed || chan->pcm_cap.minspeed == 0)
1985                         chan->pcm_cap.minspeed = rate;
1986                 if (rate > chan->pcm_cap.maxspeed || chan->pcm_cap.maxspeed == 0)
1987                         chan->pcm_cap.maxspeed = rate;
1988
1989                 if (sc->sc_sndstat_valid != 0) {
1990                         sbuf_printf(&sc->sc_sndstat, "\n\t"
1991                             "mode %d.%d:(%s) %dch, %dbit, %s, %dHz",
1992                             curidx, alt_index,
1993                             (ep_dir == UE_DIR_IN) ? "input" : "output",
1994                                     channels, p_fmt->bPrecision,
1995                                     p_fmt->description, rate);
1996                 }
1997
1998         next_ep:
1999                 sed.v1 = NULL;
2000                 ed1 = NULL;
2001         }
2002 }
2003
2004 /* This structure defines all the supported rates. */
2005
2006 static const uint32_t uaudio_rate_list[CHAN_MAX_ALT] = {
2007         384000,
2008         352800,
2009         192000,
2010         176400,
2011         96000,
2012         88200,
2013         88000,
2014         80000,
2015         72000,
2016         64000,
2017         56000,
2018         48000,
2019         44100,
2020         40000,
2021         32000,
2022         24000,
2023         22050,
2024         16000,
2025         11025,
2026         8000,
2027         0
2028 };
2029
2030 static void
2031 uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev)
2032 {
2033         uint32_t rate = uaudio_default_rate;
2034         uint8_t z;
2035         uint8_t bits = uaudio_default_bits;
2036         uint8_t y;
2037         uint8_t channels = uaudio_default_channels;
2038         uint8_t x;
2039
2040         bits -= (bits % 8);
2041         if ((bits == 0) || (bits > 32)) {
2042                 /* set a valid value */
2043                 bits = 32;
2044         }
2045         if (channels == 0) {
2046                 switch (usbd_get_speed(udev)) {
2047                 case USB_SPEED_LOW:
2048                 case USB_SPEED_FULL:
2049                         /*
2050                          * Due to high bandwidth usage and problems
2051                          * with HIGH-speed split transactions we
2052                          * disable surround setups on FULL-speed USB
2053                          * by default
2054                          */
2055                         channels = 4;
2056                         break;
2057                 default:
2058                         channels = UAUDIO_CHANNELS_MAX;
2059                         break;
2060                 }
2061         } else if (channels > UAUDIO_CHANNELS_MAX)
2062                 channels = UAUDIO_CHANNELS_MAX;
2063
2064         if (sbuf_new(&sc->sc_sndstat, NULL, 4096, SBUF_AUTOEXTEND))
2065                 sc->sc_sndstat_valid = 1;
2066
2067         /* try to search for a valid config */
2068
2069         for (x = channels; x; x--) {
2070                 for (y = bits; y; y -= 8) {
2071
2072                         /* try user defined rate, if any */
2073                         if (rate != 0)
2074                                 uaudio_chan_fill_info_sub(sc, udev, rate, x, y);
2075
2076                         /* try find a matching rate, if any */
2077                         for (z = 0; uaudio_rate_list[z]; z++)
2078                                 uaudio_chan_fill_info_sub(sc, udev, uaudio_rate_list[z], x, y);
2079                 }
2080         }
2081         if (sc->sc_sndstat_valid)
2082                 sbuf_finish(&sc->sc_sndstat);
2083 }
2084
2085 static void
2086 uaudio_chan_play_sync_callback(struct usb_xfer *xfer, usb_error_t error)
2087 {
2088         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2089         struct usb_page_cache *pc;
2090         uint64_t sample_rate;
2091         uint8_t buf[4];
2092         uint64_t temp;
2093         int len;
2094         int actlen;
2095         int nframes;
2096
2097         usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
2098
2099         switch (USB_GET_STATE(xfer)) {
2100         case USB_ST_TRANSFERRED:
2101
2102                 DPRINTFN(6, "transferred %d bytes\n", actlen);
2103
2104                 if (nframes == 0)
2105                         break;
2106                 len = usbd_xfer_frame_len(xfer, 0);
2107                 if (len == 0)
2108                         break;
2109                 if (len > sizeof(buf))
2110                         len = sizeof(buf);
2111
2112                 memset(buf, 0, sizeof(buf));
2113
2114                 pc = usbd_xfer_get_frame(xfer, 0);
2115                 usbd_copy_out(pc, 0, buf, len);
2116
2117                 temp = UGETDW(buf);
2118
2119                 DPRINTF("Value = 0x%08x\n", (int)temp);
2120
2121                 /* auto-detect SYNC format */
2122
2123                 if (len == 4)
2124                         temp &= 0x0fffffff;
2125
2126                 /* check for no data */
2127
2128                 if (temp == 0)
2129                         break;
2130
2131                 temp *= 125ULL;
2132
2133                 sample_rate = ch->usb_alt[ch->cur_alt].sample_rate;
2134
2135                 /* auto adjust */
2136                 while (temp < (sample_rate - (sample_rate / 4)))
2137                         temp *= 2;
2138
2139                 while (temp > (sample_rate + (sample_rate / 2)))
2140                         temp /= 2;
2141
2142                 DPRINTF("Comparing %d Hz :: %d Hz\n",
2143                     (int)temp, (int)sample_rate);
2144
2145                 /*
2146                  * Use feedback value as fallback when there is no
2147                  * recording channel:
2148                  */
2149                 if (ch->priv_sc->sc_rec_chan.num_alt == 0) {
2150                         int32_t jitter_max = howmany(sample_rate, 16000);
2151
2152                         /*
2153                          * Range check the jitter values to avoid
2154                          * bogus sample rate adjustments. The expected
2155                          * deviation should not be more than 1Hz per
2156                          * second. The USB v2.0 specification also
2157                          * mandates this requirement. Refer to chapter
2158                          * 5.12.4.2 about feedback.
2159                          */
2160                         ch->jitter_curr = temp - sample_rate;
2161                         if (ch->jitter_curr > jitter_max)
2162                                 ch->jitter_curr = jitter_max;
2163                         else if (ch->jitter_curr < -jitter_max)
2164                                 ch->jitter_curr = -jitter_max;
2165                 }
2166                 ch->feedback_rate = temp;
2167                 break;
2168
2169         case USB_ST_SETUP:
2170                 /*
2171                  * Check if the recording stream can be used as a
2172                  * source of jitter information to save some
2173                  * isochronous bandwidth:
2174                  */
2175                 if (ch->priv_sc->sc_rec_chan.num_alt != 0 &&
2176                     uaudio_debug == 0)
2177                         break;
2178                 usbd_xfer_set_frames(xfer, 1);
2179                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_framelen(xfer));
2180                 usbd_transfer_submit(xfer);
2181                 break;
2182
2183         default:                        /* Error */
2184                 break;
2185         }
2186 }
2187
2188 static int
2189 uaudio_chan_is_async(struct uaudio_chan *ch, uint8_t alt)
2190 {
2191         uint8_t attr = ch->usb_alt[alt].p_ed1->bmAttributes;
2192         return (UE_GET_ISO_TYPE(attr) == UE_ISO_ASYNC);
2193 }
2194
2195 static void
2196 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error)
2197 {
2198         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2199         struct uaudio_chan *ch_rec;
2200         struct usb_page_cache *pc;
2201         uint32_t mfl;
2202         uint32_t total;
2203         uint32_t blockcount;
2204         uint32_t n;
2205         uint32_t offset;
2206         int sample_size;
2207         int actlen;
2208         int sumlen;
2209
2210         if (ch->running == 0 || ch->start == ch->end) {
2211                 DPRINTF("not running or no buffer!\n");
2212                 return;
2213         }
2214
2215         /* check if there is a record channel */
2216         if (ch->priv_sc->sc_rec_chan.num_alt > 0)
2217                 ch_rec = &ch->priv_sc->sc_rec_chan;
2218         else
2219                 ch_rec = NULL;
2220
2221         usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
2222
2223         switch (USB_GET_STATE(xfer)) {
2224         case USB_ST_SETUP:
2225 tr_setup:
2226                 if (ch_rec != NULL) {
2227                         /* reset receive jitter counters */
2228                         mtx_lock(ch_rec->pcm_mtx);
2229                         ch_rec->jitter_curr = 0;
2230                         ch_rec->jitter_rem = 0;
2231                         mtx_unlock(ch_rec->pcm_mtx);
2232                 }
2233
2234                 /* reset transmit jitter counters */
2235                 ch->jitter_curr = 0;
2236                 ch->jitter_rem = 0;
2237
2238                 /* FALLTHROUGH */
2239         case USB_ST_TRANSFERRED:
2240                 if (actlen < sumlen) {
2241                         DPRINTF("short transfer, "
2242                             "%d of %d bytes\n", actlen, sumlen);
2243                 }
2244                 chn_intr(ch->pcm_ch);
2245
2246                 /*
2247                  * Check for asynchronous playback endpoint and that
2248                  * the playback endpoint is properly configured:
2249                  */
2250                 if (ch_rec != NULL &&
2251                     uaudio_chan_is_async(ch, ch->cur_alt) != 0) {
2252                         mtx_lock(ch_rec->pcm_mtx);
2253                         if (ch_rec->cur_alt < ch_rec->num_alt) {
2254                                 int64_t tx_jitter;
2255                                 int64_t rx_rate;
2256
2257                                 /* translate receive jitter into transmit jitter */
2258                                 tx_jitter = ch->usb_alt[ch->cur_alt].sample_rate;
2259                                 tx_jitter = (tx_jitter * ch_rec->jitter_curr) +
2260                                     ch->jitter_rem;
2261
2262                                 /* reset receive jitter counters */
2263                                 ch_rec->jitter_curr = 0;
2264                                 ch_rec->jitter_rem = 0;
2265
2266                                 /* compute exact number of transmit jitter samples */
2267                                 rx_rate = ch_rec->usb_alt[ch_rec->cur_alt].sample_rate;
2268                                 ch->jitter_curr += tx_jitter / rx_rate;
2269                                 ch->jitter_rem = tx_jitter % rx_rate;
2270                         }
2271                         mtx_unlock(ch_rec->pcm_mtx);
2272                 }
2273
2274                 /* start the SYNC transfer one time per second, if any */
2275                 ch->intr_counter += ch->intr_frames;
2276                 if (ch->intr_counter >= ch->frames_per_second) {
2277                         ch->intr_counter -= ch->frames_per_second;
2278                         usbd_transfer_start(ch->xfer[UAUDIO_NCHANBUFS]);
2279                 }
2280
2281                 mfl = usbd_xfer_max_framelen(xfer);
2282
2283                 if (ch->bytes_per_frame[1] > mfl) {
2284                         DPRINTF("bytes per transfer, %d, "
2285                             "exceeds maximum, %d!\n",
2286                             ch->bytes_per_frame[1],
2287                             mfl);
2288                         break;
2289                 }
2290
2291                 blockcount = ch->intr_frames;
2292
2293                 /* setup number of frames */
2294                 usbd_xfer_set_frames(xfer, blockcount);
2295
2296                 /* get sample size */
2297                 sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2298
2299                 /* reset total length */
2300                 total = 0;
2301
2302                 /* setup frame lengths */
2303                 for (n = 0; n != blockcount; n++) {
2304                         uint32_t frame_len;
2305
2306                         ch->sample_curr += ch->sample_rem;
2307                         if (ch->sample_curr >= ch->frames_per_second) {
2308                                 ch->sample_curr -= ch->frames_per_second;
2309                                 frame_len = ch->bytes_per_frame[1];
2310                         } else {
2311                                 frame_len = ch->bytes_per_frame[0];
2312                         }
2313
2314                         /* handle free running clock case */
2315                         if (ch->jitter_curr > 0 &&
2316                             (frame_len + sample_size) <= mfl) {
2317                                 DPRINTFN(6, "sending one sample more\n");
2318                                 ch->jitter_curr--;
2319                                 frame_len += sample_size;
2320                         } else if (ch->jitter_curr < 0 &&
2321                             frame_len >= sample_size) {
2322                                 DPRINTFN(6, "sending one sample less\n");
2323                                 ch->jitter_curr++;
2324                                 frame_len -= sample_size;
2325                         }
2326                         usbd_xfer_set_frame_len(xfer, n, frame_len);
2327                         total += frame_len;
2328                 }
2329
2330                 DPRINTFN(6, "transferring %d bytes\n", total);
2331
2332                 offset = 0;
2333
2334                 pc = usbd_xfer_get_frame(xfer, 0);
2335                 while (total > 0) {
2336
2337                         n = (ch->end - ch->cur);
2338                         if (n > total)
2339                                 n = total;
2340
2341                         usbd_copy_in(pc, offset, ch->cur, n);
2342
2343                         total -= n;
2344                         ch->cur += n;
2345                         offset += n;
2346
2347                         if (ch->cur >= ch->end)
2348                                 ch->cur = ch->start;
2349                 }
2350                 usbd_transfer_submit(xfer);
2351                 break;
2352
2353         default:                        /* Error */
2354                 if (error != USB_ERR_CANCELLED)
2355                         goto tr_setup;
2356                 break;
2357         }
2358 }
2359
2360 static void
2361 uaudio_chan_record_sync_callback(struct usb_xfer *xfer, usb_error_t error)
2362 {
2363         /* TODO */
2364 }
2365
2366 static void
2367 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error)
2368 {
2369         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2370         struct usb_page_cache *pc;
2371         uint32_t offset0;
2372         uint32_t mfl;
2373         int m;
2374         int n;
2375         int len;
2376         int actlen;
2377         int nframes;
2378         int expected_bytes;
2379         int sample_size;
2380
2381         if (ch->start == ch->end) {
2382                 DPRINTF("no buffer!\n");
2383                 return;
2384         }
2385
2386         usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
2387         mfl = usbd_xfer_max_framelen(xfer);
2388
2389         switch (USB_GET_STATE(xfer)) {
2390         case USB_ST_TRANSFERRED:
2391
2392                 offset0 = 0;
2393                 pc = usbd_xfer_get_frame(xfer, 0);
2394
2395                 /* try to compute the number of expected bytes */
2396                 ch->sample_curr += (ch->sample_rem * ch->intr_frames);
2397
2398                 /* compute number of expected bytes */
2399                 expected_bytes = (ch->intr_frames * ch->bytes_per_frame[0]) +
2400                     ((ch->sample_curr / ch->frames_per_second) *
2401                     (ch->bytes_per_frame[1] - ch->bytes_per_frame[0]));
2402
2403                 /* keep remainder */
2404                 ch->sample_curr %= ch->frames_per_second;
2405
2406                 /* get current sample size */
2407                 sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2408
2409                 for (n = 0; n != nframes; n++) {
2410                         uint32_t offset1 = offset0;
2411
2412                         len = usbd_xfer_frame_len(xfer, n);
2413
2414                         /* make sure we only receive complete samples */
2415                         len = len - (len % sample_size);
2416
2417                         /* subtract bytes received from expected payload */
2418                         expected_bytes -= len;
2419
2420                         /* don't receive data when not ready */
2421                         if (ch->running == 0 || ch->cur_alt != ch->set_alt)
2422                                 continue;
2423
2424                         /* fill ring buffer with samples, if any */
2425                         while (len > 0) {
2426
2427                                 m = (ch->end - ch->cur);
2428
2429                                 if (m > len)
2430                                         m = len;
2431
2432                                 usbd_copy_out(pc, offset1, ch->cur, m);
2433
2434                                 len -= m;
2435                                 offset1 += m;
2436                                 ch->cur += m;
2437
2438                                 if (ch->cur >= ch->end)
2439                                         ch->cur = ch->start;
2440                         }
2441
2442                         offset0 += mfl;
2443                 }
2444
2445                 /* update current jitter */
2446                 ch->jitter_curr -= (expected_bytes / sample_size);
2447
2448                 /* don't allow a huge amount of jitter to accumulate */
2449                 nframes = 2 * ch->intr_frames;
2450
2451                 /* range check current jitter */
2452                 if (ch->jitter_curr < -nframes)
2453                         ch->jitter_curr = -nframes;
2454                 else if (ch->jitter_curr > nframes)
2455                         ch->jitter_curr = nframes;
2456
2457                 DPRINTFN(6, "transferred %d bytes, jitter %d samples\n",
2458                     actlen, ch->jitter_curr);
2459
2460                 if (ch->running != 0)
2461                         chn_intr(ch->pcm_ch);
2462
2463         case USB_ST_SETUP:
2464 tr_setup:
2465                 nframes = ch->intr_frames;
2466
2467                 usbd_xfer_set_frames(xfer, nframes);
2468                 for (n = 0; n != nframes; n++)
2469                         usbd_xfer_set_frame_len(xfer, n, mfl);
2470
2471                 usbd_transfer_submit(xfer);
2472                 break;
2473
2474         default:                        /* Error */
2475                 if (error != USB_ERR_CANCELLED)
2476                         goto tr_setup;
2477                 break;
2478         }
2479 }
2480
2481 void   *
2482 uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b,
2483     struct pcm_channel *c, int dir)
2484 {
2485         struct uaudio_chan *ch = ((dir == PCMDIR_PLAY) ?
2486             &sc->sc_play_chan : &sc->sc_rec_chan);
2487         uint32_t buf_size;
2488         uint8_t x;
2489
2490         /* store mutex and PCM channel */
2491
2492         ch->pcm_ch = c;
2493         ch->pcm_mtx = c->lock;
2494
2495         /* compute worst case buffer */
2496
2497         buf_size = 0;
2498         for (x = 0; x != ch->num_alt; x++) {
2499                 uint32_t temp = uaudio_get_buffer_size(ch, x);
2500                 if (temp > buf_size)
2501                         buf_size = temp;
2502         }
2503
2504         /* allow double buffering */
2505         buf_size *= 2;
2506
2507         DPRINTF("Worst case buffer is %d bytes\n", (int)buf_size);
2508
2509         ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO);
2510         if (ch->buf == NULL)
2511                 goto error;
2512         if (sndbuf_setup(b, ch->buf, buf_size) != 0)
2513                 goto error;
2514
2515         ch->start = ch->buf;
2516         ch->end = ch->buf + buf_size;
2517         ch->cur = ch->buf;
2518         ch->pcm_buf = b;
2519         ch->max_buf = buf_size;
2520
2521         if (ch->pcm_mtx == NULL) {
2522                 DPRINTF("ERROR: PCM channels does not have a mutex!\n");
2523                 goto error;
2524         }
2525         return (ch);
2526
2527 error:
2528         uaudio_chan_free(ch);
2529         return (NULL);
2530 }
2531
2532 int
2533 uaudio_chan_free(struct uaudio_chan *ch)
2534 {
2535         if (ch->buf != NULL) {
2536                 free(ch->buf, M_DEVBUF);
2537                 ch->buf = NULL;
2538         }
2539         usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS + 1);
2540
2541         ch->num_alt = 0;
2542
2543         return (0);
2544 }
2545
2546 int
2547 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize)
2548 {
2549         uint32_t temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2550         sndbuf_setup(ch->pcm_buf, ch->buf, temp);
2551         return (temp / 2);
2552 }
2553
2554 int
2555 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize,
2556     uint32_t blockcount)
2557 {
2558         return (1);
2559 }
2560
2561 int
2562 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed)
2563 {
2564         struct uaudio_softc *sc;
2565         uint8_t x;
2566
2567         sc = ch->priv_sc;
2568
2569         for (x = 0; x < ch->num_alt; x++) {
2570                 if (ch->usb_alt[x].sample_rate < speed) {
2571                         /* sample rate is too low */
2572                         break;
2573                 }
2574         }
2575
2576         if (x != 0)
2577                 x--;
2578
2579         usb_proc_explore_lock(sc->sc_udev);
2580         ch->set_alt = x;
2581         usb_proc_explore_unlock(sc->sc_udev);
2582
2583         DPRINTF("Selecting alt %d\n", (int)x);
2584
2585         return (ch->usb_alt[x].sample_rate);
2586 }
2587
2588 int
2589 uaudio_chan_getptr(struct uaudio_chan *ch)
2590 {
2591         return (ch->cur - ch->start);
2592 }
2593
2594 struct pcmchan_caps *
2595 uaudio_chan_getcaps(struct uaudio_chan *ch)
2596 {
2597         return (&ch->pcm_cap);
2598 }
2599
2600 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = {
2601         .id = SND_CHN_MATRIX_DRV,
2602         .channels = 2,
2603         .ext = 0,
2604         .map = {
2605                 /* Right */
2606                 [0] = {
2607                         .type = SND_CHN_T_FR,
2608                         .members =
2609                             SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC |
2610                             SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR |
2611                             SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR
2612                 },
2613                 /* Left */
2614                 [1] = {
2615                         .type = SND_CHN_T_FL,
2616                         .members =
2617                             SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC |
2618                             SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL |
2619                             SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL
2620                 },
2621                 [2] = {
2622                         .type = SND_CHN_T_MAX,
2623                         .members = 0
2624                 }
2625         },
2626         .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL,
2627         .offset = {  1,  0, -1, -1, -1, -1, -1, -1, -1,
2628                     -1, -1, -1, -1, -1, -1, -1, -1, -1  }
2629 };
2630
2631 struct pcmchan_matrix *
2632 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format)
2633 {
2634         struct uaudio_softc *sc;
2635
2636         sc = ch->priv_sc;
2637
2638         if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 &&
2639             AFMT_CHANNEL(format) == 2)
2640                 return (&uaudio_chan_matrix_swap_2_0);
2641
2642         return (feeder_matrix_format_map(format));
2643 }
2644
2645 int
2646 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format)
2647 {
2648         DPRINTF("Selecting format 0x%08x\n", (unsigned int)format);
2649         return (0);
2650 }
2651
2652 static void
2653 uaudio_chan_start_sub(struct uaudio_chan *ch)
2654 {
2655         struct uaudio_softc *sc = ch->priv_sc;
2656         int do_start = 0;
2657
2658         if (ch->operation != CHAN_OP_DRAIN) {
2659                 if (ch->cur_alt == ch->set_alt &&
2660                     ch->operation == CHAN_OP_NONE &&
2661                     mtx_owned(ch->pcm_mtx) != 0) {
2662                         /* save doing the explore task */
2663                         do_start = 1;
2664                 } else {
2665                         ch->operation = CHAN_OP_START;
2666                         (void)usb_proc_explore_msignal(sc->sc_udev,
2667                             &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2668                 }
2669         }
2670         if (do_start) {
2671                 usbd_transfer_start(ch->xfer[0]);
2672                 usbd_transfer_start(ch->xfer[1]);
2673         }
2674 }
2675
2676 static int
2677 uaudio_chan_need_both(struct uaudio_softc *sc)
2678 {
2679         return (sc->sc_play_chan.num_alt > 0 &&
2680             sc->sc_play_chan.running != 0 &&
2681             uaudio_chan_is_async(&sc->sc_play_chan,
2682             sc->sc_play_chan.set_alt) != 0 &&
2683             sc->sc_rec_chan.num_alt > 0 &&
2684             sc->sc_rec_chan.running == 0);
2685 }
2686
2687 static int
2688 uaudio_chan_need_none(struct uaudio_softc *sc)
2689 {
2690         return (sc->sc_play_chan.num_alt > 0 &&
2691             sc->sc_play_chan.running == 0 &&
2692             sc->sc_rec_chan.num_alt > 0 &&
2693             sc->sc_rec_chan.running == 0);
2694 }
2695
2696 void
2697 uaudio_chan_start(struct uaudio_chan *ch)
2698 {
2699         struct uaudio_softc *sc = ch->priv_sc;
2700
2701         /* make operation atomic */
2702         usb_proc_explore_lock(sc->sc_udev);
2703
2704         /* check if not running */
2705         if (ch->running == 0) {
2706                 uint32_t temp;
2707
2708                 /* get current buffer size */
2709                 temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2710
2711                 /* set running flag */
2712                 ch->running = 1;
2713
2714                 /* ensure the hardware buffer is reset */
2715                 ch->start = ch->buf;
2716                 ch->end = ch->buf + temp;
2717                 ch->cur = ch->buf;
2718
2719                 if (uaudio_chan_need_both(sc)) {
2720                         /*
2721                          * Start both endpoints because of need for
2722                          * jitter information:
2723                          */
2724                         uaudio_chan_start_sub(&sc->sc_rec_chan);
2725                         uaudio_chan_start_sub(&sc->sc_play_chan);
2726                 } else {
2727                         uaudio_chan_start_sub(ch);
2728                 }
2729         }
2730
2731         /* exit atomic operation */
2732         usb_proc_explore_unlock(sc->sc_udev);
2733 }
2734
2735 static void
2736 uaudio_chan_stop_sub(struct uaudio_chan *ch)
2737 {
2738         struct uaudio_softc *sc = ch->priv_sc;
2739         int do_stop = 0;
2740
2741         if (ch->operation != CHAN_OP_DRAIN) {
2742                 if (ch->cur_alt == ch->set_alt &&
2743                     ch->operation == CHAN_OP_NONE &&
2744                     mtx_owned(ch->pcm_mtx) != 0) {
2745                         /* save doing the explore task */
2746                         do_stop = 1;
2747                 } else {
2748                         ch->operation = CHAN_OP_STOP;
2749                         (void)usb_proc_explore_msignal(sc->sc_udev,
2750                             &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2751                 }
2752         }
2753         if (do_stop) {
2754                 usbd_transfer_stop(ch->xfer[0]);
2755                 usbd_transfer_stop(ch->xfer[1]);
2756         }
2757 }
2758
2759 void
2760 uaudio_chan_stop(struct uaudio_chan *ch)
2761 {
2762         struct uaudio_softc *sc = ch->priv_sc;
2763
2764         /* make operation atomic */
2765         usb_proc_explore_lock(sc->sc_udev);
2766
2767         /* check if running */
2768         if (ch->running != 0) {
2769                 /* clear running flag */
2770                 ch->running = 0;
2771
2772                 if (uaudio_chan_need_both(sc)) {
2773                         /*
2774                          * Leave the endpoints running because we need
2775                          * information about jitter!
2776                          */
2777                 } else if (uaudio_chan_need_none(sc)) {
2778                         /*
2779                          * Stop both endpoints in case the one was used for
2780                          * jitter information:
2781                          */
2782                         uaudio_chan_stop_sub(&sc->sc_rec_chan);
2783                         uaudio_chan_stop_sub(&sc->sc_play_chan);
2784                 } else {
2785                         uaudio_chan_stop_sub(ch);
2786                 }
2787         }
2788
2789         /* exit atomic operation */
2790         usb_proc_explore_unlock(sc->sc_udev);
2791 }
2792
2793 /*========================================================================*
2794  * AC - Audio Controller - routines
2795  *========================================================================*/
2796
2797 static int
2798 uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS)
2799 {
2800         struct uaudio_softc *sc;
2801         struct uaudio_mixer_node *pmc;
2802         int hint;
2803         int error;
2804         int temp = 0;
2805         int chan = 0;
2806
2807         sc = (struct uaudio_softc *)oidp->oid_arg1;
2808         hint = oidp->oid_arg2;
2809
2810         if (sc->sc_mixer_lock == NULL)
2811                 return (ENXIO);
2812
2813         /* lookup mixer node */
2814
2815         mtx_lock(sc->sc_mixer_lock);
2816         for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
2817                 for (chan = 0; chan != (int)pmc->nchan; chan++) {
2818                         if (pmc->wValue[chan] != -1 &&
2819                             pmc->wValue[chan] == hint) {
2820                                 temp = pmc->wData[chan];
2821                                 goto found;
2822                         }
2823                 }
2824         }
2825 found:
2826         mtx_unlock(sc->sc_mixer_lock);
2827
2828         error = sysctl_handle_int(oidp, &temp, 0, req);
2829         if (error != 0 || req->newptr == NULL)
2830                 return (error);
2831
2832         /* update mixer value */
2833
2834         mtx_lock(sc->sc_mixer_lock);
2835         if (pmc != NULL &&
2836             temp >= pmc->minval &&
2837             temp <= pmc->maxval) {
2838
2839                 pmc->wData[chan] = temp;
2840                 pmc->update[(chan / 8)] |= (1 << (chan % 8));
2841
2842                 /* start the transfer, if not already started */
2843                 usbd_transfer_start(sc->sc_mixer_xfer[0]);
2844         }
2845         mtx_unlock(sc->sc_mixer_lock);
2846
2847         return (0);
2848 }
2849
2850 static void
2851 uaudio_mixer_ctl_free(struct uaudio_softc *sc)
2852 {
2853         struct uaudio_mixer_node *p_mc;
2854
2855         while ((p_mc = sc->sc_mixer_root) != NULL) {
2856                 sc->sc_mixer_root = p_mc->next;
2857                 free(p_mc, M_USBDEV);
2858         }
2859 }
2860
2861 static void
2862 uaudio_mixer_register_sysctl(struct uaudio_softc *sc, device_t dev)
2863 {
2864         struct uaudio_mixer_node *pmc;
2865         struct sysctl_oid *mixer_tree;
2866         struct sysctl_oid *control_tree;
2867         char buf[32];
2868         int chan;
2869         int n;
2870
2871         mixer_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
2872             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "mixer",
2873             CTLFLAG_RD, NULL, "");
2874
2875         if (mixer_tree == NULL)
2876                 return;
2877
2878         for (n = 0, pmc = sc->sc_mixer_root; pmc != NULL;
2879             pmc = pmc->next, n++) {
2880
2881                 for (chan = 0; chan < pmc->nchan; chan++) {
2882
2883                         if (pmc->nchan > 1) {
2884                                 snprintf(buf, sizeof(buf), "%s_%d_%d",
2885                                     pmc->name, n, chan);
2886                         } else {
2887                                 snprintf(buf, sizeof(buf), "%s_%d",
2888                                     pmc->name, n);
2889                         }
2890
2891                         control_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
2892                             SYSCTL_CHILDREN(mixer_tree), OID_AUTO, buf,
2893                             CTLFLAG_RD, NULL, "Mixer control nodes");
2894
2895                         if (control_tree == NULL)
2896                                 continue;
2897
2898                         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
2899                             SYSCTL_CHILDREN(control_tree),
2900                             OID_AUTO, "val", CTLTYPE_INT | CTLFLAG_RW, sc,
2901                             pmc->wValue[chan],
2902                             uaudio_mixer_sysctl_handler, "I", "Current value");
2903
2904                         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
2905                             SYSCTL_CHILDREN(control_tree),
2906                             OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval,
2907                             "Minimum value");
2908
2909                         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
2910                             SYSCTL_CHILDREN(control_tree),
2911                             OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval,
2912                             "Maximum value");
2913
2914                         SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
2915                             SYSCTL_CHILDREN(control_tree),
2916                             OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0,
2917                             "Description");
2918                 }
2919         }
2920 }
2921
2922 /* M-Audio FastTrack Ultra Mixer Description */
2923 /* Origin: Linux USB Audio driver */
2924 static void
2925 uaudio_mixer_controls_create_ftu(struct uaudio_softc *sc)
2926 {
2927         int chx;
2928         int chy;
2929
2930         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2931         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2932         MIX(sc).wValue[0] = MAKE_WORD(8, 0);
2933         MIX(sc).class = UAC_OUTPUT;
2934         MIX(sc).type = MIX_UNSIGNED_16;
2935         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2936         MIX(sc).name = "effect";
2937         MIX(sc).minval = 0;
2938         MIX(sc).maxval = 7;
2939         MIX(sc).mul = 7;
2940         MIX(sc).nchan = 1;
2941         MIX(sc).update[0] = 1;
2942         strlcpy(MIX(sc).desc, "Room1,2,3,Hall1,2,Plate,Delay,Echo", sizeof(MIX(sc).desc));
2943         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2944
2945         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2946         MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
2947
2948         for (chx = 0; chx != 8; chx++) {
2949                 for (chy = 0; chy != 8; chy++) {
2950
2951                         MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1);
2952                         MIX(sc).type = MIX_SIGNED_16;
2953                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2954                         MIX(sc).name = "mix_rec";
2955                         MIX(sc).nchan = 1;
2956                         MIX(sc).update[0] = 1;
2957                         MIX(sc).val_default = 0;
2958                         snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2959                             "AIn%d - Out%d Record Volume", chy + 1, chx + 1);
2960
2961                         uaudio_mixer_add_ctl(sc, &MIX(sc));
2962
2963                         MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1 + 8);
2964                         MIX(sc).type = MIX_SIGNED_16;
2965                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2966                         MIX(sc).name = "mix_play";
2967                         MIX(sc).nchan = 1;
2968                         MIX(sc).update[0] = 1;
2969                         MIX(sc).val_default = (chx == chy) ? 2 : 0;
2970                         snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2971                             "DIn%d - Out%d Playback Volume", chy + 1, chx + 1);
2972
2973                         uaudio_mixer_add_ctl(sc, &MIX(sc));
2974                 }
2975         }
2976
2977         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2978         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2979         MIX(sc).wValue[0] = MAKE_WORD(2, 0);
2980         MIX(sc).class = UAC_OUTPUT;
2981         MIX(sc).type = MIX_SIGNED_8;
2982         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2983         MIX(sc).name = "effect_vol";
2984         MIX(sc).nchan = 1;
2985         MIX(sc).update[0] = 1;
2986         MIX(sc).minval = 0;
2987         MIX(sc).maxval = 0x7f;
2988         MIX(sc).mul = 0x7f;
2989         MIX(sc).nchan = 1;
2990         MIX(sc).update[0] = 1;
2991         strlcpy(MIX(sc).desc, "Effect Volume", sizeof(MIX(sc).desc));
2992         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2993
2994         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2995         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2996         MIX(sc).wValue[0] = MAKE_WORD(3, 0);
2997         MIX(sc).class = UAC_OUTPUT;
2998         MIX(sc).type = MIX_SIGNED_16;
2999         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3000         MIX(sc).name = "effect_dur";
3001         MIX(sc).nchan = 1;
3002         MIX(sc).update[0] = 1;
3003         MIX(sc).minval = 0;
3004         MIX(sc).maxval = 0x7f00;
3005         MIX(sc).mul = 0x7f00;
3006         MIX(sc).nchan = 1;
3007         MIX(sc).update[0] = 1;
3008         strlcpy(MIX(sc).desc, "Effect Duration", sizeof(MIX(sc).desc));
3009         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3010
3011         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3012         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3013         MIX(sc).wValue[0] = MAKE_WORD(4, 0);
3014         MIX(sc).class = UAC_OUTPUT;
3015         MIX(sc).type = MIX_SIGNED_8;
3016         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3017         MIX(sc).name = "effect_fb";
3018         MIX(sc).nchan = 1;
3019         MIX(sc).update[0] = 1;
3020         MIX(sc).minval = 0;
3021         MIX(sc).maxval = 0x7f;
3022         MIX(sc).mul = 0x7f;
3023         MIX(sc).nchan = 1;
3024         MIX(sc).update[0] = 1;
3025         strlcpy(MIX(sc).desc, "Effect Feedback Volume", sizeof(MIX(sc).desc));
3026         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3027
3028         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3029         MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no);
3030         for (chy = 0; chy != 4; chy++) {
3031
3032                 MIX(sc).wValue[0] = MAKE_WORD(7, chy + 1);
3033                 MIX(sc).type = MIX_SIGNED_16;
3034                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3035                 MIX(sc).name = "effect_ret";
3036                 MIX(sc).nchan = 1;
3037                 MIX(sc).update[0] = 1;
3038                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3039                     "Effect Return %d Volume", chy + 1);
3040
3041                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3042         }
3043
3044         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3045         MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3046
3047         for (chy = 0; chy != 8; chy++) {
3048                 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1);
3049                 MIX(sc).type = MIX_SIGNED_16;
3050                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3051                 MIX(sc).name = "effect_send";
3052                 MIX(sc).nchan = 1;
3053                 MIX(sc).update[0] = 1;
3054                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3055                     "Effect Send AIn%d Volume", chy + 1);
3056
3057                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3058
3059                 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1 + 8);
3060                 MIX(sc).type = MIX_SIGNED_16;
3061                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3062                 MIX(sc).name = "effect_send";
3063                 MIX(sc).nchan = 1;
3064                 MIX(sc).update[0] = 1;
3065                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3066                     "Effect Send DIn%d Volume", chy + 1);
3067
3068                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3069         }
3070 }
3071
3072 static void
3073 uaudio_mixer_reload_all(struct uaudio_softc *sc)
3074 {
3075         struct uaudio_mixer_node *pmc;
3076         int chan;
3077
3078         if (sc->sc_mixer_lock == NULL)
3079                 return;
3080
3081         mtx_lock(sc->sc_mixer_lock);
3082         for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
3083                 /* use reset defaults for non-oss controlled settings */
3084                 if (pmc->ctl == SOUND_MIXER_NRDEVICES)
3085                         continue;
3086                 for (chan = 0; chan < pmc->nchan; chan++)
3087                         pmc->update[chan / 8] |= (1 << (chan % 8));
3088         }
3089         usbd_transfer_start(sc->sc_mixer_xfer[0]);
3090
3091         /* start HID volume keys, if any */
3092         usbd_transfer_start(sc->sc_hid.xfer[0]);
3093         mtx_unlock(sc->sc_mixer_lock);
3094 }
3095
3096 static void
3097 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3098 {
3099         struct uaudio_mixer_node *p_mc_new =
3100             malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK);
3101         int ch;
3102
3103         if (p_mc_new != NULL) {
3104                 memcpy(p_mc_new, mc, sizeof(*p_mc_new));
3105                 p_mc_new->next = sc->sc_mixer_root;
3106                 sc->sc_mixer_root = p_mc_new;
3107                 sc->sc_mixer_count++;
3108
3109                 /* set default value for all channels */
3110                 for (ch = 0; ch < p_mc_new->nchan; ch++) {
3111                         switch (p_mc_new->val_default) {
3112                         case 1:
3113                                 /* 50% */
3114                                 p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2;
3115                                 break;
3116                         case 2:
3117                                 /* 100% */
3118                                 p_mc_new->wData[ch] = p_mc_new->maxval;
3119                                 break;
3120                         default:
3121                                 /* 0% */
3122                                 p_mc_new->wData[ch] = p_mc_new->minval;
3123                                 break;
3124                         }
3125                 }
3126         } else {
3127                 DPRINTF("out of memory\n");
3128         }
3129 }
3130
3131 static void
3132 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3133 {
3134         int32_t res;
3135
3136         if (mc->class < UAC_NCLASSES) {
3137                 DPRINTF("adding %s.%d\n",
3138                     uac_names[mc->class], mc->ctl);
3139         } else {
3140                 DPRINTF("adding %d\n", mc->ctl);
3141         }
3142
3143         if (mc->type == MIX_ON_OFF) {
3144                 mc->minval = 0;
3145                 mc->maxval = 1;
3146         } else if (mc->type == MIX_SELECTOR) {
3147         } else {
3148
3149                 /* determine min and max values */
3150
3151                 mc->minval = uaudio_mixer_get(sc->sc_udev,
3152                     sc->sc_audio_rev, GET_MIN, mc);
3153                 mc->maxval = uaudio_mixer_get(sc->sc_udev,
3154                     sc->sc_audio_rev, GET_MAX, mc);
3155
3156                 /* check if max and min was swapped */
3157
3158                 if (mc->maxval < mc->minval) {
3159                         res = mc->maxval;
3160                         mc->maxval = mc->minval;
3161                         mc->minval = res;
3162                 }
3163
3164                 /* compute value range */
3165                 mc->mul = mc->maxval - mc->minval;
3166                 if (mc->mul == 0)
3167                         mc->mul = 1;
3168
3169                 /* compute value alignment */
3170                 res = uaudio_mixer_get(sc->sc_udev,
3171                     sc->sc_audio_rev, GET_RES, mc);
3172
3173                 DPRINTF("Resolution = %d\n", (int)res);
3174         }
3175
3176         uaudio_mixer_add_ctl_sub(sc, mc);
3177
3178 #ifdef USB_DEBUG
3179         if (uaudio_debug > 2) {
3180                 uint8_t i;
3181
3182                 for (i = 0; i < mc->nchan; i++) {
3183                         DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]);
3184                 }
3185                 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' "
3186                     "min=%d max=%d\n",
3187                     mc->wIndex, mc->type, mc->ctl,
3188                     mc->minval, mc->maxval);
3189         }
3190 #endif
3191 }
3192
3193 static void
3194 uaudio_mixer_add_mixer(struct uaudio_softc *sc,
3195     const struct uaudio_terminal_node *iot, int id)
3196 {
3197         const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu_v1;
3198         const struct usb_audio_mixer_unit_1 *d1;
3199
3200         uint32_t bno;                   /* bit number */
3201         uint32_t p;                     /* bit number accumulator */
3202         uint32_t mo;                    /* matching outputs */
3203         uint32_t mc;                    /* matching channels */
3204         uint32_t ichs;                  /* input channels */
3205         uint32_t ochs;                  /* output channels */
3206         uint32_t c;
3207         uint32_t chs;                   /* channels */
3208         uint32_t i;
3209         uint32_t o;
3210
3211         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3212             d0->bUnitId, d0->bNrInPins);
3213
3214         /* compute the number of input channels */
3215
3216         ichs = 0;
3217         for (i = 0; i < d0->bNrInPins; i++) {
3218                 ichs += uaudio_mixer_get_cluster(
3219                     d0->baSourceId[i], iot).bNrChannels;
3220         }
3221
3222         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3223
3224         /* and the number of output channels */
3225
3226         ochs = d1->bNrChannels;
3227
3228         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3229
3230         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3231
3232         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3233         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3234         MIX(sc).type = MIX_SIGNED_16;
3235
3236         if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3237                 return;
3238
3239         for (p = i = 0; i < d0->bNrInPins; i++) {
3240                 chs = uaudio_mixer_get_cluster(
3241                     d0->baSourceId[i], iot).bNrChannels;
3242                 mc = 0;
3243                 for (c = 0; c < chs; c++) {
3244                         mo = 0;
3245                         for (o = 0; o < ochs; o++) {
3246                                 bno = ((p + c) * ochs) + o;
3247                                 if (BIT_TEST(d1->bmControls, bno))
3248                                         mo++;
3249                         }
3250                         if (mo == 1)
3251                                 mc++;
3252                 }
3253                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3254
3255                         /* repeat bit-scan */
3256
3257                         mc = 0;
3258                         for (c = 0; c < chs; c++) {
3259                                 for (o = 0; o < ochs; o++) {
3260                                         bno = ((p + c) * ochs) + o;
3261                                         if (BIT_TEST(d1->bmControls, bno))
3262                                                 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3263                                 }
3264                         }
3265                         MIX(sc).nchan = chs;
3266                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3267                 }
3268                 p += chs;
3269         }
3270 }
3271
3272 static void
3273 uaudio20_mixer_add_mixer(struct uaudio_softc *sc,
3274     const struct uaudio_terminal_node *iot, int id)
3275 {
3276         const struct usb_audio20_mixer_unit_0 *d0 = iot[id].u.mu_v2;
3277         const struct usb_audio20_mixer_unit_1 *d1;
3278
3279         uint32_t bno;                   /* bit number */
3280         uint32_t p;                     /* bit number accumulator */
3281         uint32_t mo;                    /* matching outputs */
3282         uint32_t mc;                    /* matching channels */
3283         uint32_t ichs;                  /* input channels */
3284         uint32_t ochs;                  /* output channels */
3285         uint32_t c;
3286         uint32_t chs;                   /* channels */
3287         uint32_t i;
3288         uint32_t o;
3289
3290         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3291             d0->bUnitId, d0->bNrInPins);
3292
3293         /* compute the number of input channels */
3294
3295         ichs = 0;
3296         for (i = 0; i < d0->bNrInPins; i++) {
3297                 ichs += uaudio20_mixer_get_cluster(
3298                     d0->baSourceId[i], iot).bNrChannels;
3299         }
3300
3301         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3302
3303         /* and the number of output channels */
3304
3305         ochs = d1->bNrChannels;
3306
3307         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3308
3309         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3310
3311         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3312         uaudio20_mixer_determine_class(&iot[id], &MIX(sc));
3313         MIX(sc).type = MIX_SIGNED_16;
3314
3315         if (uaudio20_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3316                 return;
3317
3318         for (p = i = 0; i < d0->bNrInPins; i++) {
3319                 chs = uaudio20_mixer_get_cluster(
3320                     d0->baSourceId[i], iot).bNrChannels;
3321                 mc = 0;
3322                 for (c = 0; c < chs; c++) {
3323                         mo = 0;
3324                         for (o = 0; o < ochs; o++) {
3325                                 bno = ((p + c) * ochs) + o;
3326                                 if (BIT_TEST(d1->bmControls, bno))
3327                                         mo++;
3328                         }
3329                         if (mo == 1)
3330                                 mc++;
3331                 }
3332                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3333
3334                         /* repeat bit-scan */
3335
3336                         mc = 0;
3337                         for (c = 0; c < chs; c++) {
3338                                 for (o = 0; o < ochs; o++) {
3339                                         bno = ((p + c) * ochs) + o;
3340                                         if (BIT_TEST(d1->bmControls, bno))
3341                                                 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3342                                 }
3343                         }
3344                         MIX(sc).nchan = chs;
3345                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3346                 }
3347                 p += chs;
3348         }
3349 }
3350
3351 static void
3352 uaudio_mixer_add_selector(struct uaudio_softc *sc,
3353     const struct uaudio_terminal_node *iot, int id)
3354 {
3355         const struct usb_audio_selector_unit *d = iot[id].u.su_v1;
3356         uint16_t i;
3357
3358         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3359             d->bUnitId, d->bNrInPins);
3360
3361         if (d->bNrInPins == 0)
3362                 return;
3363
3364         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3365
3366         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3367         MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3368         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3369         MIX(sc).nchan = 1;
3370         MIX(sc).type = MIX_SELECTOR;
3371         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3372         MIX(sc).minval = 1;
3373         MIX(sc).maxval = d->bNrInPins;
3374         MIX(sc).name = "selector";
3375
3376         i = d->baSourceId[d->bNrInPins];
3377         if (i == 0 ||
3378             usbd_req_get_string_any(sc->sc_udev, NULL,
3379             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3380                 MIX(sc).desc[0] = 0;
3381         }
3382
3383         if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN) {
3384                 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3385         }
3386         MIX(sc).mul = (MIX(sc).maxval - MIX(sc).minval);
3387         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) {
3388                 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3389         }
3390
3391         for (i = 0; i < MIX(sc).maxval; i++) {
3392                 MIX(sc).slctrtype[i] = uaudio_mixer_feature_name(
3393                     &iot[d->baSourceId[i]], &MIX(sc));
3394         }
3395
3396         MIX(sc).class = 0;                      /* not used */
3397
3398         uaudio_mixer_add_ctl(sc, &MIX(sc));
3399 }
3400
3401 static void
3402 uaudio20_mixer_add_selector(struct uaudio_softc *sc,
3403     const struct uaudio_terminal_node *iot, int id)
3404 {
3405         const struct usb_audio20_selector_unit *d = iot[id].u.su_v2;
3406         uint16_t i;
3407
3408         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3409             d->bUnitId, d->bNrInPins);
3410
3411         if (d->bNrInPins == 0)
3412                 return;
3413
3414         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3415
3416         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3417         MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3418         uaudio20_mixer_determine_class(&iot[id], &MIX(sc));
3419         MIX(sc).nchan = 1;
3420         MIX(sc).type = MIX_SELECTOR;
3421         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3422         MIX(sc).minval = 1;
3423         MIX(sc).maxval = d->bNrInPins;
3424         MIX(sc).name = "selector";
3425
3426         i = d->baSourceId[d->bNrInPins];
3427         if (i == 0 ||
3428             usbd_req_get_string_any(sc->sc_udev, NULL,
3429             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3430                 MIX(sc).desc[0] = 0;
3431         }
3432
3433         if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3434                 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3435
3436         MIX(sc).mul = (MIX(sc).maxval - MIX(sc).minval);
3437         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++)
3438                 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3439
3440         for (i = 0; i < MIX(sc).maxval; i++) {
3441                 MIX(sc).slctrtype[i] = uaudio20_mixer_feature_name(
3442                     &iot[d->baSourceId[i]], &MIX(sc));
3443         }
3444
3445         MIX(sc).class = 0;                      /* not used */
3446
3447         uaudio_mixer_add_ctl(sc, &MIX(sc));
3448 }
3449
3450 static uint32_t
3451 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d,
3452     uint8_t i)
3453 {
3454         uint32_t temp = 0;
3455         uint32_t offset = (i * d->bControlSize);
3456
3457         if (d->bControlSize > 0) {
3458                 temp |= d->bmaControls[offset];
3459                 if (d->bControlSize > 1) {
3460                         temp |= d->bmaControls[offset + 1] << 8;
3461                         if (d->bControlSize > 2) {
3462                                 temp |= d->bmaControls[offset + 2] << 16;
3463                                 if (d->bControlSize > 3) {
3464                                         temp |= d->bmaControls[offset + 3] << 24;
3465                                 }
3466                         }
3467                 }
3468         }
3469         return (temp);
3470 }
3471
3472 static void
3473 uaudio_mixer_add_feature(struct uaudio_softc *sc,
3474     const struct uaudio_terminal_node *iot, int id)
3475 {
3476         const struct usb_audio_feature_unit *d = iot[id].u.fu_v1;
3477         uint32_t fumask;
3478         uint32_t mmask;
3479         uint32_t cmask;
3480         uint16_t mixernumber;
3481         uint8_t nchan;
3482         uint8_t chan;
3483         uint8_t ctl;
3484         uint8_t i;
3485
3486         if (d->bControlSize == 0)
3487                 return;
3488
3489         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3490
3491         nchan = (d->bLength - 7) / d->bControlSize;
3492         mmask = uaudio_mixer_feature_get_bmaControls(d, 0);
3493         cmask = 0;
3494
3495         if (nchan == 0)
3496                 return;
3497
3498         /* figure out what we can control */
3499
3500         for (chan = 1; chan < nchan; chan++) {
3501                 DPRINTFN(10, "chan=%d mask=%x\n",
3502                     chan, uaudio_mixer_feature_get_bmaControls(d, chan));
3503
3504                 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan);
3505         }
3506
3507         if (nchan > MIX_MAX_CHAN) {
3508                 nchan = MIX_MAX_CHAN;
3509         }
3510         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3511
3512         i = d->bmaControls[d->bControlSize];
3513         if (i == 0 ||
3514             usbd_req_get_string_any(sc->sc_udev, NULL,
3515             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3516                 MIX(sc).desc[0] = 0;
3517         }
3518
3519         for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) {
3520
3521                 fumask = FU_MASK(ctl);
3522
3523                 DPRINTFN(5, "ctl=%d fumask=0x%04x\n",
3524                     ctl, fumask);
3525
3526                 if (mmask & fumask) {
3527                         MIX(sc).nchan = 1;
3528                         MIX(sc).wValue[0] = MAKE_WORD(ctl, 0);
3529                 } else if (cmask & fumask) {
3530                         MIX(sc).nchan = nchan - 1;
3531                         for (i = 1; i < nchan; i++) {
3532                                 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask)
3533                                         MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i);
3534                                 else
3535                                         MIX(sc).wValue[i - 1] = -1;
3536                         }
3537                 } else {
3538                         continue;
3539                 }
3540
3541                 mixernumber = uaudio_mixer_feature_name(&iot[id], &MIX(sc));
3542
3543                 switch (ctl) {
3544                 case MUTE_CONTROL:
3545                         MIX(sc).type = MIX_ON_OFF;
3546                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3547                         MIX(sc).name = "mute";
3548                         break;
3549
3550                 case VOLUME_CONTROL:
3551                         MIX(sc).type = MIX_SIGNED_16;
3552                         MIX(sc).ctl = mixernumber;
3553                         MIX(sc).name = "vol";
3554                         break;
3555
3556                 case BASS_CONTROL:
3557                         MIX(sc).type = MIX_SIGNED_8;
3558                         MIX(sc).ctl = SOUND_MIXER_BASS;
3559                         MIX(sc).name = "bass";
3560                         break;
3561
3562                 case MID_CONTROL:
3563                         MIX(sc).type = MIX_SIGNED_8;
3564                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3565                         MIX(sc).name = "mid";
3566                         break;
3567
3568                 case TREBLE_CONTROL:
3569                         MIX(sc).type = MIX_SIGNED_8;
3570                         MIX(sc).ctl = SOUND_MIXER_TREBLE;
3571                         MIX(sc).name = "treble";
3572                         break;
3573
3574                 case GRAPHIC_EQUALIZER_CONTROL:
3575                         continue;       /* XXX don't add anything */
3576
3577                 case AGC_CONTROL:
3578                         MIX(sc).type = MIX_ON_OFF;
3579                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3580                         MIX(sc).name = "agc";
3581                         break;
3582
3583                 case DELAY_CONTROL:
3584                         MIX(sc).type = MIX_UNSIGNED_16;
3585                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3586                         MIX(sc).name = "delay";
3587                         break;
3588
3589                 case BASS_BOOST_CONTROL:
3590                         MIX(sc).type = MIX_ON_OFF;
3591                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3592                         MIX(sc).name = "boost";
3593                         break;
3594
3595                 case LOUDNESS_CONTROL:
3596                         MIX(sc).type = MIX_ON_OFF;
3597                         MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3598                         MIX(sc).name = "loudness";
3599                         break;
3600
3601                 default:
3602                         MIX(sc).type = MIX_UNKNOWN;
3603                         break;
3604                 }
3605
3606                 if (MIX(sc).type != MIX_UNKNOWN)
3607                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3608         }
3609 }
3610
3611 static void
3612 uaudio20_mixer_add_feature(struct uaudio_softc *sc,
3613     const struct uaudio_terminal_node *iot, int id)
3614 {
3615         const struct usb_audio20_feature_unit *d = iot[id].u.fu_v2;
3616         uint32_t ctl;
3617         uint32_t mmask;
3618         uint32_t cmask;
3619         uint16_t mixernumber;
3620         uint8_t nchan;
3621         uint8_t chan;
3622         uint8_t i;
3623         uint8_t what;
3624
3625         if (UGETDW(d->bmaControls[0]) == 0)
3626                 return;
3627
3628         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3629
3630         nchan = (d->bLength - 6) / 4;
3631         mmask = UGETDW(d->bmaControls[0]);
3632         cmask = 0;
3633
3634         if (nchan == 0)
3635                 return;
3636
3637         /* figure out what we can control */
3638
3639         for (chan = 1; chan < nchan; chan++)
3640                 cmask |= UGETDW(d->bmaControls[chan]);
3641
3642         if (nchan > MIX_MAX_CHAN)
3643                 nchan = MIX_MAX_CHAN;
3644
3645         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3646
3647         i = d->bmaControls[nchan][0];
3648         if (i == 0 ||
3649             usbd_req_get_string_any(sc->sc_udev, NULL,
3650             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3651                 MIX(sc).desc[0] = 0;
3652         }
3653
3654         for (ctl = 3; ctl != 0; ctl <<= 2) {
3655
3656                 mixernumber = uaudio20_mixer_feature_name(&iot[id], &MIX(sc));
3657
3658                 switch (ctl) {
3659                 case (3 << 0):
3660                         MIX(sc).type = MIX_ON_OFF;
3661                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3662                         MIX(sc).name = "mute";
3663                         what = MUTE_CONTROL;
3664                         break;
3665                 case (3 << 2):
3666                         MIX(sc).type = MIX_SIGNED_16;
3667                         MIX(sc).ctl = mixernumber;
3668                         MIX(sc).name = "vol";
3669                         what = VOLUME_CONTROL;
3670                         break;
3671                 case (3 << 4):
3672                         MIX(sc).type = MIX_SIGNED_8;
3673                         MIX(sc).ctl = SOUND_MIXER_BASS;
3674                         MIX(sc).name = "bass";
3675                         what = BASS_CONTROL;
3676                         break;
3677                 case (3 << 6):
3678                         MIX(sc).type = MIX_SIGNED_8;
3679                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3680                         MIX(sc).name = "mid";
3681                         what = MID_CONTROL;
3682                         break;
3683                 case (3 << 8):
3684                         MIX(sc).type = MIX_SIGNED_8;
3685                         MIX(sc).ctl = SOUND_MIXER_TREBLE;
3686                         MIX(sc).name = "treble";
3687                         what = TREBLE_CONTROL;
3688                         break;
3689                 case (3 << 12):
3690                         MIX(sc).type = MIX_ON_OFF;
3691                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3692                         MIX(sc).name = "agc";
3693                         what = AGC_CONTROL;
3694                         break;
3695                 case (3 << 14):
3696                         MIX(sc).type = MIX_UNSIGNED_16;
3697                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3698                         MIX(sc).name = "delay";
3699                         what = DELAY_CONTROL;
3700                         break;
3701                 case (3 << 16):
3702                         MIX(sc).type = MIX_ON_OFF;
3703                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3704                         MIX(sc).name = "boost";
3705                         what = BASS_BOOST_CONTROL;
3706                         break;
3707                 case (3 << 18):
3708                         MIX(sc).type = MIX_ON_OFF;
3709                         MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3710                         MIX(sc).name = "loudness";
3711                         what = LOUDNESS_CONTROL;
3712                         break;
3713                 case (3 << 20):
3714                         MIX(sc).type = MIX_SIGNED_16;
3715                         MIX(sc).ctl = mixernumber;
3716                         MIX(sc).name = "igain";
3717                         what = INPUT_GAIN_CONTROL;
3718                         break;
3719                 case (3 << 22):
3720                         MIX(sc).type = MIX_SIGNED_16;
3721                         MIX(sc).ctl = mixernumber;
3722                         MIX(sc).name = "igainpad";
3723                         what = INPUT_GAIN_PAD_CONTROL;
3724                         break;
3725                 default:
3726                         continue;
3727                 }
3728
3729                 if ((mmask & ctl) == ctl) {
3730                         MIX(sc).nchan = 1;
3731                         MIX(sc).wValue[0] = MAKE_WORD(what, 0);
3732                 } else if ((cmask & ctl) == ctl) {
3733                         MIX(sc).nchan = nchan - 1;
3734                         for (i = 1; i < nchan; i++) {
3735                                 if ((UGETDW(d->bmaControls[i]) & ctl) == ctl)
3736                                         MIX(sc).wValue[i - 1] = MAKE_WORD(what, i);
3737                                 else
3738                                         MIX(sc).wValue[i - 1] = -1;
3739                         }
3740                 } else {
3741                         continue;
3742                 }
3743
3744                 if (MIX(sc).type != MIX_UNKNOWN)
3745                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3746         }
3747 }
3748
3749 static void
3750 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc,
3751     const struct uaudio_terminal_node *iot, int id)
3752 {
3753         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3754         const struct usb_audio_processing_unit_1 *d1 =
3755             (const void *)(d0->baSourceId + d0->bNrInPins);
3756         const struct usb_audio_processing_unit_updown *ud =
3757             (const void *)(d1->bmControls + d1->bControlSize);
3758         uint8_t i;
3759
3760         if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) {
3761                 return;
3762         }
3763         if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes))
3764             == NULL) {
3765                 return;
3766         }
3767         DPRINTFN(3, "bUnitId=%d bNrModes=%d\n",
3768             d0->bUnitId, ud->bNrModes);
3769
3770         if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
3771                 DPRINTF("no mode select\n");
3772                 return;
3773         }
3774         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3775
3776         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3777         MIX(sc).nchan = 1;
3778         MIX(sc).wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0);
3779         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3780         MIX(sc).type = MIX_ON_OFF;              /* XXX */
3781
3782         for (i = 0; i < ud->bNrModes; i++) {
3783                 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i]));
3784                 /* XXX */
3785         }
3786
3787         uaudio_mixer_add_ctl(sc, &MIX(sc));
3788 }
3789
3790 static void
3791 uaudio_mixer_add_processing(struct uaudio_softc *sc,
3792     const struct uaudio_terminal_node *iot, int id)
3793 {
3794         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3795         const struct usb_audio_processing_unit_1 *d1 =
3796             (const void *)(d0->baSourceId + d0->bNrInPins);
3797         uint16_t ptype;
3798
3799         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3800
3801         ptype = UGETW(d0->wProcessType);
3802
3803         DPRINTFN(3, "wProcessType=%d bUnitId=%d "
3804             "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins);
3805
3806         if (d1->bControlSize == 0) {
3807                 return;
3808         }
3809         if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
3810                 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3811                 MIX(sc).nchan = 1;
3812                 MIX(sc).wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0);
3813                 uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3814                 MIX(sc).type = MIX_ON_OFF;
3815                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3816         }
3817         switch (ptype) {
3818         case UPDOWNMIX_PROCESS:
3819                 uaudio_mixer_add_processing_updown(sc, iot, id);
3820                 break;
3821
3822         case DOLBY_PROLOGIC_PROCESS:
3823         case P3D_STEREO_EXTENDER_PROCESS:
3824         case REVERBATION_PROCESS:
3825         case CHORUS_PROCESS:
3826         case DYN_RANGE_COMP_PROCESS:
3827         default:
3828                 DPRINTF("unit %d, type=%d is not implemented\n",
3829                     d0->bUnitId, ptype);
3830                 break;
3831         }
3832 }
3833
3834 static void
3835 uaudio_mixer_add_extension(struct uaudio_softc *sc,
3836     const struct uaudio_terminal_node *iot, int id)
3837 {
3838         const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu_v1;
3839         const struct usb_audio_extension_unit_1 *d1 =
3840             (const void *)(d0->baSourceId + d0->bNrInPins);
3841
3842         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3843             d0->bUnitId, d0->bNrInPins);
3844
3845         if (sc->sc_uq_au_no_xu) {
3846                 return;
3847         }
3848         if (d1->bControlSize == 0) {
3849                 return;
3850         }
3851         if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
3852
3853                 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3854
3855                 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3856                 MIX(sc).nchan = 1;
3857                 MIX(sc).wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0);
3858                 uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3859                 MIX(sc).type = MIX_ON_OFF;
3860
3861                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3862         }
3863 }
3864
3865 static const void *
3866 uaudio_mixer_verify_desc(const void *arg, uint32_t len)
3867 {
3868         const struct usb_audio_mixer_unit_1 *d1;
3869         const struct usb_audio_extension_unit_1 *e1;
3870         const struct usb_audio_processing_unit_1 *u1;
3871
3872         union {
3873                 const struct usb_descriptor *desc;
3874                 const struct usb_audio_input_terminal *it;
3875                 const struct usb_audio_output_terminal *ot;
3876                 const struct usb_audio_mixer_unit_0 *mu;
3877                 const struct usb_audio_selector_unit *su;
3878                 const struct usb_audio_feature_unit *fu;
3879                 const struct usb_audio_processing_unit_0 *pu;
3880                 const struct usb_audio_extension_unit_0 *eu;
3881         }     u;
3882
3883         u.desc = arg;
3884
3885         if (u.desc == NULL) {
3886                 goto error;
3887         }
3888         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) {
3889                 goto error;
3890         }
3891         switch (u.desc->bDescriptorSubtype) {
3892         case UDESCSUB_AC_INPUT:
3893                 len += sizeof(*u.it);
3894                 break;
3895
3896         case UDESCSUB_AC_OUTPUT:
3897                 len += sizeof(*u.ot);
3898                 break;
3899
3900         case UDESCSUB_AC_MIXER:
3901                 len += sizeof(*u.mu);
3902
3903                 if (u.desc->bLength < len) {
3904                         goto error;
3905                 }
3906                 len += u.mu->bNrInPins;
3907
3908                 if (u.desc->bLength < len) {
3909                         goto error;
3910                 }
3911                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
3912
3913                 len += sizeof(*d1);
3914                 break;
3915
3916         case UDESCSUB_AC_SELECTOR:
3917                 len += sizeof(*u.su);
3918
3919                 if (u.desc->bLength < len) {
3920                         goto error;
3921                 }
3922                 len += u.su->bNrInPins + 1;
3923                 break;
3924
3925         case UDESCSUB_AC_FEATURE:
3926                 len += sizeof(*u.fu) + 1;
3927
3928                 if (u.desc->bLength < len)
3929                         goto error;
3930
3931                 len += u.fu->bControlSize;
3932                 break;
3933
3934         case UDESCSUB_AC_PROCESSING:
3935                 len += sizeof(*u.pu);
3936
3937                 if (u.desc->bLength < len) {
3938                         goto error;
3939                 }
3940                 len += u.pu->bNrInPins;
3941
3942                 if (u.desc->bLength < len) {
3943                         goto error;
3944                 }
3945                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
3946
3947                 len += sizeof(*u1);
3948
3949                 if (u.desc->bLength < len) {
3950                         goto error;
3951                 }
3952                 len += u1->bControlSize;
3953
3954                 break;
3955
3956         case UDESCSUB_AC_EXTENSION:
3957                 len += sizeof(*u.eu);
3958
3959                 if (u.desc->bLength < len) {
3960                         goto error;
3961                 }
3962                 len += u.eu->bNrInPins;
3963
3964                 if (u.desc->bLength < len) {
3965                         goto error;
3966                 }
3967                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
3968
3969                 len += sizeof(*e1);
3970
3971                 if (u.desc->bLength < len) {
3972                         goto error;
3973                 }
3974                 len += e1->bControlSize;
3975                 break;
3976
3977         default:
3978                 goto error;
3979         }
3980
3981         if (u.desc->bLength < len) {
3982                 goto error;
3983         }
3984         return (u.desc);
3985
3986 error:
3987         if (u.desc) {
3988                 DPRINTF("invalid descriptor, type=%d, "
3989                     "sub_type=%d, len=%d of %d bytes\n",
3990                     u.desc->bDescriptorType,
3991                     u.desc->bDescriptorSubtype,
3992                     u.desc->bLength, len);
3993         }
3994         return (NULL);
3995 }
3996
3997 static const void *
3998 uaudio20_mixer_verify_desc(const void *arg, uint32_t len)
3999 {
4000         const struct usb_audio20_mixer_unit_1 *d1;
4001         const struct usb_audio20_extension_unit_1 *e1;
4002         const struct usb_audio20_processing_unit_1 *u1;
4003         const struct usb_audio20_clock_selector_unit_1 *c1;
4004
4005         union {
4006                 const struct usb_descriptor *desc;
4007                 const struct usb_audio20_clock_source_unit *csrc;
4008                 const struct usb_audio20_clock_selector_unit_0 *csel;
4009                 const struct usb_audio20_clock_multiplier_unit *cmul;
4010                 const struct usb_audio20_input_terminal *it;
4011                 const struct usb_audio20_output_terminal *ot;
4012                 const struct usb_audio20_mixer_unit_0 *mu;
4013                 const struct usb_audio20_selector_unit *su;
4014                 const struct usb_audio20_feature_unit *fu;
4015                 const struct usb_audio20_sample_rate_unit *ru;
4016                 const struct usb_audio20_processing_unit_0 *pu;
4017                 const struct usb_audio20_extension_unit_0 *eu;
4018                 const struct usb_audio20_effect_unit *ef;
4019         }     u;
4020
4021         u.desc = arg;
4022
4023         if (u.desc == NULL)
4024                 goto error;
4025
4026         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE)
4027                 goto error;
4028
4029         switch (u.desc->bDescriptorSubtype) {
4030         case UDESCSUB_AC_INPUT:
4031                 len += sizeof(*u.it);
4032                 break;
4033
4034         case UDESCSUB_AC_OUTPUT:
4035                 len += sizeof(*u.ot);
4036                 break;
4037
4038         case UDESCSUB_AC_MIXER:
4039                 len += sizeof(*u.mu);
4040
4041                 if (u.desc->bLength < len)
4042                         goto error;
4043                 len += u.mu->bNrInPins;
4044
4045                 if (u.desc->bLength < len)
4046                         goto error;
4047
4048                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4049
4050                 len += sizeof(*d1) + d1->bNrChannels;
4051                 break;
4052
4053         case UDESCSUB_AC_SELECTOR:
4054                 len += sizeof(*u.su);
4055
4056                 if (u.desc->bLength < len)
4057                         goto error;
4058
4059                 len += u.su->bNrInPins + 1;
4060                 break;
4061
4062         case UDESCSUB_AC_FEATURE:
4063                 len += sizeof(*u.fu) + 1;
4064                 break;
4065
4066         case UDESCSUB_AC_EFFECT:
4067                 len += sizeof(*u.ef) + 4;
4068                 break;
4069
4070         case UDESCSUB_AC_PROCESSING_V2:
4071                 len += sizeof(*u.pu);
4072
4073                 if (u.desc->bLength < len)
4074                         goto error;
4075
4076                 len += u.pu->bNrInPins;
4077
4078                 if (u.desc->bLength < len)
4079                         goto error;
4080
4081                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4082
4083                 len += sizeof(*u1);
4084                 break;
4085
4086         case UDESCSUB_AC_EXTENSION_V2:
4087                 len += sizeof(*u.eu);
4088
4089                 if (u.desc->bLength < len)
4090                         goto error;
4091
4092                 len += u.eu->bNrInPins;
4093
4094                 if (u.desc->bLength < len)
4095                         goto error;
4096
4097                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4098
4099                 len += sizeof(*e1);
4100                 break;
4101
4102         case UDESCSUB_AC_CLOCK_SRC:
4103                 len += sizeof(*u.csrc);
4104                 break;
4105
4106         case UDESCSUB_AC_CLOCK_SEL:
4107                 len += sizeof(*u.csel);
4108
4109                 if (u.desc->bLength < len)
4110                         goto error;
4111
4112                 len += u.csel->bNrInPins;
4113
4114                 if (u.desc->bLength < len)
4115                         goto error;
4116
4117                 c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins);
4118
4119                 len += sizeof(*c1);
4120                 break;
4121
4122         case UDESCSUB_AC_CLOCK_MUL:
4123                 len += sizeof(*u.cmul);
4124                 break;
4125
4126         case UDESCSUB_AC_SAMPLE_RT:
4127                 len += sizeof(*u.ru);
4128                 break;
4129
4130         default:
4131                 goto error;
4132         }
4133
4134         if (u.desc->bLength < len)
4135                 goto error;
4136
4137         return (u.desc);
4138
4139 error:
4140         if (u.desc) {
4141                 DPRINTF("invalid descriptor, type=%d, "
4142                     "sub_type=%d, len=%d of %d bytes\n",
4143                     u.desc->bDescriptorType,
4144                     u.desc->bDescriptorSubtype,
4145                     u.desc->bLength, len);
4146         }
4147         return (NULL);
4148 }
4149
4150 static struct usb_audio_cluster
4151 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4152 {
4153         struct usb_audio_cluster r;
4154         const struct usb_descriptor *dp;
4155         uint8_t i;
4156
4157         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
4158                 dp = iot[id].u.desc;
4159                 if (dp == NULL) {
4160                         goto error;
4161                 }
4162                 switch (dp->bDescriptorSubtype) {
4163                 case UDESCSUB_AC_INPUT:
4164                         r.bNrChannels = iot[id].u.it_v1->bNrChannels;
4165                         r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0];
4166                         r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1];
4167                         r.iChannelNames = iot[id].u.it_v1->iChannelNames;
4168                         goto done;
4169
4170                 case UDESCSUB_AC_OUTPUT:
4171                         id = iot[id].u.ot_v1->bSourceId;
4172                         break;
4173
4174                 case UDESCSUB_AC_MIXER:
4175                         r = *(const struct usb_audio_cluster *)
4176                             &iot[id].u.mu_v1->baSourceId[
4177                             iot[id].u.mu_v1->bNrInPins];
4178                         goto done;
4179
4180                 case UDESCSUB_AC_SELECTOR:
4181                         if (iot[id].u.su_v1->bNrInPins > 0) {
4182                                 /* XXX This is not really right */
4183                                 id = iot[id].u.su_v1->baSourceId[0];
4184                         }
4185                         break;
4186
4187                 case UDESCSUB_AC_FEATURE:
4188                         id = iot[id].u.fu_v1->bSourceId;
4189                         break;
4190
4191                 case UDESCSUB_AC_PROCESSING:
4192                         r = *((const struct usb_audio_cluster *)
4193                             &iot[id].u.pu_v1->baSourceId[
4194                             iot[id].u.pu_v1->bNrInPins]);
4195                         goto done;
4196
4197                 case UDESCSUB_AC_EXTENSION:
4198                         r = *((const struct usb_audio_cluster *)
4199                             &iot[id].u.eu_v1->baSourceId[
4200                             iot[id].u.eu_v1->bNrInPins]);
4201                         goto done;
4202
4203                 default:
4204                         goto error;
4205                 }
4206         }
4207 error:
4208         DPRINTF("bad data\n");
4209         memset(&r, 0, sizeof(r));
4210 done:
4211         return (r);
4212 }
4213
4214 static struct usb_audio20_cluster
4215 uaudio20_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4216 {
4217         struct usb_audio20_cluster r;
4218         const struct usb_descriptor *dp;
4219         uint8_t i;
4220
4221         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
4222                 dp = iot[id].u.desc;
4223                 if (dp == NULL)
4224                         goto error;
4225
4226                 switch (dp->bDescriptorSubtype) {
4227                 case UDESCSUB_AC_INPUT:
4228                         r.bNrChannels = iot[id].u.it_v2->bNrChannels;
4229                         r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0];
4230                         r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1];
4231                         r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2];
4232                         r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3];
4233                         r.iChannelNames = iot[id].u.it_v2->iTerminal;
4234                         goto done;
4235
4236                 case UDESCSUB_AC_OUTPUT:
4237                         id = iot[id].u.ot_v2->bSourceId;
4238                         break;
4239
4240                 case UDESCSUB_AC_MIXER:
4241                         r = *(const struct usb_audio20_cluster *)
4242                             &iot[id].u.mu_v2->baSourceId[
4243                             iot[id].u.mu_v2->bNrInPins];
4244                         goto done;
4245
4246                 case UDESCSUB_AC_SELECTOR:
4247                         if (iot[id].u.su_v2->bNrInPins > 0) {
4248                                 /* XXX This is not really right */
4249                                 id = iot[id].u.su_v2->baSourceId[0];
4250                         }
4251                         break;
4252
4253                 case UDESCSUB_AC_SAMPLE_RT:
4254                         id = iot[id].u.ru_v2->bSourceId;
4255                         break;
4256
4257                 case UDESCSUB_AC_EFFECT:
4258                         id = iot[id].u.ef_v2->bSourceId;
4259                         break;
4260
4261                 case UDESCSUB_AC_FEATURE:
4262                         id = iot[id].u.fu_v2->bSourceId;
4263                         break;
4264
4265                 case UDESCSUB_AC_PROCESSING_V2:
4266                         r = *((const struct usb_audio20_cluster *)
4267                             &iot[id].u.pu_v2->baSourceId[
4268                             iot[id].u.pu_v2->bNrInPins]);
4269                         goto done;
4270
4271                 case UDESCSUB_AC_EXTENSION_V2:
4272                         r = *((const struct usb_audio20_cluster *)
4273                             &iot[id].u.eu_v2->baSourceId[
4274                             iot[id].u.eu_v2->bNrInPins]);
4275                         goto done;
4276
4277                 default:
4278                         goto error;
4279                 }
4280         }
4281 error:
4282         DPRINTF("Bad data!\n");
4283         memset(&r, 0, sizeof(r));
4284 done:
4285         return (r);
4286 }
4287
4288 static uint16_t
4289 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot,
4290     struct uaudio_mixer_node *mix)
4291 {
4292         uint16_t terminal_type = 0x0000;
4293         const struct uaudio_terminal_node *input[2];
4294         const struct uaudio_terminal_node *output[2];
4295
4296         input[0] = uaudio_mixer_get_input(iot, 0);
4297         input[1] = uaudio_mixer_get_input(iot, 1);
4298
4299         output[0] = uaudio_mixer_get_output(iot, 0);
4300         output[1] = uaudio_mixer_get_output(iot, 1);
4301
4302         /*
4303          * check if there is only
4304          * one output terminal:
4305          */
4306         if (output[0] && (!output[1])) {
4307                 terminal_type =
4308                     UGETW(output[0]->u.ot_v1->wTerminalType);
4309         }
4310         /*
4311          * If the only output terminal is USB,
4312          * the class is UAC_RECORD.
4313          */
4314         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
4315
4316                 mix->class = UAC_RECORD;
4317                 if (input[0] && (!input[1])) {
4318                         terminal_type =
4319                             UGETW(input[0]->u.it_v1->wTerminalType);
4320                 } else {
4321                         terminal_type = 0;
4322                 }
4323                 goto done;
4324         }
4325         /*
4326          * if the unit is connected to just
4327          * one input terminal, the
4328          * class is UAC_INPUT:
4329          */
4330         if (input[0] && (!input[1])) {
4331                 mix->class = UAC_INPUT;
4332                 terminal_type =
4333                     UGETW(input[0]->u.it_v1->wTerminalType);
4334                 goto done;
4335         }
4336         /*
4337          * Otherwise, the class is UAC_OUTPUT.
4338          */
4339         mix->class = UAC_OUTPUT;
4340 done:
4341         return (terminal_type);
4342 }
4343
4344 static uint16_t
4345 uaudio20_mixer_determine_class(const struct uaudio_terminal_node *iot,
4346     struct uaudio_mixer_node *mix)
4347 {
4348         uint16_t terminal_type = 0x0000;
4349         const struct uaudio_terminal_node *input[2];
4350         const struct uaudio_terminal_node *output[2];
4351
4352         input[0] = uaudio_mixer_get_input(iot, 0);
4353         input[1] = uaudio_mixer_get_input(iot, 1);
4354
4355         output[0] = uaudio_mixer_get_output(iot, 0);
4356         output[1] = uaudio_mixer_get_output(iot, 1);
4357
4358         /*
4359          * check if there is only
4360          * one output terminal:
4361          */
4362         if (output[0] && (!output[1]))
4363                 terminal_type = UGETW(output[0]->u.ot_v2->wTerminalType);
4364         /*
4365          * If the only output terminal is USB,
4366          * the class is UAC_RECORD.
4367          */
4368         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
4369
4370                 mix->class = UAC_RECORD;
4371                 if (input[0] && (!input[1])) {
4372                         terminal_type =
4373                             UGETW(input[0]->u.it_v2->wTerminalType);
4374                 } else {
4375                         terminal_type = 0;
4376                 }
4377                 goto done;
4378         }
4379         /*
4380          * if the unit is connected to just
4381          * one input terminal, the
4382          * class is UAC_INPUT:
4383          */
4384         if (input[0] && (!input[1])) {
4385                 mix->class = UAC_INPUT;
4386                 terminal_type =
4387                     UGETW(input[0]->u.it_v2->wTerminalType);
4388                 goto done;
4389         }
4390         /*
4391          * Otherwise, the class is UAC_OUTPUT.
4392          */
4393         mix->class = UAC_OUTPUT;
4394 done:
4395         return (terminal_type);
4396 }
4397
4398 struct uaudio_tt_to_feature {
4399         uint16_t terminal_type;
4400         uint16_t feature;
4401 };
4402
4403 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = {
4404
4405         {UAT_STREAM, SOUND_MIXER_PCM},
4406
4407         {UATI_MICROPHONE, SOUND_MIXER_MIC},
4408         {UATI_DESKMICROPHONE, SOUND_MIXER_MIC},
4409         {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC},
4410         {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC},
4411         {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC},
4412         {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC},
4413
4414         {UATO_SPEAKER, SOUND_MIXER_SPEAKER},
4415         {UATO_DESKTOPSPEAKER, SOUND_MIXER_SPEAKER},
4416         {UATO_ROOMSPEAKER, SOUND_MIXER_SPEAKER},
4417         {UATO_COMMSPEAKER, SOUND_MIXER_SPEAKER},
4418
4419         {UATE_ANALOGCONN, SOUND_MIXER_LINE},
4420         {UATE_LINECONN, SOUND_MIXER_LINE},
4421         {UATE_LEGACYCONN, SOUND_MIXER_LINE},
4422
4423         {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM},
4424         {UATE_SPDIF, SOUND_MIXER_ALTPCM},
4425         {UATE_1394DA, SOUND_MIXER_ALTPCM},
4426         {UATE_1394DV, SOUND_MIXER_ALTPCM},
4427
4428         {UATF_CDPLAYER, SOUND_MIXER_CD},
4429
4430         {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH},
4431
4432         {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO},
4433         {UATF_DVDAUDIO, SOUND_MIXER_VIDEO},
4434         {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO},
4435
4436         /* telephony terminal types */
4437         {UATT_UNDEFINED, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4438         {UATT_PHONELINE, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4439         {UATT_TELEPHONE, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4440         {UATT_DOWNLINEPHONE, SOUND_MIXER_PHONEIN},      /* SOUND_MIXER_PHONEOUT */
4441
4442         {UATF_RADIORECV, SOUND_MIXER_RADIO},
4443         {UATF_RADIOXMIT, SOUND_MIXER_RADIO},
4444
4445         {UAT_UNDEFINED, SOUND_MIXER_VOLUME},
4446         {UAT_VENDOR, SOUND_MIXER_VOLUME},
4447         {UATI_UNDEFINED, SOUND_MIXER_VOLUME},
4448
4449         /* output terminal types */
4450         {UATO_UNDEFINED, SOUND_MIXER_VOLUME},
4451         {UATO_DISPLAYAUDIO, SOUND_MIXER_VOLUME},
4452         {UATO_SUBWOOFER, SOUND_MIXER_VOLUME},
4453         {UATO_HEADPHONES, SOUND_MIXER_VOLUME},
4454
4455         /* bidir terminal types */
4456         {UATB_UNDEFINED, SOUND_MIXER_VOLUME},
4457         {UATB_HANDSET, SOUND_MIXER_VOLUME},
4458         {UATB_HEADSET, SOUND_MIXER_VOLUME},
4459         {UATB_SPEAKERPHONE, SOUND_MIXER_VOLUME},
4460         {UATB_SPEAKERPHONEESUP, SOUND_MIXER_VOLUME},
4461         {UATB_SPEAKERPHONEECANC, SOUND_MIXER_VOLUME},
4462
4463         /* external terminal types */
4464         {UATE_UNDEFINED, SOUND_MIXER_VOLUME},
4465
4466         /* embedded function terminal types */
4467         {UATF_UNDEFINED, SOUND_MIXER_VOLUME},
4468         {UATF_CALIBNOISE, SOUND_MIXER_VOLUME},
4469         {UATF_EQUNOISE, SOUND_MIXER_VOLUME},
4470         {UATF_DAT, SOUND_MIXER_VOLUME},
4471         {UATF_DCC, SOUND_MIXER_VOLUME},
4472         {UATF_MINIDISK, SOUND_MIXER_VOLUME},
4473         {UATF_ANALOGTAPE, SOUND_MIXER_VOLUME},
4474         {UATF_PHONOGRAPH, SOUND_MIXER_VOLUME},
4475         {UATF_VCRAUDIO, SOUND_MIXER_VOLUME},
4476         {UATF_SATELLITE, SOUND_MIXER_VOLUME},
4477         {UATF_CABLETUNER, SOUND_MIXER_VOLUME},
4478         {UATF_DSS, SOUND_MIXER_VOLUME},
4479         {UATF_MULTITRACK, SOUND_MIXER_VOLUME},
4480         {0xffff, SOUND_MIXER_VOLUME},
4481
4482         /* default */
4483         {0x0000, SOUND_MIXER_VOLUME},
4484 };
4485
4486 static uint16_t
4487 uaudio_mixer_feature_name(const struct uaudio_terminal_node *iot,
4488     struct uaudio_mixer_node *mix)
4489 {
4490         const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature;
4491         uint16_t terminal_type = uaudio_mixer_determine_class(iot, mix);
4492
4493         if ((mix->class == UAC_RECORD) && (terminal_type == 0)) {
4494                 return (SOUND_MIXER_IMIX);
4495         }
4496         while (uat->terminal_type) {
4497                 if (uat->terminal_type == terminal_type) {
4498                         break;
4499                 }
4500                 uat++;
4501         }
4502
4503         DPRINTF("terminal_type=0x%04x -> %d\n",
4504             terminal_type, uat->feature);
4505
4506         return (uat->feature);
4507 }
4508
4509 static uint16_t
4510 uaudio20_mixer_feature_name(const struct uaudio_terminal_node *iot,
4511     struct uaudio_mixer_node *mix)
4512 {
4513         const struct uaudio_tt_to_feature *uat;
4514         uint16_t terminal_type = uaudio20_mixer_determine_class(iot, mix);
4515
4516         if ((mix->class == UAC_RECORD) && (terminal_type == 0))
4517                 return (SOUND_MIXER_IMIX);
4518
4519         for (uat = uaudio_tt_to_feature; uat->terminal_type != 0; uat++) {
4520                 if (uat->terminal_type == terminal_type)
4521                         break;
4522         }
4523
4524         DPRINTF("terminal_type=0x%04x -> %d\n",
4525             terminal_type, uat->feature);
4526
4527         return (uat->feature);
4528 }
4529
4530 static const struct uaudio_terminal_node *
4531 uaudio_mixer_get_input(const struct uaudio_terminal_node *iot, uint8_t i)
4532 {
4533         struct uaudio_terminal_node *root = iot->root;
4534         uint8_t n;
4535
4536         n = iot->usr.id_max;
4537         do {
4538                 if (iot->usr.bit_input[n / 8] & (1 << (n % 8))) {
4539                         if (!i--)
4540                                 return (root + n);
4541                 }
4542         } while (n--);
4543
4544         return (NULL);
4545 }
4546
4547 static const struct uaudio_terminal_node *
4548 uaudio_mixer_get_output(const struct uaudio_terminal_node *iot, uint8_t i)
4549 {
4550         struct uaudio_terminal_node *root = iot->root;
4551         uint8_t n;
4552
4553         n = iot->usr.id_max;
4554         do {
4555                 if (iot->usr.bit_output[n / 8] & (1 << (n % 8))) {
4556                         if (!i--)
4557                                 return (root + n);
4558                 }
4559         } while (n--);
4560
4561         return (NULL);
4562 }
4563
4564 static void
4565 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4566     const uint8_t *p_id, uint8_t n_id,
4567     struct uaudio_search_result *info)
4568 {
4569         struct uaudio_terminal_node *iot;
4570         uint8_t n;
4571         uint8_t i;
4572         uint8_t is_last;
4573
4574 top:
4575         for (n = 0; n < n_id; n++) {
4576
4577                 i = p_id[n];
4578
4579                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4580                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4581                         return;
4582                 }
4583
4584                 info->recurse_level++;
4585
4586                 iot = (root + i);
4587
4588                 if (iot->u.desc == NULL)
4589                         continue;
4590
4591                 is_last = ((n + 1) == n_id);
4592
4593                 switch (iot->u.desc->bDescriptorSubtype) {
4594                 case UDESCSUB_AC_INPUT:
4595                         info->bit_input[i / 8] |= (1 << (i % 8));
4596                         break;
4597
4598                 case UDESCSUB_AC_FEATURE:
4599                         if (is_last) {
4600                                 p_id = &iot->u.fu_v1->bSourceId;
4601                                 n_id = 1;
4602                                 goto top;
4603                         }
4604                         uaudio_mixer_find_inputs_sub(
4605                             root, &iot->u.fu_v1->bSourceId, 1, info);
4606                         break;
4607
4608                 case UDESCSUB_AC_OUTPUT:
4609                         if (is_last) {
4610                                 p_id = &iot->u.ot_v1->bSourceId;
4611                                 n_id = 1;
4612                                 goto top;
4613                         }
4614                         uaudio_mixer_find_inputs_sub(
4615                             root, &iot->u.ot_v1->bSourceId, 1, info);
4616                         break;
4617
4618                 case UDESCSUB_AC_MIXER:
4619                         if (is_last) {
4620                                 p_id = iot->u.mu_v1->baSourceId;
4621                                 n_id = iot->u.mu_v1->bNrInPins;
4622                                 goto top;
4623                         }
4624                         uaudio_mixer_find_inputs_sub(
4625                             root, iot->u.mu_v1->baSourceId,
4626                             iot->u.mu_v1->bNrInPins, info);
4627                         break;
4628
4629                 case UDESCSUB_AC_SELECTOR:
4630                         if (is_last) {
4631                                 p_id = iot->u.su_v1->baSourceId;
4632                                 n_id = iot->u.su_v1->bNrInPins;
4633                                 goto top;
4634                         }
4635                         uaudio_mixer_find_inputs_sub(
4636                             root, iot->u.su_v1->baSourceId,
4637                             iot->u.su_v1->bNrInPins, info);
4638                         break;
4639
4640                 case UDESCSUB_AC_PROCESSING:
4641                         if (is_last) {
4642                                 p_id = iot->u.pu_v1->baSourceId;
4643                                 n_id = iot->u.pu_v1->bNrInPins;
4644                                 goto top;
4645                         }
4646                         uaudio_mixer_find_inputs_sub(
4647                             root, iot->u.pu_v1->baSourceId,
4648                             iot->u.pu_v1->bNrInPins, info);
4649                         break;
4650
4651                 case UDESCSUB_AC_EXTENSION:
4652                         if (is_last) {
4653                                 p_id = iot->u.eu_v1->baSourceId;
4654                                 n_id = iot->u.eu_v1->bNrInPins;
4655                                 goto top;
4656                         }
4657                         uaudio_mixer_find_inputs_sub(
4658                             root, iot->u.eu_v1->baSourceId,
4659                             iot->u.eu_v1->bNrInPins, info);
4660                         break;
4661
4662                 default:
4663                         break;
4664                 }
4665         }
4666 }
4667
4668 static void
4669 uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4670     const uint8_t *p_id, uint8_t n_id,
4671     struct uaudio_search_result *info)
4672 {
4673         struct uaudio_terminal_node *iot;
4674         uint8_t n;
4675         uint8_t i;
4676         uint8_t is_last;
4677
4678 top:
4679         for (n = 0; n < n_id; n++) {
4680
4681                 i = p_id[n];
4682
4683                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4684                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4685                         return;
4686                 }
4687
4688                 info->recurse_level++;
4689
4690                 iot = (root + i);
4691
4692                 if (iot->u.desc == NULL)
4693                         continue;
4694
4695                 is_last = ((n + 1) == n_id);
4696
4697                 switch (iot->u.desc->bDescriptorSubtype) {
4698                 case UDESCSUB_AC_INPUT:
4699                         info->bit_input[i / 8] |= (1 << (i % 8));
4700                         break;
4701
4702                 case UDESCSUB_AC_OUTPUT:
4703                         if (is_last) {
4704                                 p_id = &iot->u.ot_v2->bSourceId;
4705                                 n_id = 1;
4706                                 goto top;
4707                         }
4708                         uaudio20_mixer_find_inputs_sub(
4709                             root, &iot->u.ot_v2->bSourceId, 1, info);
4710                         break;
4711
4712                 case UDESCSUB_AC_MIXER:
4713                         if (is_last) {
4714                                 p_id = iot->u.mu_v2->baSourceId;
4715                                 n_id = iot->u.mu_v2->bNrInPins;
4716                                 goto top;
4717                         }
4718                         uaudio20_mixer_find_inputs_sub(
4719                             root, iot->u.mu_v2->baSourceId,
4720                             iot->u.mu_v2->bNrInPins, info);
4721                         break;
4722
4723                 case UDESCSUB_AC_SELECTOR:
4724                         if (is_last) {
4725                                 p_id = iot->u.su_v2->baSourceId;
4726                                 n_id = iot->u.su_v2->bNrInPins;
4727                                 goto top;
4728                         }
4729                         uaudio20_mixer_find_inputs_sub(
4730                             root, iot->u.su_v2->baSourceId,
4731                             iot->u.su_v2->bNrInPins, info);
4732                         break;
4733
4734                 case UDESCSUB_AC_SAMPLE_RT:
4735                         if (is_last) {
4736                                 p_id = &iot->u.ru_v2->bSourceId;
4737                                 n_id = 1;
4738                                 goto top;
4739                         }
4740                         uaudio20_mixer_find_inputs_sub(
4741                             root, &iot->u.ru_v2->bSourceId,
4742                             1, info);
4743                         break;
4744
4745                 case UDESCSUB_AC_EFFECT:
4746                         if (is_last) {
4747                                 p_id = &iot->u.ef_v2->bSourceId;
4748                                 n_id = 1;
4749                                 goto top;
4750                         }
4751                         uaudio20_mixer_find_inputs_sub(
4752                             root, &iot->u.ef_v2->bSourceId,
4753                             1, info);
4754                         break;
4755
4756                 case UDESCSUB_AC_FEATURE:
4757                         if (is_last) {
4758                                 p_id = &iot->u.fu_v2->bSourceId;
4759                                 n_id = 1;
4760                                 goto top;
4761                         }
4762                         uaudio20_mixer_find_inputs_sub(
4763                             root, &iot->u.fu_v2->bSourceId, 1, info);
4764                         break;
4765
4766                 case UDESCSUB_AC_PROCESSING_V2:
4767                         if (is_last) {
4768                                 p_id = iot->u.pu_v2->baSourceId;
4769                                 n_id = iot->u.pu_v2->bNrInPins;
4770                                 goto top;
4771                         }
4772                         uaudio20_mixer_find_inputs_sub(
4773                             root, iot->u.pu_v2->baSourceId,
4774                             iot->u.pu_v2->bNrInPins, info);
4775                         break;
4776
4777                 case UDESCSUB_AC_EXTENSION_V2:
4778                         if (is_last) {
4779                                 p_id = iot->u.eu_v2->baSourceId;
4780                                 n_id = iot->u.eu_v2->bNrInPins;
4781                                 goto top;
4782                         }
4783                         uaudio20_mixer_find_inputs_sub(
4784                             root, iot->u.eu_v2->baSourceId,
4785                             iot->u.eu_v2->bNrInPins, info);
4786                         break;
4787                 default:
4788                         break;
4789                 }
4790         }
4791 }
4792
4793 static void
4794 uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root,
4795     const uint8_t *p_id, uint8_t n_id,
4796     struct uaudio_search_result *info)
4797 {
4798         struct uaudio_terminal_node *iot;
4799         uint8_t n;
4800         uint8_t i;
4801         uint8_t is_last;
4802         uint8_t id;
4803
4804 top:
4805         for (n = 0; n < n_id; n++) {
4806
4807                 i = p_id[n];
4808
4809                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4810                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4811                         return;
4812                 }
4813
4814                 info->recurse_level++;
4815
4816                 iot = (root + i);
4817
4818                 if (iot->u.desc == NULL)
4819                         continue;
4820
4821                 is_last = ((n + 1) == n_id);
4822
4823                 switch (iot->u.desc->bDescriptorSubtype) {
4824                 case UDESCSUB_AC_INPUT:
4825                         info->is_input = 1;
4826                         if (is_last) {
4827                                 p_id = &iot->u.it_v2->bCSourceId;
4828                                 n_id = 1;
4829                                 goto top;
4830                         }
4831                         uaudio20_mixer_find_clocks_sub(root,
4832                             &iot->u.it_v2->bCSourceId, 1, info);
4833                         break;
4834
4835                 case UDESCSUB_AC_OUTPUT:
4836                         info->is_input = 0;
4837                         if (is_last) {
4838                                 p_id = &iot->u.ot_v2->bCSourceId;
4839                                 n_id = 1;
4840                                 goto top;
4841                         }
4842                         uaudio20_mixer_find_clocks_sub(root,
4843                             &iot->u.ot_v2->bCSourceId, 1, info);
4844                         break;
4845
4846                 case UDESCSUB_AC_CLOCK_SEL:
4847                         if (is_last) {
4848                                 p_id = iot->u.csel_v2->baCSourceId;
4849                                 n_id = iot->u.csel_v2->bNrInPins;
4850                                 goto top;
4851                         }
4852                         uaudio20_mixer_find_clocks_sub(root,
4853                             iot->u.csel_v2->baCSourceId,
4854                             iot->u.csel_v2->bNrInPins, info);
4855                         break;
4856
4857                 case UDESCSUB_AC_CLOCK_MUL:
4858                         if (is_last) {
4859                                 p_id = &iot->u.cmul_v2->bCSourceId;
4860                                 n_id = 1;
4861                                 goto top;
4862                         }
4863                         uaudio20_mixer_find_clocks_sub(root,
4864                             &iot->u.cmul_v2->bCSourceId,
4865                             1, info);
4866                         break;
4867
4868                 case UDESCSUB_AC_CLOCK_SRC:
4869
4870                         id = iot->u.csrc_v2->bClockId;
4871
4872                         switch (info->is_input) {
4873                         case 0:
4874                                 info->bit_output[id / 8] |= (1 << (id % 8));
4875                                 break;
4876                         case 1:
4877                                 info->bit_input[id / 8] |= (1 << (id % 8));
4878                                 break;
4879                         default:
4880                                 break;
4881                         }
4882                         break;
4883
4884                 default:
4885                         break;
4886                 }
4887         }
4888 }
4889
4890 static void
4891 uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *root, uint8_t id,
4892     uint8_t n_id, struct uaudio_search_result *info)
4893 {
4894         struct uaudio_terminal_node *iot = (root + id);
4895         uint8_t j;
4896
4897         j = n_id;
4898         do {
4899                 if ((j != id) && ((root + j)->u.desc) &&
4900                     ((root + j)->u.desc->bDescriptorSubtype == UDESCSUB_AC_OUTPUT)) {
4901
4902                         /*
4903                          * "j" (output) <--- virtual wire <--- "id" (input)
4904                          *
4905                          * if "j" has "id" on the input, then "id" have "j" on
4906                          * the output, because they are connected:
4907                          */
4908                         if ((root + j)->usr.bit_input[id / 8] & (1 << (id % 8))) {
4909                                 iot->usr.bit_output[j / 8] |= (1 << (j % 8));
4910                         }
4911                 }
4912         } while (j--);
4913 }
4914
4915 static void
4916 uaudio_mixer_fill_info(struct uaudio_softc *sc,
4917     struct usb_device *udev, void *desc)
4918 {
4919         const struct usb_audio_control_descriptor *acdp;
4920         struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
4921         const struct usb_descriptor *dp;
4922         const struct usb_audio_unit *au;
4923         struct uaudio_terminal_node *iot = NULL;
4924         uint16_t wTotalLen;
4925         uint8_t ID_max = 0;             /* inclusive */
4926         uint8_t i;
4927
4928         desc = usb_desc_foreach(cd, desc);
4929
4930         if (desc == NULL) {
4931                 DPRINTF("no Audio Control header\n");
4932                 goto done;
4933         }
4934         acdp = desc;
4935
4936         if ((acdp->bLength < sizeof(*acdp)) ||
4937             (acdp->bDescriptorType != UDESC_CS_INTERFACE) ||
4938             (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) {
4939                 DPRINTF("invalid Audio Control header\n");
4940                 goto done;
4941         }
4942         /* "wTotalLen" is allowed to be corrupt */
4943         wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength;
4944
4945         /* get USB audio revision */
4946         sc->sc_audio_rev = UGETW(acdp->bcdADC);
4947
4948         DPRINTFN(3, "found AC header, vers=%03x, len=%d\n",
4949             sc->sc_audio_rev, wTotalLen);
4950
4951         iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP,
4952             M_WAITOK | M_ZERO);
4953
4954         if (iot == NULL) {
4955                 DPRINTF("no memory!\n");
4956                 goto done;
4957         }
4958         while ((desc = usb_desc_foreach(cd, desc))) {
4959
4960                 dp = desc;
4961
4962                 if (dp->bLength > wTotalLen) {
4963                         break;
4964                 } else {
4965                         wTotalLen -= dp->bLength;
4966                 }
4967
4968                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30)
4969                         au = NULL;
4970                 else if (sc->sc_audio_rev >= UAUDIO_VERSION_20)
4971                         au = uaudio20_mixer_verify_desc(dp, 0);
4972                 else
4973                         au = uaudio_mixer_verify_desc(dp, 0);
4974
4975                 if (au) {
4976                         iot[au->bUnitId].u.desc = (const void *)au;
4977                         if (au->bUnitId > ID_max)
4978                                 ID_max = au->bUnitId;
4979                 }
4980         }
4981
4982         DPRINTF("Maximum ID=%d\n", ID_max);
4983
4984         /*
4985          * determine sourcing inputs for
4986          * all nodes in the tree:
4987          */
4988         i = ID_max;
4989         do {
4990                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
4991                         /* FALLTHROUGH */
4992                 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
4993                         uaudio20_mixer_find_inputs_sub(iot,
4994                             &i, 1, &((iot + i)->usr));
4995
4996                         sc->sc_mixer_clocks.is_input = 255;
4997                         sc->sc_mixer_clocks.recurse_level = 0;
4998
4999                         uaudio20_mixer_find_clocks_sub(iot,
5000                             &i, 1, &sc->sc_mixer_clocks);
5001                 } else {
5002                         uaudio_mixer_find_inputs_sub(iot,
5003                             &i, 1, &((iot + i)->usr));
5004                 }
5005         } while (i--);
5006
5007         /*
5008          * determine outputs for
5009          * all nodes in the tree:
5010          */
5011         i = ID_max;
5012         do {
5013                 uaudio_mixer_find_outputs_sub(iot,
5014                     i, ID_max, &((iot + i)->usr));
5015         } while (i--);
5016
5017         /* set "id_max" and "root" */
5018
5019         i = ID_max;
5020         do {
5021                 (iot + i)->usr.id_max = ID_max;
5022                 (iot + i)->root = iot;
5023         } while (i--);
5024
5025         /*
5026          * Scan the config to create a linked list of "mixer" nodes:
5027          */
5028
5029         i = ID_max;
5030         do {
5031                 dp = iot[i].u.desc;
5032
5033                 if (dp == NULL)
5034                         continue;
5035
5036                 DPRINTFN(11, "id=%d subtype=%d\n",
5037                     i, dp->bDescriptorSubtype);
5038
5039                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5040                         continue;
5041                 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5042
5043                         switch (dp->bDescriptorSubtype) {
5044                         case UDESCSUB_AC_HEADER:
5045                                 DPRINTF("unexpected AC header\n");
5046                                 break;
5047
5048                         case UDESCSUB_AC_INPUT:
5049                         case UDESCSUB_AC_OUTPUT:
5050                         case UDESCSUB_AC_PROCESSING_V2:
5051                         case UDESCSUB_AC_EXTENSION_V2:
5052                         case UDESCSUB_AC_EFFECT:
5053                         case UDESCSUB_AC_CLOCK_SRC:
5054                         case UDESCSUB_AC_CLOCK_SEL:
5055                         case UDESCSUB_AC_CLOCK_MUL:
5056                         case UDESCSUB_AC_SAMPLE_RT:
5057                                 break;
5058
5059                         case UDESCSUB_AC_MIXER:
5060                                 uaudio20_mixer_add_mixer(sc, iot, i);
5061                                 break;
5062
5063                         case UDESCSUB_AC_SELECTOR:
5064                                 uaudio20_mixer_add_selector(sc, iot, i);
5065                                 break;
5066
5067                         case UDESCSUB_AC_FEATURE:
5068                                 uaudio20_mixer_add_feature(sc, iot, i);
5069                                 break;
5070
5071                         default:
5072                                 DPRINTF("bad AC desc subtype=0x%02x\n",
5073                                     dp->bDescriptorSubtype);
5074                                 break;
5075                         }
5076                         continue;
5077                 }
5078
5079                 switch (dp->bDescriptorSubtype) {
5080                 case UDESCSUB_AC_HEADER:
5081                         DPRINTF("unexpected AC header\n");
5082                         break;
5083
5084                 case UDESCSUB_AC_INPUT:
5085                 case UDESCSUB_AC_OUTPUT:
5086                         break;
5087
5088                 case UDESCSUB_AC_MIXER:
5089                         uaudio_mixer_add_mixer(sc, iot, i);
5090                         break;
5091
5092                 case UDESCSUB_AC_SELECTOR:
5093                         uaudio_mixer_add_selector(sc, iot, i);
5094                         break;
5095
5096                 case UDESCSUB_AC_FEATURE:
5097                         uaudio_mixer_add_feature(sc, iot, i);
5098                         break;
5099
5100                 case UDESCSUB_AC_PROCESSING:
5101                         uaudio_mixer_add_processing(sc, iot, i);
5102                         break;
5103
5104                 case UDESCSUB_AC_EXTENSION:
5105                         uaudio_mixer_add_extension(sc, iot, i);
5106                         break;
5107
5108                 default:
5109                         DPRINTF("bad AC desc subtype=0x%02x\n",
5110                             dp->bDescriptorSubtype);
5111                         break;
5112                 }
5113
5114         } while (i--);
5115
5116 done:
5117         free(iot, M_TEMP);
5118 }
5119
5120 static int
5121 uaudio_mixer_get(struct usb_device *udev, uint16_t audio_rev,
5122     uint8_t what, struct uaudio_mixer_node *mc)
5123 {
5124         struct usb_device_request req;
5125         int val;
5126         uint8_t data[2 + (2 * 3)];
5127         usb_error_t err;
5128
5129         if (mc->wValue[0] == -1)
5130                 return (0);
5131
5132         if (audio_rev >= UAUDIO_VERSION_30)
5133                 return (0);
5134         else if (audio_rev >= UAUDIO_VERSION_20) {
5135                 if (what == GET_CUR) {
5136                         req.bRequest = UA20_CS_CUR;
5137                         USETW(req.wLength, 2);
5138                 } else {
5139                         req.bRequest = UA20_CS_RANGE;
5140                         USETW(req.wLength, 8);
5141                 }
5142         } else {
5143                 uint16_t len = MIX_SIZE(mc->type);
5144
5145                 req.bRequest = what;
5146                 USETW(req.wLength, len);
5147         }
5148
5149         req.bmRequestType = UT_READ_CLASS_INTERFACE;
5150         USETW(req.wValue, mc->wValue[0]);
5151         USETW(req.wIndex, mc->wIndex);
5152
5153         memset(data, 0, sizeof(data));
5154
5155         err = usbd_do_request(udev, NULL, &req, data);
5156         if (err) {
5157                 DPRINTF("err=%s\n", usbd_errstr(err));
5158                 return (0);
5159         }
5160
5161         if (audio_rev >= UAUDIO_VERSION_30) {
5162                 val = 0;
5163         } else if (audio_rev >= UAUDIO_VERSION_20) {
5164                 switch (what) {
5165                 case GET_CUR:
5166                         val = (data[0] | (data[1] << 8));
5167                         break;
5168                 case GET_MIN:
5169                         val = (data[2] | (data[3] << 8));
5170                         break;
5171                 case GET_MAX:
5172                         val = (data[4] | (data[5] << 8));
5173                         break;
5174                 case GET_RES:
5175                         val = (data[6] | (data[7] << 8));
5176                         break;
5177                 default:
5178                         val = 0;
5179                         break;
5180                 }
5181         } else {
5182                 val = (data[0] | (data[1] << 8));
5183         }
5184
5185         if (what == GET_CUR || what == GET_MIN || what == GET_MAX)
5186                 val = uaudio_mixer_signext(mc->type, val);
5187
5188         DPRINTFN(3, "val=%d\n", val);
5189
5190         return (val);
5191 }
5192
5193 static void
5194 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error)
5195 {
5196         struct usb_device_request req;
5197         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
5198         struct uaudio_mixer_node *mc = sc->sc_mixer_curr;
5199         struct usb_page_cache *pc;
5200         uint16_t len;
5201         uint8_t repeat = 1;
5202         uint8_t update;
5203         uint8_t chan;
5204         uint8_t buf[2];
5205
5206         DPRINTF("\n");
5207
5208         switch (USB_GET_STATE(xfer)) {
5209         case USB_ST_TRANSFERRED:
5210 tr_transferred:
5211         case USB_ST_SETUP:
5212 tr_setup:
5213
5214                 if (mc == NULL) {
5215                         mc = sc->sc_mixer_root;
5216                         sc->sc_mixer_curr = mc;
5217                         sc->sc_mixer_chan = 0;
5218                         repeat = 0;
5219                 }
5220                 while (mc) {
5221                         while (sc->sc_mixer_chan < mc->nchan) {
5222
5223                                 chan = sc->sc_mixer_chan;
5224
5225                                 sc->sc_mixer_chan++;
5226
5227                                 update = ((mc->update[chan / 8] & (1 << (chan % 8))) &&
5228                                     (mc->wValue[chan] != -1));
5229
5230                                 mc->update[chan / 8] &= ~(1 << (chan % 8));
5231
5232                                 if (update) {
5233
5234                                         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5235                                         USETW(req.wValue, mc->wValue[chan]);
5236                                         USETW(req.wIndex, mc->wIndex);
5237
5238                                         if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5239                                                 return;
5240                                         } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5241                                                 len = 2;
5242                                                 req.bRequest = UA20_CS_CUR;
5243                                                 USETW(req.wLength, len);
5244                                         } else {
5245                                                 len = MIX_SIZE(mc->type);
5246                                                 req.bRequest = SET_CUR;
5247                                                 USETW(req.wLength, len);
5248                                         }
5249
5250                                         buf[0] = (mc->wData[chan] & 0xFF);
5251                                         buf[1] = (mc->wData[chan] >> 8) & 0xFF;
5252
5253                                         pc = usbd_xfer_get_frame(xfer, 0);
5254                                         usbd_copy_in(pc, 0, &req, sizeof(req));
5255                                         pc = usbd_xfer_get_frame(xfer, 1);
5256                                         usbd_copy_in(pc, 0, buf, len);
5257
5258                                         usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
5259                                         usbd_xfer_set_frame_len(xfer, 1, len);
5260                                         usbd_xfer_set_frames(xfer, len ? 2 : 1);
5261                                         usbd_transfer_submit(xfer);
5262                                         return;
5263                                 }
5264                         }
5265
5266                         mc = mc->next;
5267                         sc->sc_mixer_curr = mc;
5268                         sc->sc_mixer_chan = 0;
5269                 }
5270
5271                 if (repeat) {
5272                         goto tr_setup;
5273                 }
5274                 break;
5275
5276         default:                        /* Error */
5277                 DPRINTF("error=%s\n", usbd_errstr(error));
5278                 if (error == USB_ERR_CANCELLED) {
5279                         /* do nothing - we are detaching */
5280                         break;
5281                 }
5282                 goto tr_transferred;
5283         }
5284 }
5285
5286 static usb_error_t
5287 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)
5288 {
5289         struct usb_device_request req;
5290         uint8_t data[3];
5291
5292         DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed);
5293
5294         req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
5295         req.bRequest = SET_CUR;
5296         USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
5297         USETW(req.wIndex, endpt);
5298         USETW(req.wLength, 3);
5299         data[0] = speed;
5300         data[1] = speed >> 8;
5301         data[2] = speed >> 16;
5302
5303         return (usbd_do_request(udev, NULL, &req, data));
5304 }
5305
5306 static usb_error_t
5307 uaudio20_set_speed(struct usb_device *udev, uint8_t iface_no,
5308     uint8_t clockid, uint32_t speed)
5309 {
5310         struct usb_device_request req;
5311         uint8_t data[4];
5312
5313         DPRINTFN(6, "ifaceno=%d clockid=%d speed=%u\n",
5314             iface_no, clockid, speed);
5315
5316         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5317         req.bRequest = UA20_CS_CUR;
5318         USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
5319         USETW2(req.wIndex, clockid, iface_no);
5320         USETW(req.wLength, 4);
5321         data[0] = speed;
5322         data[1] = speed >> 8;
5323         data[2] = speed >> 16;
5324         data[3] = speed >> 24;
5325
5326         return (usbd_do_request(udev, NULL, &req, data));
5327 }
5328
5329 static int
5330 uaudio_mixer_signext(uint8_t type, int val)
5331 {
5332         if (!MIX_UNSIGNED(type)) {
5333                 if (MIX_SIZE(type) == 2) {
5334                         val = (int16_t)val;
5335                 } else {
5336                         val = (int8_t)val;
5337                 }
5338         }
5339         return (val);
5340 }
5341
5342 static int
5343 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int32_t val)
5344 {
5345         if (mc->type == MIX_ON_OFF) {
5346                 val = (val != 0);
5347         } else if (mc->type == MIX_SELECTOR) {
5348                 if ((val < mc->minval) ||
5349                     (val > mc->maxval)) {
5350                         val = mc->minval;
5351                 }
5352         } else {
5353
5354                 /* compute actual volume */
5355                 val = (val * mc->mul) / 255;
5356
5357                 /* add lower offset */
5358                 val = val + mc->minval;
5359
5360                 /* make sure we don't write a value out of range */
5361                 if (val > mc->maxval)
5362                         val = mc->maxval;
5363                 else if (val < mc->minval)
5364                         val = mc->minval;
5365         }
5366
5367         DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n",
5368             mc->type, val, mc->minval, mc->maxval, val);
5369         return (val);
5370 }
5371
5372 static void
5373 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc,
5374     uint8_t chan, int32_t val)
5375 {
5376         val = uaudio_mixer_bsd2value(mc, val);
5377
5378         mc->update[chan / 8] |= (1 << (chan % 8));
5379         mc->wData[chan] = val;
5380
5381         /* start the transfer, if not already started */
5382
5383         usbd_transfer_start(sc->sc_mixer_xfer[0]);
5384 }
5385
5386 static void
5387 uaudio_mixer_init(struct uaudio_softc *sc)
5388 {
5389         struct uaudio_mixer_node *mc;
5390         int32_t i;
5391
5392         for (mc = sc->sc_mixer_root; mc;
5393             mc = mc->next) {
5394
5395                 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
5396                         /*
5397                          * Set device mask bits. See
5398                          * /usr/include/machine/soundcard.h
5399                          */
5400                         sc->sc_mix_info |= (1 << mc->ctl);
5401                 }
5402                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5403                     (mc->type == MIX_SELECTOR)) {
5404
5405                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5406                                 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES) {
5407                                         continue;
5408                                 }
5409                                 sc->sc_recsrc_info |= 1 << mc->slctrtype[i - 1];
5410                         }
5411                 }
5412         }
5413 }
5414
5415 int
5416 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5417 {
5418         DPRINTF("\n");
5419
5420         sc->sc_mixer_lock = mixer_get_lock(m);
5421         sc->sc_mixer_dev = m;
5422
5423         if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
5424             sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
5425             sc->sc_mixer_lock)) {
5426                 DPRINTFN(0, "could not allocate USB "
5427                     "transfer for audio mixer!\n");
5428                 return (ENOMEM);
5429         }
5430         if (!(sc->sc_mix_info & SOUND_MASK_VOLUME)) {
5431                 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM);
5432                 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE);
5433         }
5434         mix_setdevs(m, sc->sc_mix_info);
5435         mix_setrecdevs(m, sc->sc_recsrc_info);
5436         return (0);
5437 }
5438
5439 int
5440 uaudio_mixer_uninit_sub(struct uaudio_softc *sc)
5441 {
5442         DPRINTF("\n");
5443
5444         usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
5445
5446         sc->sc_mixer_lock = NULL;
5447
5448         return (0);
5449 }
5450
5451 void
5452 uaudio_mixer_set(struct uaudio_softc *sc, unsigned type,
5453     unsigned left, unsigned right)
5454 {
5455         struct uaudio_mixer_node *mc;
5456         int chan;
5457
5458         for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) {
5459
5460                 if (mc->ctl == type) {
5461                         for (chan = 0; chan < mc->nchan; chan++) {
5462                                 uaudio_mixer_ctl_set(sc, mc, chan,
5463                                     (int)((chan == 0 ? left : right) *
5464                                     255) / 100);
5465                         }
5466                 }
5467         }
5468 }
5469
5470 uint32_t
5471 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, uint32_t src)
5472 {
5473         struct uaudio_mixer_node *mc;
5474         uint32_t mask;
5475         uint32_t temp;
5476         int32_t i;
5477
5478         for (mc = sc->sc_mixer_root; mc;
5479             mc = mc->next) {
5480
5481                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5482                     (mc->type == MIX_SELECTOR)) {
5483
5484                         /* compute selector mask */
5485
5486                         mask = 0;
5487                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5488                                 mask |= (1 << mc->slctrtype[i - 1]);
5489                         }
5490
5491                         temp = mask & src;
5492                         if (temp == 0) {
5493                                 continue;
5494                         }
5495                         /* find the first set bit */
5496                         temp = (-temp) & temp;
5497
5498                         /* update "src" */
5499                         src &= ~mask;
5500                         src |= temp;
5501
5502                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5503                                 if (temp != (1 << mc->slctrtype[i - 1])) {
5504                                         continue;
5505                                 }
5506                                 uaudio_mixer_ctl_set(sc, mc, 0, i);
5507                                 break;
5508                         }
5509                 }
5510         }
5511         return (src);
5512 }
5513
5514 /*========================================================================*
5515  * MIDI support routines
5516  *========================================================================*/
5517
5518 static void
5519 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
5520 {
5521         struct umidi_chan *chan = usbd_xfer_softc(xfer);
5522         struct umidi_sub_chan *sub;
5523         struct usb_page_cache *pc;
5524         uint8_t buf[4];
5525         uint8_t cmd_len;
5526         uint8_t cn;
5527         uint16_t pos;
5528         int actlen;
5529
5530         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
5531
5532         switch (USB_GET_STATE(xfer)) {
5533         case USB_ST_TRANSFERRED:
5534
5535                 DPRINTF("actlen=%d bytes\n", actlen);
5536
5537                 pos = 0;
5538                 pc = usbd_xfer_get_frame(xfer, 0);
5539
5540                 while (actlen >= 4) {
5541
5542                         /* copy out the MIDI data */
5543                         usbd_copy_out(pc, pos, buf, 4);
5544                         /* command length */
5545                         cmd_len = umidi_cmd_to_len[buf[0] & 0xF];
5546                         /* cable number */
5547                         cn = buf[0] >> 4;
5548                         /*
5549                          * Lookup sub-channel. The index is range
5550                          * checked below.
5551                          */
5552                         sub = &chan->sub[cn];
5553
5554                         if ((cmd_len != 0) && (cn < chan->max_emb_jack) &&
5555                             (sub->read_open != 0)) {
5556
5557                                 /* Send data to the application */
5558                                 usb_fifo_put_data_linear(
5559                                     sub->fifo.fp[USB_FIFO_RX],
5560                                     buf + 1, cmd_len, 1);
5561                         }
5562                         actlen -= 4;
5563                         pos += 4;
5564                 }
5565
5566         case USB_ST_SETUP:
5567                 DPRINTF("start\n");
5568 tr_setup:
5569                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
5570                 usbd_transfer_submit(xfer);
5571                 break;
5572
5573         default:
5574                 DPRINTF("error=%s\n", usbd_errstr(error));
5575
5576                 if (error != USB_ERR_CANCELLED) {
5577                         /* try to clear stall first */
5578                         usbd_xfer_set_stall(xfer);
5579                         goto tr_setup;
5580                 }
5581                 break;
5582         }
5583 }
5584
5585 /*
5586  * The following statemachine, that converts MIDI commands to
5587  * USB MIDI packets, derives from Linux's usbmidi.c, which
5588  * was written by "Clemens Ladisch":
5589  *
5590  * Returns:
5591  *    0: No command
5592  * Else: Command is complete
5593  */
5594 static uint8_t
5595 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b)
5596 {
5597         uint8_t p0 = (cn << 4);
5598
5599         if (b >= 0xf8) {
5600                 sub->temp_0[0] = p0 | 0x0f;
5601                 sub->temp_0[1] = b;
5602                 sub->temp_0[2] = 0;
5603                 sub->temp_0[3] = 0;
5604                 sub->temp_cmd = sub->temp_0;
5605                 return (1);
5606
5607         } else if (b >= 0xf0) {
5608                 switch (b) {
5609                 case 0xf0:              /* system exclusive begin */
5610                         sub->temp_1[1] = b;
5611                         sub->state = UMIDI_ST_SYSEX_1;
5612                         break;
5613                 case 0xf1:              /* MIDI time code */
5614                 case 0xf3:              /* song select */
5615                         sub->temp_1[1] = b;
5616                         sub->state = UMIDI_ST_1PARAM;
5617                         break;
5618                 case 0xf2:              /* song position pointer */
5619                         sub->temp_1[1] = b;
5620                         sub->state = UMIDI_ST_2PARAM_1;
5621                         break;
5622                 case 0xf4:              /* unknown */
5623                 case 0xf5:              /* unknown */
5624                         sub->state = UMIDI_ST_UNKNOWN;
5625                         break;
5626                 case 0xf6:              /* tune request */
5627                         sub->temp_1[0] = p0 | 0x05;
5628                         sub->temp_1[1] = 0xf6;
5629                         sub->temp_1[2] = 0;
5630                         sub->temp_1[3] = 0;
5631                         sub->temp_cmd = sub->temp_1;
5632                         sub->state = UMIDI_ST_UNKNOWN;
5633                         return (1);
5634
5635                 case 0xf7:              /* system exclusive end */
5636                         switch (sub->state) {
5637                         case UMIDI_ST_SYSEX_0:
5638                                 sub->temp_1[0] = p0 | 0x05;
5639                                 sub->temp_1[1] = 0xf7;
5640                                 sub->temp_1[2] = 0;
5641                                 sub->temp_1[3] = 0;
5642                                 sub->temp_cmd = sub->temp_1;
5643                                 sub->state = UMIDI_ST_UNKNOWN;
5644                                 return (1);
5645                         case UMIDI_ST_SYSEX_1:
5646                                 sub->temp_1[0] = p0 | 0x06;
5647                                 sub->temp_1[2] = 0xf7;
5648                                 sub->temp_1[3] = 0;
5649                                 sub->temp_cmd = sub->temp_1;
5650                                 sub->state = UMIDI_ST_UNKNOWN;
5651                                 return (1);
5652                         case UMIDI_ST_SYSEX_2:
5653                                 sub->temp_1[0] = p0 | 0x07;
5654                                 sub->temp_1[3] = 0xf7;
5655                                 sub->temp_cmd = sub->temp_1;
5656                                 sub->state = UMIDI_ST_UNKNOWN;
5657                                 return (1);
5658                         }
5659                         sub->state = UMIDI_ST_UNKNOWN;
5660                         break;
5661                 }
5662         } else if (b >= 0x80) {
5663                 sub->temp_1[1] = b;
5664                 if ((b >= 0xc0) && (b <= 0xdf)) {
5665                         sub->state = UMIDI_ST_1PARAM;
5666                 } else {
5667                         sub->state = UMIDI_ST_2PARAM_1;
5668                 }
5669         } else {                        /* b < 0x80 */
5670                 switch (sub->state) {
5671                 case UMIDI_ST_1PARAM:
5672                         if (sub->temp_1[1] < 0xf0) {
5673                                 p0 |= sub->temp_1[1] >> 4;
5674                         } else {
5675                                 p0 |= 0x02;
5676                                 sub->state = UMIDI_ST_UNKNOWN;
5677                         }
5678                         sub->temp_1[0] = p0;
5679                         sub->temp_1[2] = b;
5680                         sub->temp_1[3] = 0;
5681                         sub->temp_cmd = sub->temp_1;
5682                         return (1);
5683                 case UMIDI_ST_2PARAM_1:
5684                         sub->temp_1[2] = b;
5685                         sub->state = UMIDI_ST_2PARAM_2;
5686                         break;
5687                 case UMIDI_ST_2PARAM_2:
5688                         if (sub->temp_1[1] < 0xf0) {
5689                                 p0 |= sub->temp_1[1] >> 4;
5690                                 sub->state = UMIDI_ST_2PARAM_1;
5691                         } else {
5692                                 p0 |= 0x03;
5693                                 sub->state = UMIDI_ST_UNKNOWN;
5694                         }
5695                         sub->temp_1[0] = p0;
5696                         sub->temp_1[3] = b;
5697                         sub->temp_cmd = sub->temp_1;
5698                         return (1);
5699                 case UMIDI_ST_SYSEX_0:
5700                         sub->temp_1[1] = b;
5701                         sub->state = UMIDI_ST_SYSEX_1;
5702                         break;
5703                 case UMIDI_ST_SYSEX_1:
5704                         sub->temp_1[2] = b;
5705                         sub->state = UMIDI_ST_SYSEX_2;
5706                         break;
5707                 case UMIDI_ST_SYSEX_2:
5708                         sub->temp_1[0] = p0 | 0x04;
5709                         sub->temp_1[3] = b;
5710                         sub->temp_cmd = sub->temp_1;
5711                         sub->state = UMIDI_ST_SYSEX_0;
5712                         return (1);
5713                 default:
5714                         break;
5715                 }
5716         }
5717         return (0);
5718 }
5719
5720 static void
5721 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
5722 {
5723         struct umidi_chan *chan = usbd_xfer_softc(xfer);
5724         struct umidi_sub_chan *sub;
5725         struct usb_page_cache *pc;
5726         uint32_t actlen;
5727         uint16_t nframes;
5728         uint8_t buf;
5729         uint8_t start_cable;
5730         uint8_t tr_any;
5731         int len;
5732
5733         usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
5734
5735         /*
5736          * NOTE: Some MIDI devices only accept 4 bytes of data per
5737          * short terminated USB transfer.
5738          */
5739         switch (USB_GET_STATE(xfer)) {
5740         case USB_ST_TRANSFERRED:
5741                 DPRINTF("actlen=%d bytes\n", len);
5742
5743         case USB_ST_SETUP:
5744 tr_setup:
5745                 DPRINTF("start\n");
5746
5747                 nframes = 0;    /* reset */
5748                 start_cable = chan->curr_cable;
5749                 tr_any = 0;
5750                 pc = usbd_xfer_get_frame(xfer, 0);
5751
5752                 while (1) {
5753
5754                         /* round robin de-queueing */
5755
5756                         sub = &chan->sub[chan->curr_cable];
5757
5758                         if (sub->write_open) {
5759                                 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX],
5760                                     &buf, 1, &actlen, 0);
5761                         } else {
5762                                 actlen = 0;
5763                         }
5764
5765                         if (actlen) {
5766
5767                                 tr_any = 1;
5768
5769                                 DPRINTF("byte=0x%02x from FIFO %u\n", buf,
5770                                     (unsigned int)chan->curr_cable);
5771
5772                                 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) {
5773
5774                                         DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n",
5775                                             sub->temp_cmd[0], sub->temp_cmd[1],
5776                                             sub->temp_cmd[2], sub->temp_cmd[3]);
5777
5778                                         usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4);
5779
5780                                         nframes++;
5781
5782                                         if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0))
5783                                                 break;
5784                                 } else {
5785                                         continue;
5786                                 }
5787                         }
5788
5789                         chan->curr_cable++;
5790                         if (chan->curr_cable >= chan->max_emb_jack)
5791                                 chan->curr_cable = 0;
5792
5793                         if (chan->curr_cable == start_cable) {
5794                                 if (tr_any == 0)
5795                                         break;
5796                                 tr_any = 0;
5797                         }
5798                 }
5799
5800                 if (nframes != 0) {
5801                         DPRINTF("Transferring %d frames\n", (int)nframes);
5802                         usbd_xfer_set_frame_len(xfer, 0, 4 * nframes);
5803                         usbd_transfer_submit(xfer);
5804                 }
5805                 break;
5806
5807         default:                        /* Error */
5808
5809                 DPRINTF("error=%s\n", usbd_errstr(error));
5810
5811                 if (error != USB_ERR_CANCELLED) {
5812                         /* try to clear stall first */
5813                         usbd_xfer_set_stall(xfer);
5814                         goto tr_setup;
5815                 }
5816                 break;
5817         }
5818 }
5819
5820 static struct umidi_sub_chan *
5821 umidi_sub_by_fifo(struct usb_fifo *fifo)
5822 {
5823         struct umidi_chan *chan = usb_fifo_softc(fifo);
5824         struct umidi_sub_chan *sub;
5825         uint32_t n;
5826
5827         for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) {
5828                 sub = &chan->sub[n];
5829                 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) ||
5830                     (sub->fifo.fp[USB_FIFO_TX] == fifo)) {
5831                         return (sub);
5832                 }
5833         }
5834
5835         panic("%s:%d cannot find usb_fifo!\n",
5836             __FILE__, __LINE__);
5837
5838         return (NULL);
5839 }
5840
5841 static void
5842 umidi_start_read(struct usb_fifo *fifo)
5843 {
5844         struct umidi_chan *chan = usb_fifo_softc(fifo);
5845
5846         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
5847 }
5848
5849 static void
5850 umidi_stop_read(struct usb_fifo *fifo)
5851 {
5852         struct umidi_chan *chan = usb_fifo_softc(fifo);
5853         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5854
5855         DPRINTF("\n");
5856
5857         sub->read_open = 0;
5858
5859         if (--(chan->read_open_refcount) == 0) {
5860                 /*
5861                  * XXX don't stop the read transfer here, hence that causes
5862                  * problems with some MIDI adapters
5863                  */
5864                 DPRINTF("(stopping read transfer)\n");
5865         }
5866 }
5867
5868 static void
5869 umidi_start_write(struct usb_fifo *fifo)
5870 {
5871         struct umidi_chan *chan = usb_fifo_softc(fifo);
5872
5873         if (chan->xfer[UMIDI_TX_TRANSFER] == NULL) {
5874                 uint8_t buf[1];
5875                 int actlen;
5876                 do {
5877                         /* dump data */
5878                         usb_fifo_get_data_linear(fifo, buf, 1, &actlen, 0);
5879                 } while (actlen > 0);
5880         } else {
5881                 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]);
5882         }
5883 }
5884
5885 static void
5886 umidi_stop_write(struct usb_fifo *fifo)
5887 {
5888         struct umidi_chan *chan = usb_fifo_softc(fifo);
5889         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5890
5891         DPRINTF("\n");
5892
5893         sub->write_open = 0;
5894
5895         if (--(chan->write_open_refcount) == 0) {
5896                 DPRINTF("(stopping write transfer)\n");
5897                 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]);
5898         }
5899 }
5900
5901 static int
5902 umidi_open(struct usb_fifo *fifo, int fflags)
5903 {
5904         struct umidi_chan *chan = usb_fifo_softc(fifo);
5905         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5906
5907         if (fflags & FREAD) {
5908                 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
5909                         return (ENOMEM);
5910                 }
5911                 mtx_lock(&chan->mtx);
5912                 chan->read_open_refcount++;
5913                 sub->read_open = 1;
5914                 mtx_unlock(&chan->mtx);
5915         }
5916         if (fflags & FWRITE) {
5917                 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
5918                         return (ENOMEM);
5919                 }
5920                 /* clear stall first */
5921                 mtx_lock(&chan->mtx);
5922                 chan->write_open_refcount++;
5923                 sub->write_open = 1;
5924
5925                 /* reset */
5926                 sub->state = UMIDI_ST_UNKNOWN;
5927                 mtx_unlock(&chan->mtx);
5928         }
5929         return (0);                     /* success */
5930 }
5931
5932 static void
5933 umidi_close(struct usb_fifo *fifo, int fflags)
5934 {
5935         if (fflags & FREAD) {
5936                 usb_fifo_free_buffer(fifo);
5937         }
5938         if (fflags & FWRITE) {
5939                 usb_fifo_free_buffer(fifo);
5940         }
5941 }
5942
5943
5944 static int
5945 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data,
5946     int fflags)
5947 {
5948         return (ENODEV);
5949 }
5950
5951 static void
5952 umidi_init(device_t dev)
5953 {
5954         struct uaudio_softc *sc = device_get_softc(dev);
5955         struct umidi_chan *chan = &sc->sc_midi_chan;
5956
5957         mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE);
5958 }
5959
5960 static struct usb_fifo_methods umidi_fifo_methods = {
5961         .f_start_read = &umidi_start_read,
5962         .f_start_write = &umidi_start_write,
5963         .f_stop_read = &umidi_stop_read,
5964         .f_stop_write = &umidi_stop_write,
5965         .f_open = &umidi_open,
5966         .f_close = &umidi_close,
5967         .f_ioctl = &umidi_ioctl,
5968         .basename[0] = "umidi",
5969 };
5970
5971 static int
5972 umidi_probe(device_t dev)
5973 {
5974         struct uaudio_softc *sc = device_get_softc(dev);
5975         struct usb_attach_arg *uaa = device_get_ivars(dev);
5976         struct umidi_chan *chan = &sc->sc_midi_chan;
5977         struct umidi_sub_chan *sub;
5978         int unit = device_get_unit(dev);
5979         int error;
5980         uint32_t n;
5981
5982         if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI))
5983                 chan->single_command = 1;
5984
5985         if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index,
5986             chan->iface_alt_index)) {
5987                 DPRINTF("setting of alternate index failed!\n");
5988                 goto detach;
5989         }
5990         usbd_set_parent_iface(sc->sc_udev, chan->iface_index,
5991             sc->sc_mixer_iface_index);
5992
5993         error = usbd_transfer_setup(uaa->device, &chan->iface_index,
5994             chan->xfer, umidi_config, UMIDI_N_TRANSFER,
5995             chan, &chan->mtx);
5996         if (error) {
5997                 DPRINTF("error=%s\n", usbd_errstr(error));
5998                 goto detach;
5999         }
6000         if (chan->xfer[UMIDI_TX_TRANSFER] == NULL &&
6001             chan->xfer[UMIDI_RX_TRANSFER] == NULL) {
6002                 DPRINTF("no BULK or INTERRUPT MIDI endpoint(s) found\n");
6003                 goto detach;
6004         }
6005
6006         /*
6007          * Some USB MIDI device makers couldn't resist using
6008          * wMaxPacketSize = 4 for RX and TX BULK endpoints, although
6009          * that size is an unsupported value for FULL speed BULK
6010          * endpoints. The same applies to some HIGH speed MIDI devices
6011          * which are using a wMaxPacketSize different from 512 bytes.
6012          *
6013          * Refer to section 5.8.3 in USB 2.0 PDF: Cite: "All Host
6014          * Controllers are required to have support for 8-, 16-, 32-,
6015          * and 64-byte maximum packet sizes for full-speed bulk
6016          * endpoints and 512 bytes for high-speed bulk endpoints."
6017          */
6018         if (chan->xfer[UMIDI_TX_TRANSFER] != NULL &&
6019             usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER]))
6020                 chan->single_command = 1;
6021
6022         if (chan->single_command != 0)
6023                 device_printf(dev, "Single command MIDI quirk enabled\n");
6024
6025         if ((chan->max_emb_jack == 0) ||
6026             (chan->max_emb_jack > UMIDI_EMB_JACK_MAX)) {
6027                 chan->max_emb_jack = UMIDI_EMB_JACK_MAX;
6028         }
6029
6030         for (n = 0; n < chan->max_emb_jack; n++) {
6031
6032                 sub = &chan->sub[n];
6033
6034                 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
6035                     &umidi_fifo_methods, &sub->fifo, unit, n,
6036                     chan->iface_index,
6037                     UID_ROOT, GID_OPERATOR, 0644);
6038                 if (error) {
6039                         goto detach;
6040                 }
6041         }
6042
6043         mtx_lock(&chan->mtx);
6044
6045         /*
6046          * NOTE: At least one device will not work properly unless the
6047          * BULK IN pipe is open all the time. This might have to do
6048          * about that the internal queues of the device overflow if we
6049          * don't read them regularly.
6050          */
6051         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
6052
6053         mtx_unlock(&chan->mtx);
6054
6055         return (0);                     /* success */
6056
6057 detach:
6058         return (ENXIO);                 /* failure */
6059 }
6060
6061 static int
6062 umidi_detach(device_t dev)
6063 {
6064         struct uaudio_softc *sc = device_get_softc(dev);
6065         struct umidi_chan *chan = &sc->sc_midi_chan;
6066         uint32_t n;
6067
6068         for (n = 0; n < UMIDI_EMB_JACK_MAX; n++)
6069                 usb_fifo_detach(&chan->sub[n].fifo);
6070
6071         mtx_lock(&chan->mtx);
6072
6073         usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]);
6074
6075         mtx_unlock(&chan->mtx);
6076
6077         usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
6078
6079         mtx_destroy(&chan->mtx);
6080
6081         return (0);
6082 }
6083
6084 static void
6085 uaudio_hid_rx_callback(struct usb_xfer *xfer, usb_error_t error)
6086 {
6087         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
6088         const uint8_t *buffer = usbd_xfer_get_frame_buffer(xfer, 0);
6089         struct snd_mixer *m;
6090         uint8_t id;
6091         int actlen;
6092
6093         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
6094
6095         switch (USB_GET_STATE(xfer)) {
6096         case USB_ST_TRANSFERRED:
6097                 DPRINTF("actlen=%d\n", actlen);
6098
6099                 if (actlen != 0 &&
6100                     (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) {
6101                         id = *buffer;
6102                         buffer++;
6103                         actlen--;
6104                 } else {
6105                         id = 0;
6106                 }
6107
6108                 m = sc->sc_mixer_dev;
6109
6110                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) &&
6111                     (sc->sc_hid.mute_id == id) &&
6112                     hid_get_data(buffer, actlen,
6113                     &sc->sc_hid.mute_loc)) {
6114
6115                         DPRINTF("Mute toggle\n");
6116
6117                         mixer_hwvol_mute_locked(m);
6118                 }
6119
6120                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) &&
6121                     (sc->sc_hid.volume_up_id == id) &&
6122                     hid_get_data(buffer, actlen,
6123                     &sc->sc_hid.volume_up_loc)) {
6124
6125                         DPRINTF("Volume Up\n");
6126
6127                         mixer_hwvol_step_locked(m, 1, 1);
6128                 }
6129
6130                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) &&
6131                     (sc->sc_hid.volume_down_id == id) &&
6132                     hid_get_data(buffer, actlen,
6133                     &sc->sc_hid.volume_down_loc)) {
6134
6135                         DPRINTF("Volume Down\n");
6136
6137                         mixer_hwvol_step_locked(m, -1, -1);
6138                 }
6139
6140         case USB_ST_SETUP:
6141 tr_setup:
6142                 /* check if we can put more data into the FIFO */
6143                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
6144                 usbd_transfer_submit(xfer);
6145                 break;
6146
6147         default:                        /* Error */
6148
6149                 DPRINTF("error=%s\n", usbd_errstr(error));
6150
6151                 if (error != USB_ERR_CANCELLED) {
6152                         /* try to clear stall first */
6153                         usbd_xfer_set_stall(xfer);
6154                         goto tr_setup;
6155                 }
6156                 break;
6157         }
6158 }
6159
6160 static int
6161 uaudio_hid_probe(struct uaudio_softc *sc,
6162     struct usb_attach_arg *uaa)
6163 {
6164         void *d_ptr;
6165         uint32_t flags;
6166         uint16_t d_len;
6167         uint8_t id;
6168         int error;
6169
6170         if (!(sc->sc_hid.flags & UAUDIO_HID_VALID))
6171                 return (-1);
6172
6173         if (sc->sc_mixer_lock == NULL)
6174                 return (-1);
6175
6176         /* Get HID descriptor */
6177         error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
6178             &d_len, M_TEMP, sc->sc_hid.iface_index);
6179
6180         if (error) {
6181                 DPRINTF("error reading report description\n");
6182                 return (-1);
6183         }
6184
6185         /* check if there is an ID byte */
6186         hid_report_size(d_ptr, d_len, hid_input, &id);
6187
6188         if (id != 0)
6189                 sc->sc_hid.flags |= UAUDIO_HID_HAS_ID;
6190
6191         if (hid_locate(d_ptr, d_len,
6192             HID_USAGE2(HUP_CONSUMER, 0xE9 /* Volume Increment */),
6193             hid_input, 0, &sc->sc_hid.volume_up_loc, &flags,
6194             &sc->sc_hid.volume_up_id)) {
6195                 if (flags & HIO_VARIABLE)
6196                         sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP;
6197                 DPRINTFN(1, "Found Volume Up key\n");
6198         }
6199
6200         if (hid_locate(d_ptr, d_len,
6201             HID_USAGE2(HUP_CONSUMER, 0xEA /* Volume Decrement */),
6202             hid_input, 0, &sc->sc_hid.volume_down_loc, &flags,
6203             &sc->sc_hid.volume_down_id)) {
6204                 if (flags & HIO_VARIABLE)
6205                         sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN;
6206                 DPRINTFN(1, "Found Volume Down key\n");
6207         }
6208
6209         if (hid_locate(d_ptr, d_len,
6210             HID_USAGE2(HUP_CONSUMER, 0xE2 /* Mute */),
6211             hid_input, 0, &sc->sc_hid.mute_loc, &flags,
6212             &sc->sc_hid.mute_id)) {
6213                 if (flags & HIO_VARIABLE)
6214                         sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE;
6215                 DPRINTFN(1, "Found Mute key\n");
6216         }
6217
6218         free(d_ptr, M_TEMP);
6219
6220         if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP |
6221             UAUDIO_HID_HAS_VOLUME_DOWN |
6222             UAUDIO_HID_HAS_MUTE))) {
6223                 DPRINTFN(1, "Did not find any volume related keys\n");
6224                 return (-1);
6225         }
6226
6227         /* prevent the uhid driver from attaching */
6228         usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index,
6229             sc->sc_mixer_iface_index);
6230
6231         /* allocate USB transfers */
6232         error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index,
6233             sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER,
6234             sc, sc->sc_mixer_lock);
6235         if (error) {
6236                 DPRINTF("error=%s\n", usbd_errstr(error));
6237                 return (-1);
6238         }
6239         return (0);
6240 }
6241
6242 static void
6243 uaudio_hid_detach(struct uaudio_softc *sc)
6244 {
6245         usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER);
6246 }
6247
6248 DRIVER_MODULE_ORDERED(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0, SI_ORDER_ANY);
6249 MODULE_DEPEND(uaudio, usb, 1, 1, 1);
6250 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
6251 MODULE_VERSION(uaudio, 1);