sys/dev/sound/usb/uaudio.c

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