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