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