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