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