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