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