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