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  * SPDX-License-Identifier: BSD-2-Clause-NetBSD
   6  *
   7  * Copyright (c) 1999 The NetBSD Foundation, Inc.
   8  * All rights reserved.
   9  *
  10  * This code is derived from software contributed to The NetBSD Foundation
  11  * by Lennart Augustsson (lennart@augustsson.net) at
  12  * Carlstedt Research & Technology.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  26  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  27  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 /*
  40  * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf
  41  *                  http://www.usb.org/developers/devclass_docs/frmts10.pdf
  42  *                  http://www.usb.org/developers/devclass_docs/termt10.pdf
  43  */
  44
  45 /*
  46  * Also merged:
  47  *  $NetBSD: uaudio.c,v 1.94 2005/01/15 15:19:53 kent Exp $
  48  *  $NetBSD: uaudio.c,v 1.95 2005/01/16 06:02:19 dsainty Exp $
  49  *  $NetBSD: uaudio.c,v 1.96 2005/01/16 12:46:00 kent Exp $
  50  *  $NetBSD: uaudio.c,v 1.97 2005/02/24 08:19:38 martin Exp $
  51  */
  52
  53 #include <sys/stdint.h>
  54 #include <sys/stddef.h>
  55 #include <sys/param.h>
  56 #include <sys/queue.h>
  57 #include <sys/types.h>
  58 #include <sys/systm.h>
  59 #include <sys/kernel.h>
  60 #include <sys/bus.h>
  61 #include <sys/module.h>
  62 #include <sys/lock.h>
  63 #include <sys/mutex.h>
  64 #include <sys/condvar.h>
  65 #include <sys/sysctl.h>
  66 #include <sys/sx.h>
  67 #include <sys/unistd.h>
  68 #include <sys/callout.h>
  69 #include <sys/malloc.h>
  70 #include <sys/priv.h>
  71
  72 #include "usbdevs.h"
  73 #include <dev/usb/usb.h>
  74 #include <dev/usb/usbdi.h>
  75 #include <dev/usb/usbdi_util.h>
  76 #include <dev/usb/usbhid.h>
  77 #include <dev/usb/usb_request.h>
  78 #include <dev/usb/usb_process.h>
  79
  80 #define USB_DEBUG_VAR uaudio_debug
  81 #include <dev/usb/usb_debug.h>
  82
  83 #include <dev/usb/quirk/usb_quirk.h>
  84
  85 #include <sys/reboot.h>                 /* for bootverbose */
  86
  87 #ifdef HAVE_KERNEL_OPTION_HEADERS
  88 #include "opt_snd.h"
  89 #endif
  90
  91 #include <dev/sound/pcm/sound.h>
  92 #include <dev/sound/usb/uaudioreg.h>
  93 #include <dev/sound/usb/uaudio.h>
  94 #include <dev/sound/chip.h>
  95 #include "feeder_if.h"
  96
  97 static int uaudio_default_rate = 0;             /* use rate list */
  98 static int uaudio_default_bits = 32;
  99 static int uaudio_default_channels = 0;         /* use default */
 100 static int uaudio_buffer_ms = 8;
 101
 102 #ifdef USB_DEBUG
 103 static int uaudio_debug;
 104
 105 static SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
 106     "USB uaudio");
 107
 108 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RWTUN,
 109     &uaudio_debug, 0, "uaudio debug level");
 110 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_rate, CTLFLAG_RWTUN,
 111     &uaudio_default_rate, 0, "uaudio default sample rate");
 112 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_bits, CTLFLAG_RWTUN,
 113     &uaudio_default_bits, 0, "uaudio default sample bits");
 114 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_channels, CTLFLAG_RWTUN,
 115     &uaudio_default_channels, 0, "uaudio default sample channels");
 116
 117 static int
 118 uaudio_buffer_ms_sysctl(SYSCTL_HANDLER_ARGS)
 119 {
 120         int err, val;
 121
 122         val = uaudio_buffer_ms;
 123         err = sysctl_handle_int(oidp, &val, 0, req);
 124
 125         if (err != 0 || req->newptr == NULL || val == uaudio_buffer_ms)
 126                 return (err);
 127
 128         if (val > 8)
 129                 val = 8;
 130         else if (val < 2)
 131                 val = 2;
 132
 133         uaudio_buffer_ms = val;
 134
 135         return (0);
 136 }
 137 SYSCTL_PROC(_hw_usb_uaudio, OID_AUTO, buffer_ms,
 138     CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0, sizeof(int),
 139     uaudio_buffer_ms_sysctl, "I",
 140     "uaudio buffering delay from 2ms to 8ms");
 141 #else
 142 #define uaudio_debug 0
 143 #endif
 144
 145 #define UAUDIO_NFRAMES          64      /* must be factor of 8 due HS-USB */
 146 #define UAUDIO_NCHANBUFS        2       /* number of outstanding request */
 147 #define UAUDIO_RECURSE_LIMIT    255     /* rounds */
 148 #define UAUDIO_CHANNELS_MAX     MIN(64, AFMT_CHANNEL_MAX)
 149 #define UAUDIO_MATRIX_MAX       8       /* channels */
 150
 151 #define MAKE_WORD(h,l) (((h) << 8) | (l))
 152 #define BIT_TEST(bm,bno) (((bm)[(bno) / 8] >> (7 - ((bno) % 8))) & 1)
 153 #define UAUDIO_MAX_CHAN(x) (x)
 154 #define MIX(sc) ((sc)->sc_mixer_node)
 155
 156 union uaudio_asid {
 157         const struct usb_audio_streaming_interface_descriptor *v1;
 158         const struct usb_audio20_streaming_interface_descriptor *v2;
 159 };
 160
 161 union uaudio_asf1d {
 162         const struct usb_audio_streaming_type1_descriptor *v1;
 163         const struct usb_audio20_streaming_type1_descriptor *v2;
 164 };
 165
 166 union uaudio_sed {
 167         const struct usb_audio_streaming_endpoint_descriptor *v1;
 168         const struct usb_audio20_streaming_endpoint_descriptor *v2;
 169 };
 170
 171 struct uaudio_mixer_node {
 172         const char *name;
 173
 174         int32_t minval;
 175         int32_t maxval;
 176 #define MIX_MAX_CHAN 16
 177         int32_t wValue[MIX_MAX_CHAN];   /* using nchan */
 178         uint32_t mul;
 179         uint32_t ctl;
 180
 181         int wData[MIX_MAX_CHAN];        /* using nchan */
 182         uint16_t wIndex;
 183
 184         uint8_t update[(MIX_MAX_CHAN + 7) / 8];
 185         uint8_t nchan;
 186         uint8_t type;
 187 #define MIX_ON_OFF      1
 188 #define MIX_SIGNED_16   2
 189 #define MIX_UNSIGNED_16 3
 190 #define MIX_SIGNED_8    4
 191 #define MIX_SELECTOR    5
 192 #define MIX_UNKNOWN     6
 193 #define MIX_SIZE(n) ((((n) == MIX_SIGNED_16) || \
 194                       ((n) == MIX_UNSIGNED_16)) ? 2 : 1)
 195 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
 196
 197 #define MAX_SELECTOR_INPUT_PIN 256
 198         uint8_t slctrtype[MAX_SELECTOR_INPUT_PIN];
 199         uint8_t val_default;
 200
 201         uint8_t desc[64];
 202
 203         struct uaudio_mixer_node *next;
 204 };
 205
 206 struct uaudio_configure_msg {
 207         struct usb_proc_msg hdr;
 208         struct uaudio_softc *sc;
 209 };
 210
 211 #define CHAN_MAX_ALT 24
 212
 213 struct uaudio_chan_alt {
 214         union uaudio_asf1d p_asf1d;
 215         union uaudio_sed p_sed;
 216         const usb_endpoint_descriptor_audio_t *p_ed1;
 217         const struct uaudio_format *p_fmt;
 218         const struct usb_config *usb_cfg;
 219         uint32_t sample_rate;   /* in Hz */
 220         uint16_t sample_size;
 221         uint8_t iface_index;
 222         uint8_t iface_alt_index;
 223         uint8_t channels;
 224 };
 225
 226 struct uaudio_chan {
 227         struct pcmchan_caps pcm_cap;    /* capabilities */
 228         struct uaudio_chan_alt usb_alt[CHAN_MAX_ALT];
 229         struct snd_dbuf *pcm_buf;
 230         struct mtx *pcm_mtx;            /* lock protecting this structure */
 231         struct uaudio_softc *priv_sc;
 232         struct pcm_channel *pcm_ch;
 233         struct usb_xfer *xfer[UAUDIO_NCHANBUFS + 1];
 234
 235         uint8_t *buf;                   /* pointer to buffer */
 236         uint8_t *start;                 /* upper layer buffer start */
 237         uint8_t *end;                   /* upper layer buffer end */
 238         uint8_t *cur;                   /* current position in upper layer
 239                                          * buffer */
 240
 241         uint32_t intr_frames;           /* in units */
 242         uint32_t frames_per_second;
 243         uint32_t sample_rem;
 244         uint32_t sample_curr;
 245         uint32_t max_buf;
 246         int32_t jitter_rem;
 247         int32_t jitter_curr;
 248
 249         int feedback_rate;
 250
 251         uint32_t pcm_format[2];
 252
 253         uint16_t bytes_per_frame[2];
 254
 255         uint32_t intr_counter;
 256         uint32_t running;
 257         uint32_t num_alt;
 258         uint32_t cur_alt;
 259         uint32_t set_alt;
 260         uint32_t operation;
 261 #define CHAN_OP_NONE 0
 262 #define CHAN_OP_START 1
 263 #define CHAN_OP_STOP 2
 264 #define CHAN_OP_DRAIN 3
 265
 266         uint8_t iface_index;
 267 };
 268
 269 #define UMIDI_EMB_JACK_MAX   16         /* units */
 270 #define UMIDI_TX_FRAMES    256          /* units */
 271 #define UMIDI_TX_BUFFER    (UMIDI_TX_FRAMES * 4)        /* bytes */
 272
 273 enum {
 274         UMIDI_TX_TRANSFER,
 275         UMIDI_RX_TRANSFER,
 276         UMIDI_N_TRANSFER,
 277 };
 278
 279 struct umidi_sub_chan {
 280         struct usb_fifo_sc fifo;
 281         uint8_t *temp_cmd;
 282         uint8_t temp_0[4];
 283         uint8_t temp_1[4];
 284         uint8_t state;
 285 #define UMIDI_ST_UNKNOWN   0            /* scan for command */
 286 #define UMIDI_ST_1PARAM    1
 287 #define UMIDI_ST_2PARAM_1  2
 288 #define UMIDI_ST_2PARAM_2  3
 289 #define UMIDI_ST_SYSEX_0   4
 290 #define UMIDI_ST_SYSEX_1   5
 291 #define UMIDI_ST_SYSEX_2   6
 292
 293         uint8_t read_open:1;
 294         uint8_t write_open:1;
 295         uint8_t unused:6;
 296 };
 297
 298 struct umidi_chan {
 299
 300         struct umidi_sub_chan sub[UMIDI_EMB_JACK_MAX];
 301         struct mtx mtx;
 302
 303         struct usb_xfer *xfer[UMIDI_N_TRANSFER];
 304
 305         uint8_t iface_index;
 306         uint8_t iface_alt_index;
 307
 308         uint8_t read_open_refcount;
 309         uint8_t write_open_refcount;
 310
 311         uint8_t curr_cable;
 312         uint8_t max_emb_jack;
 313         uint8_t valid;
 314         uint8_t single_command;
 315 };
 316
 317 struct uaudio_search_result {
 318         uint8_t bit_input[(256 + 7) / 8];
 319         uint8_t bit_output[(256 + 7) / 8];
 320         uint8_t recurse_level;
 321         uint8_t id_max;
 322         uint8_t is_input;
 323 };
 324
 325 enum {
 326         UAUDIO_HID_RX_TRANSFER,
 327         UAUDIO_HID_N_TRANSFER,
 328 };
 329
 330 struct uaudio_hid {
 331         struct usb_xfer *xfer[UAUDIO_HID_N_TRANSFER];
 332         struct hid_location volume_up_loc;
 333         struct hid_location volume_down_loc;
 334         struct hid_location mute_loc;
 335         uint32_t flags;
 336 #define UAUDIO_HID_VALID                0x0001
 337 #define UAUDIO_HID_HAS_ID               0x0002
 338 #define UAUDIO_HID_HAS_VOLUME_UP        0x0004
 339 #define UAUDIO_HID_HAS_VOLUME_DOWN      0x0008
 340 #define UAUDIO_HID_HAS_MUTE             0x0010
 341         uint8_t iface_index;
 342         uint8_t volume_up_id;
 343         uint8_t volume_down_id;
 344         uint8_t mute_id;
 345 };
 346
 347 #define UAUDIO_SPDIF_OUT        0x01    /* Enable S/PDIF output */
 348 #define UAUDIO_SPDIF_OUT_48K    0x02    /* Out sample rate = 48K */
 349 #define UAUDIO_SPDIF_OUT_96K    0x04    /* Out sample rate = 96K */
 350 #define UAUDIO_SPDIF_IN_MIX     0x10    /* Input mix enable */
 351
 352 #define UAUDIO_MAX_CHILD 2
 353
 354 struct uaudio_softc_child {
 355         device_t pcm_device;
 356         struct mtx *mixer_lock;
 357         struct snd_mixer *mixer_dev;
 358
 359         uint32_t mix_info;
 360         uint32_t recsrc_info;
 361
 362         uint8_t pcm_registered:1;
 363         uint8_t mixer_init:1;
 364 };
 365
 366 struct uaudio_softc {
 367         struct sbuf sc_sndstat;
 368         struct sndcard_func sc_sndcard_func;
 369         struct uaudio_chan sc_rec_chan[UAUDIO_MAX_CHILD];
 370         struct uaudio_chan sc_play_chan[UAUDIO_MAX_CHILD];
 371         struct umidi_chan sc_midi_chan;
 372         struct uaudio_hid sc_hid;
 373         struct uaudio_search_result sc_mixer_clocks;
 374         struct uaudio_mixer_node sc_mixer_node;
 375         struct uaudio_configure_msg sc_config_msg[2];
 376         struct uaudio_softc_child sc_child[UAUDIO_MAX_CHILD];
 377
 378         struct usb_device *sc_udev;
 379         struct usb_xfer *sc_mixer_xfer[1];
 380         struct uaudio_mixer_node *sc_mixer_root;
 381         struct uaudio_mixer_node *sc_mixer_curr;
 382         int     (*sc_set_spdif_fn) (struct uaudio_softc *, int);
 383
 384         uint16_t sc_audio_rev;
 385         uint16_t sc_mixer_count;
 386
 387         uint8_t sc_mixer_iface_index;
 388         uint8_t sc_mixer_iface_no;
 389         uint8_t sc_mixer_chan;
 390         uint8_t sc_sndstat_valid:1;
 391         uint8_t sc_uq_audio_swap_lr:1;
 392         uint8_t sc_uq_au_inp_async:1;
 393         uint8_t sc_uq_au_no_xu:1;
 394         uint8_t sc_uq_bad_adc:1;
 395         uint8_t sc_uq_au_vendor_class:1;
 396         uint8_t sc_pcm_bitperfect:1;
 397 };
 398
 399 struct uaudio_terminal_node {
 400         union {
 401                 const struct usb_descriptor *desc;
 402                 const struct usb_audio_input_terminal *it_v1;
 403                 const struct usb_audio_output_terminal *ot_v1;
 404                 const struct usb_audio_mixer_unit_0 *mu_v1;
 405                 const struct usb_audio_selector_unit *su_v1;
 406                 const struct usb_audio_feature_unit *fu_v1;
 407                 const struct usb_audio_processing_unit_0 *pu_v1;
 408                 const struct usb_audio_extension_unit_0 *eu_v1;
 409                 const struct usb_audio20_clock_source_unit *csrc_v2;
 410                 const struct usb_audio20_clock_selector_unit_0 *csel_v2;
 411                 const struct usb_audio20_clock_multiplier_unit *cmul_v2;
 412                 const struct usb_audio20_input_terminal *it_v2;
 413                 const struct usb_audio20_output_terminal *ot_v2;
 414                 const struct usb_audio20_mixer_unit_0 *mu_v2;
 415                 const struct usb_audio20_selector_unit *su_v2;
 416                 const struct usb_audio20_feature_unit *fu_v2;
 417                 const struct usb_audio20_sample_rate_unit *ru_v2;
 418                 const struct usb_audio20_processing_unit_0 *pu_v2;
 419                 const struct usb_audio20_extension_unit_0 *eu_v2;
 420                 const struct usb_audio20_effect_unit *ef_v2;
 421         }       u;
 422         struct uaudio_search_result usr;
 423         struct uaudio_terminal_node *root;
 424 };
 425
 426 struct uaudio_format {
 427         uint16_t wFormat;
 428         uint8_t bPrecision;
 429         uint32_t freebsd_fmt;
 430         const char *description;
 431 };
 432
 433 static const struct uaudio_format uaudio10_formats[] = {
 434
 435         {UA_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"},
 436         {UA_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"},
 437         {UA_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"},
 438         {UA_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"},
 439
 440         {UA_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"},
 441         {UA_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"},
 442         {UA_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"},
 443         {UA_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"},
 444
 445         {UA_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"},
 446         {UA_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"},
 447
 448         {0, 0, 0, NULL}
 449 };
 450
 451 static const struct uaudio_format uaudio20_formats[] = {
 452
 453         {UA20_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"},
 454         {UA20_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"},
 455         {UA20_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"},
 456         {UA20_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"},
 457
 458         {UA20_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"},
 459         {UA20_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"},
 460         {UA20_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"},
 461         {UA20_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"},
 462
 463         {UA20_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"},
 464         {UA20_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"},
 465
 466         {0, 0, 0, NULL}
 467 };
 468
 469 /* prototypes */
 470
 471 static device_probe_t uaudio_probe;
 472 static device_attach_t uaudio_attach;
 473 static device_detach_t uaudio_detach;
 474
 475 static usb_callback_t uaudio_chan_play_callback;
 476 static usb_callback_t uaudio_chan_play_sync_callback;
 477 static usb_callback_t uaudio_chan_record_callback;
 478 static usb_callback_t uaudio_chan_record_sync_callback;
 479 static usb_callback_t uaudio_mixer_write_cfg_callback;
 480 static usb_callback_t umidi_bulk_read_callback;
 481 static usb_callback_t umidi_bulk_write_callback;
 482 static usb_callback_t uaudio_hid_rx_callback;
 483
 484 static usb_proc_callback_t uaudio_configure_msg;
 485
 486 /* ==== USB mixer ==== */
 487
 488 static int uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS);
 489 static void uaudio_mixer_ctl_free(struct uaudio_softc *);
 490 static void uaudio_mixer_register_sysctl(struct uaudio_softc *, device_t, unsigned);
 491 static void uaudio_mixer_reload_all(struct uaudio_softc *);
 492 static void uaudio_mixer_controls_create_ftu(struct uaudio_softc *);
 493
 494 /* ==== USB audio v1.0 ==== */
 495
 496 static void     uaudio_mixer_add_mixer(struct uaudio_softc *,
 497                     const struct uaudio_terminal_node *, int);
 498 static void     uaudio_mixer_add_selector(struct uaudio_softc *,
 499                     const struct uaudio_terminal_node *, int);
 500 static uint32_t uaudio_mixer_feature_get_bmaControls(
 501                     const struct usb_audio_feature_unit *, uint8_t);
 502 static void     uaudio_mixer_add_feature(struct uaudio_softc *,
 503                     const struct uaudio_terminal_node *, int);
 504 static void     uaudio_mixer_add_processing_updown(struct uaudio_softc *,
 505                     const struct uaudio_terminal_node *, int);
 506 static void     uaudio_mixer_add_processing(struct uaudio_softc *,
 507                     const struct uaudio_terminal_node *, int);
 508 static void     uaudio_mixer_add_extension(struct uaudio_softc *,
 509                     const struct uaudio_terminal_node *, int);
 510 static struct   usb_audio_cluster uaudio_mixer_get_cluster(uint8_t,
 511                     const struct uaudio_terminal_node *);
 512 static uint16_t uaudio_mixer_determine_class(const struct uaudio_terminal_node *);
 513 static void     uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *,
 514                     const uint8_t *, uint8_t, struct uaudio_search_result *);
 515 static const void *uaudio_mixer_verify_desc(const void *, uint32_t);
 516 static usb_error_t uaudio_set_speed(struct usb_device *, uint8_t, uint32_t);
 517 static int      uaudio_mixer_get(struct usb_device *, uint16_t, uint8_t,
 518                     struct uaudio_mixer_node *);
 519
 520 /* ==== USB audio v2.0 ==== */
 521
 522 static void     uaudio20_mixer_add_mixer(struct uaudio_softc *,
 523                     const struct uaudio_terminal_node *, int);
 524 static void     uaudio20_mixer_add_selector(struct uaudio_softc *,
 525                     const struct uaudio_terminal_node *, int);
 526 static void     uaudio20_mixer_add_feature(struct uaudio_softc *,
 527                     const struct uaudio_terminal_node *, int);
 528 static struct   usb_audio20_cluster uaudio20_mixer_get_cluster(uint8_t,
 529                     const struct uaudio_terminal_node *);
 530 static uint16_t uaudio20_mixer_determine_class(const struct uaudio_terminal_node *);
 531 static void     uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *,
 532                     const uint8_t *, uint8_t, struct uaudio_search_result *);
 533 static const void *uaudio20_mixer_verify_desc(const void *, uint32_t);
 534 static usb_error_t uaudio20_set_speed(struct usb_device *, uint8_t,
 535                     uint8_t, uint32_t);
 536
 537 /* USB audio v1.0 and v2.0 */
 538
 539 static void     uaudio_chan_fill_info_sub(struct uaudio_softc *,
 540                     struct usb_device *, uint32_t, uint8_t, uint8_t);
 541 static void     uaudio_chan_fill_info(struct uaudio_softc *,
 542                     struct usb_device *);
 543 static void     uaudio_mixer_add_ctl_sub(struct uaudio_softc *,
 544                     struct uaudio_mixer_node *);
 545 static void     uaudio_mixer_add_ctl(struct uaudio_softc *,
 546                     struct uaudio_mixer_node *);
 547 static void     uaudio_mixer_fill_info(struct uaudio_softc *,
 548                     struct usb_device *, void *);
 549 static int      uaudio_mixer_signext(uint8_t, int);
 550 static void     uaudio_mixer_init(struct uaudio_softc *, unsigned);
 551 static uint8_t  umidi_convert_to_usb(struct umidi_sub_chan *, uint8_t, uint8_t);
 552 static struct   umidi_sub_chan *umidi_sub_by_fifo(struct usb_fifo *);
 553 static void     umidi_start_read(struct usb_fifo *);
 554 static void     umidi_stop_read(struct usb_fifo *);
 555 static void     umidi_start_write(struct usb_fifo *);
 556 static void     umidi_stop_write(struct usb_fifo *);
 557 static int      umidi_open(struct usb_fifo *, int);
 558 static int      umidi_ioctl(struct usb_fifo *, u_long cmd, void *, int);
 559 static void     umidi_close(struct usb_fifo *, int);
 560 static void     umidi_init(device_t dev);
 561 static int      umidi_probe(device_t dev);
 562 static int      umidi_detach(device_t dev);
 563 static int      uaudio_hid_probe(struct uaudio_softc *sc,
 564                     struct usb_attach_arg *uaa);
 565 static void     uaudio_hid_detach(struct uaudio_softc *sc);
 566
 567 #ifdef USB_DEBUG
 568 static void     uaudio_chan_dump_ep_desc(
 569                     const usb_endpoint_descriptor_audio_t *);
 570 #endif
 571
 572 static const struct usb_config
 573         uaudio_cfg_record[UAUDIO_NCHANBUFS + 1] = {
 574         [0] = {
 575                 .type = UE_ISOCHRONOUS,
 576                 .endpoint = UE_ADDR_ANY,
 577                 .direction = UE_DIR_IN,
 578                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 579                 .frames = UAUDIO_NFRAMES,
 580                 .flags = {.short_xfer_ok = 1,},
 581                 .callback = &uaudio_chan_record_callback,
 582         },
 583
 584         [1] = {
 585                 .type = UE_ISOCHRONOUS,
 586                 .endpoint = UE_ADDR_ANY,
 587                 .direction = UE_DIR_IN,
 588                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 589                 .frames = UAUDIO_NFRAMES,
 590                 .flags = {.short_xfer_ok = 1,},
 591                 .callback = &uaudio_chan_record_callback,
 592         },
 593
 594         [2] = {
 595                 .type = UE_ISOCHRONOUS,
 596                 .endpoint = UE_ADDR_ANY,
 597                 .direction = UE_DIR_OUT,
 598                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 599                 .frames = 1,
 600                 .flags = {.no_pipe_ok = 1,.short_xfer_ok = 1,},
 601                 .callback = &uaudio_chan_record_sync_callback,
 602         },
 603 };
 604
 605 static const struct usb_config
 606         uaudio_cfg_play[UAUDIO_NCHANBUFS + 1] = {
 607         [0] = {
 608                 .type = UE_ISOCHRONOUS,
 609                 .endpoint = UE_ADDR_ANY,
 610                 .direction = UE_DIR_OUT,
 611                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 612                 .frames = UAUDIO_NFRAMES,
 613                 .flags = {.short_xfer_ok = 1,},
 614                 .callback = &uaudio_chan_play_callback,
 615         },
 616
 617         [1] = {
 618                 .type = UE_ISOCHRONOUS,
 619                 .endpoint = UE_ADDR_ANY,
 620                 .direction = UE_DIR_OUT,
 621                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 622                 .frames = UAUDIO_NFRAMES,
 623                 .flags = {.short_xfer_ok = 1,},
 624                 .callback = &uaudio_chan_play_callback,
 625         },
 626
 627         [2] = {
 628                 .type = UE_ISOCHRONOUS,
 629                 .endpoint = UE_ADDR_ANY,
 630                 .direction = UE_DIR_IN,
 631                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 632                 .frames = 1,
 633                 .flags = {.no_pipe_ok = 1,.short_xfer_ok = 1,},
 634                 .callback = &uaudio_chan_play_sync_callback,
 635         },
 636 };
 637
 638 static const struct usb_config
 639         uaudio_mixer_config[1] = {
 640         [0] = {
 641                 .type = UE_CONTROL,
 642                 .endpoint = 0x00,       /* Control pipe */
 643                 .direction = UE_DIR_ANY,
 644                 .bufsize = (sizeof(struct usb_device_request) + 4),
 645                 .callback = &uaudio_mixer_write_cfg_callback,
 646                 .timeout = 1000,        /* 1 second */
 647         },
 648 };
 649
 650 static const
 651 uint8_t umidi_cmd_to_len[16] = {
 652         [0x0] = 0,                      /* reserved */
 653         [0x1] = 0,                      /* reserved */
 654         [0x2] = 2,                      /* bytes */
 655         [0x3] = 3,                      /* bytes */
 656         [0x4] = 3,                      /* bytes */
 657         [0x5] = 1,                      /* bytes */
 658         [0x6] = 2,                      /* bytes */
 659         [0x7] = 3,                      /* bytes */
 660         [0x8] = 3,                      /* bytes */
 661         [0x9] = 3,                      /* bytes */
 662         [0xA] = 3,                      /* bytes */
 663         [0xB] = 3,                      /* bytes */
 664         [0xC] = 2,                      /* bytes */
 665         [0xD] = 2,                      /* bytes */
 666         [0xE] = 3,                      /* bytes */
 667         [0xF] = 1,                      /* bytes */
 668 };
 669
 670 static const struct usb_config
 671         umidi_config[UMIDI_N_TRANSFER] = {
 672         [UMIDI_TX_TRANSFER] = {
 673                 .type = UE_BULK,
 674                 .endpoint = UE_ADDR_ANY,
 675                 .direction = UE_DIR_OUT,
 676                 .bufsize = UMIDI_TX_BUFFER,
 677                 .flags = {.no_pipe_ok = 1},
 678                 .callback = &umidi_bulk_write_callback,
 679         },
 680
 681         [UMIDI_RX_TRANSFER] = {
 682                 .type = UE_BULK,
 683                 .endpoint = UE_ADDR_ANY,
 684                 .direction = UE_DIR_IN,
 685                 .bufsize = 4,   /* bytes */
 686                 .flags = {.short_xfer_ok = 1,.proxy_buffer = 1,.no_pipe_ok = 1},
 687                 .callback = &umidi_bulk_read_callback,
 688         },
 689 };
 690
 691 static const struct usb_config
 692         uaudio_hid_config[UAUDIO_HID_N_TRANSFER] = {
 693         [UAUDIO_HID_RX_TRANSFER] = {
 694                 .type = UE_INTERRUPT,
 695                 .endpoint = UE_ADDR_ANY,
 696                 .direction = UE_DIR_IN,
 697                 .bufsize = 0,   /* use wMaxPacketSize */
 698                 .flags = {.short_xfer_ok = 1,},
 699                 .callback = &uaudio_hid_rx_callback,
 700         },
 701 };
 702
 703 static devclass_t uaudio_devclass;
 704
 705 static device_method_t uaudio_methods[] = {
 706         DEVMETHOD(device_probe, uaudio_probe),
 707         DEVMETHOD(device_attach, uaudio_attach),
 708         DEVMETHOD(device_detach, uaudio_detach),
 709         DEVMETHOD(device_suspend, bus_generic_suspend),
 710         DEVMETHOD(device_resume, bus_generic_resume),
 711         DEVMETHOD(device_shutdown, bus_generic_shutdown),
 712
 713         DEVMETHOD_END
 714 };
 715
 716 static driver_t uaudio_driver = {
 717         .name = "uaudio",
 718         .methods = uaudio_methods,
 719         .size = sizeof(struct uaudio_softc),
 720 };
 721
 722 /* The following table is derived from Linux's quirks-table.h */
 723 static const STRUCT_USB_HOST_ID uaudio_vendor_midi[] = {
 724         { USB_VPI(USB_VENDOR_YAMAHA, 0x1000, 0) }, /* UX256 */
 725         { USB_VPI(USB_VENDOR_YAMAHA, 0x1001, 0) }, /* MU1000 */
 726         { USB_VPI(USB_VENDOR_YAMAHA, 0x1002, 0) }, /* MU2000 */
 727         { USB_VPI(USB_VENDOR_YAMAHA, 0x1003, 0) }, /* MU500 */
 728         { USB_VPI(USB_VENDOR_YAMAHA, 0x1004, 3) }, /* UW500 */
 729         { USB_VPI(USB_VENDOR_YAMAHA, 0x1005, 0) }, /* MOTIF6 */
 730         { USB_VPI(USB_VENDOR_YAMAHA, 0x1006, 0) }, /* MOTIF7 */
 731         { USB_VPI(USB_VENDOR_YAMAHA, 0x1007, 0) }, /* MOTIF8 */
 732         { USB_VPI(USB_VENDOR_YAMAHA, 0x1008, 0) }, /* UX96 */
 733         { USB_VPI(USB_VENDOR_YAMAHA, 0x1009, 0) }, /* UX16 */
 734         { USB_VPI(USB_VENDOR_YAMAHA, 0x100a, 3) }, /* EOS BX */
 735         { USB_VPI(USB_VENDOR_YAMAHA, 0x100c, 0) }, /* UC-MX */
 736         { USB_VPI(USB_VENDOR_YAMAHA, 0x100d, 0) }, /* UC-KX */
 737         { USB_VPI(USB_VENDOR_YAMAHA, 0x100e, 0) }, /* S08 */
 738         { USB_VPI(USB_VENDOR_YAMAHA, 0x100f, 0) }, /* CLP-150 */
 739         { USB_VPI(USB_VENDOR_YAMAHA, 0x1010, 0) }, /* CLP-170 */
 740         { USB_VPI(USB_VENDOR_YAMAHA, 0x1011, 0) }, /* P-250 */
 741         { USB_VPI(USB_VENDOR_YAMAHA, 0x1012, 0) }, /* TYROS */
 742         { USB_VPI(USB_VENDOR_YAMAHA, 0x1013, 0) }, /* PF-500 */
 743         { USB_VPI(USB_VENDOR_YAMAHA, 0x1014, 0) }, /* S90 */
 744         { USB_VPI(USB_VENDOR_YAMAHA, 0x1015, 0) }, /* MOTIF-R */
 745         { USB_VPI(USB_VENDOR_YAMAHA, 0x1016, 0) }, /* MDP-5 */
 746         { USB_VPI(USB_VENDOR_YAMAHA, 0x1017, 0) }, /* CVP-204 */
 747         { USB_VPI(USB_VENDOR_YAMAHA, 0x1018, 0) }, /* CVP-206 */
 748         { USB_VPI(USB_VENDOR_YAMAHA, 0x1019, 0) }, /* CVP-208 */
 749         { USB_VPI(USB_VENDOR_YAMAHA, 0x101a, 0) }, /* CVP-210 */
 750         { USB_VPI(USB_VENDOR_YAMAHA, 0x101b, 0) }, /* PSR-1100 */
 751         { USB_VPI(USB_VENDOR_YAMAHA, 0x101c, 0) }, /* PSR-2100 */
 752         { USB_VPI(USB_VENDOR_YAMAHA, 0x101d, 0) }, /* CLP-175 */
 753         { USB_VPI(USB_VENDOR_YAMAHA, 0x101e, 0) }, /* PSR-K1 */
 754         { USB_VPI(USB_VENDOR_YAMAHA, 0x101f, 0) }, /* EZ-J24 */
 755         { USB_VPI(USB_VENDOR_YAMAHA, 0x1020, 0) }, /* EZ-250i */
 756         { USB_VPI(USB_VENDOR_YAMAHA, 0x1021, 0) }, /* MOTIF ES 6 */
 757         { USB_VPI(USB_VENDOR_YAMAHA, 0x1022, 0) }, /* MOTIF ES 7 */
 758         { USB_VPI(USB_VENDOR_YAMAHA, 0x1023, 0) }, /* MOTIF ES 8 */
 759         { USB_VPI(USB_VENDOR_YAMAHA, 0x1024, 0) }, /* CVP-301 */
 760         { USB_VPI(USB_VENDOR_YAMAHA, 0x1025, 0) }, /* CVP-303 */
 761         { USB_VPI(USB_VENDOR_YAMAHA, 0x1026, 0) }, /* CVP-305 */
 762         { USB_VPI(USB_VENDOR_YAMAHA, 0x1027, 0) }, /* CVP-307 */
 763         { USB_VPI(USB_VENDOR_YAMAHA, 0x1028, 0) }, /* CVP-309 */
 764         { USB_VPI(USB_VENDOR_YAMAHA, 0x1029, 0) }, /* CVP-309GP */
 765         { USB_VPI(USB_VENDOR_YAMAHA, 0x102a, 0) }, /* PSR-1500 */
 766         { USB_VPI(USB_VENDOR_YAMAHA, 0x102b, 0) }, /* PSR-3000 */
 767         { USB_VPI(USB_VENDOR_YAMAHA, 0x102e, 0) }, /* ELS-01/01C */
 768         { USB_VPI(USB_VENDOR_YAMAHA, 0x1030, 0) }, /* PSR-295/293 */
 769         { USB_VPI(USB_VENDOR_YAMAHA, 0x1031, 0) }, /* DGX-205/203 */
 770         { USB_VPI(USB_VENDOR_YAMAHA, 0x1032, 0) }, /* DGX-305 */
 771         { USB_VPI(USB_VENDOR_YAMAHA, 0x1033, 0) }, /* DGX-505 */
 772         { USB_VPI(USB_VENDOR_YAMAHA, 0x1034, 0) }, /* NULL */
 773         { USB_VPI(USB_VENDOR_YAMAHA, 0x1035, 0) }, /* NULL */
 774         { USB_VPI(USB_VENDOR_YAMAHA, 0x1036, 0) }, /* NULL */
 775         { USB_VPI(USB_VENDOR_YAMAHA, 0x1037, 0) }, /* NULL */
 776         { USB_VPI(USB_VENDOR_YAMAHA, 0x1038, 0) }, /* NULL */
 777         { USB_VPI(USB_VENDOR_YAMAHA, 0x1039, 0) }, /* NULL */
 778         { USB_VPI(USB_VENDOR_YAMAHA, 0x103a, 0) }, /* NULL */
 779         { USB_VPI(USB_VENDOR_YAMAHA, 0x103b, 0) }, /* NULL */
 780         { USB_VPI(USB_VENDOR_YAMAHA, 0x103c, 0) }, /* NULL */
 781         { USB_VPI(USB_VENDOR_YAMAHA, 0x103d, 0) }, /* NULL */
 782         { USB_VPI(USB_VENDOR_YAMAHA, 0x103e, 0) }, /* NULL */
 783         { USB_VPI(USB_VENDOR_YAMAHA, 0x103f, 0) }, /* NULL */
 784         { USB_VPI(USB_VENDOR_YAMAHA, 0x1040, 0) }, /* NULL */
 785         { USB_VPI(USB_VENDOR_YAMAHA, 0x1041, 0) }, /* NULL */
 786         { USB_VPI(USB_VENDOR_YAMAHA, 0x1042, 0) }, /* NULL */
 787         { USB_VPI(USB_VENDOR_YAMAHA, 0x1043, 0) }, /* NULL */
 788         { USB_VPI(USB_VENDOR_YAMAHA, 0x1044, 0) }, /* NULL */
 789         { USB_VPI(USB_VENDOR_YAMAHA, 0x1045, 0) }, /* NULL */
 790         { USB_VPI(USB_VENDOR_YAMAHA, 0x104e, 0) }, /* NULL */
 791         { USB_VPI(USB_VENDOR_YAMAHA, 0x104f, 0) }, /* NULL */
 792         { USB_VPI(USB_VENDOR_YAMAHA, 0x1050, 0) }, /* NULL */
 793         { USB_VPI(USB_VENDOR_YAMAHA, 0x1051, 0) }, /* NULL */
 794         { USB_VPI(USB_VENDOR_YAMAHA, 0x1052, 0) }, /* NULL */
 795         { USB_VPI(USB_VENDOR_YAMAHA, 0x1053, 0) }, /* NULL */
 796         { USB_VPI(USB_VENDOR_YAMAHA, 0x1054, 0) }, /* NULL */
 797         { USB_VPI(USB_VENDOR_YAMAHA, 0x1055, 0) }, /* NULL */
 798         { USB_VPI(USB_VENDOR_YAMAHA, 0x1056, 0) }, /* NULL */
 799         { USB_VPI(USB_VENDOR_YAMAHA, 0x1057, 0) }, /* NULL */
 800         { USB_VPI(USB_VENDOR_YAMAHA, 0x1058, 0) }, /* NULL */
 801         { USB_VPI(USB_VENDOR_YAMAHA, 0x1059, 0) }, /* NULL */
 802         { USB_VPI(USB_VENDOR_YAMAHA, 0x105a, 0) }, /* NULL */
 803         { USB_VPI(USB_VENDOR_YAMAHA, 0x105b, 0) }, /* NULL */
 804         { USB_VPI(USB_VENDOR_YAMAHA, 0x105c, 0) }, /* NULL */
 805         { USB_VPI(USB_VENDOR_YAMAHA, 0x105d, 0) }, /* NULL */
 806         { USB_VPI(USB_VENDOR_YAMAHA, 0x1503, 3) }, /* MOX6/MOX8 */
 807         { USB_VPI(USB_VENDOR_YAMAHA, 0x2000, 0) }, /* DGP-7 */
 808         { USB_VPI(USB_VENDOR_YAMAHA, 0x2001, 0) }, /* DGP-5 */
 809         { USB_VPI(USB_VENDOR_YAMAHA, 0x2002, 0) }, /* NULL */
 810         { USB_VPI(USB_VENDOR_YAMAHA, 0x2003, 0) }, /* NULL */
 811         { USB_VPI(USB_VENDOR_YAMAHA, 0x5000, 0) }, /* CS1D */
 812         { USB_VPI(USB_VENDOR_YAMAHA, 0x5001, 0) }, /* DSP1D */
 813         { USB_VPI(USB_VENDOR_YAMAHA, 0x5002, 0) }, /* DME32 */
 814         { USB_VPI(USB_VENDOR_YAMAHA, 0x5003, 0) }, /* DM2000 */
 815         { USB_VPI(USB_VENDOR_YAMAHA, 0x5004, 0) }, /* 02R96 */
 816         { USB_VPI(USB_VENDOR_YAMAHA, 0x5005, 0) }, /* ACU16-C */
 817         { USB_VPI(USB_VENDOR_YAMAHA, 0x5006, 0) }, /* NHB32-C */
 818         { USB_VPI(USB_VENDOR_YAMAHA, 0x5007, 0) }, /* DM1000 */
 819         { USB_VPI(USB_VENDOR_YAMAHA, 0x5008, 0) }, /* 01V96 */
 820         { USB_VPI(USB_VENDOR_YAMAHA, 0x5009, 0) }, /* SPX2000 */
 821         { USB_VPI(USB_VENDOR_YAMAHA, 0x500a, 0) }, /* PM5D */
 822         { USB_VPI(USB_VENDOR_YAMAHA, 0x500b, 0) }, /* DME64N */
 823         { USB_VPI(USB_VENDOR_YAMAHA, 0x500c, 0) }, /* DME24N */
 824         { USB_VPI(USB_VENDOR_YAMAHA, 0x500d, 0) }, /* NULL */
 825         { USB_VPI(USB_VENDOR_YAMAHA, 0x500e, 0) }, /* NULL */
 826         { USB_VPI(USB_VENDOR_YAMAHA, 0x500f, 0) }, /* NULL */
 827         { USB_VPI(USB_VENDOR_YAMAHA, 0x7000, 0) }, /* DTX */
 828         { USB_VPI(USB_VENDOR_YAMAHA, 0x7010, 0) }, /* UB99 */
 829 };
 830
 831 static const STRUCT_USB_HOST_ID __used uaudio_devs[] = {
 832         /* Generic USB audio class match */
 833         {USB_IFACE_CLASS(UICLASS_AUDIO),
 834          USB_IFACE_SUBCLASS(UISUBCLASS_AUDIOCONTROL),},
 835         /* Generic USB MIDI class match */
 836         {USB_IFACE_CLASS(UICLASS_AUDIO),
 837          USB_IFACE_SUBCLASS(UISUBCLASS_MIDISTREAM),},
 838 };
 839
 840 static unsigned
 841 uaudio_get_child_index_by_dev(struct uaudio_softc *sc, device_t dev)
 842 {
 843         unsigned i;
 844
 845         for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
 846                 if (dev == sc->sc_child[i].pcm_device)
 847                         return (i);
 848         }
 849         panic("uaudio_get_child_index_dev: Invalid device: %p\n", dev);
 850         return (0);
 851 }
 852
 853 static unsigned
 854 uaudio_get_child_index_by_chan(struct uaudio_softc *sc, struct uaudio_chan *ch)
 855 {
 856         unsigned i;
 857
 858         for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
 859                 if ((sc->sc_play_chan + i) == ch ||
 860                     (sc->sc_rec_chan + i) == ch)
 861                         return (i);
 862         }
 863         panic("uaudio_get_child_index_by_chan: Invalid chan: %p\n", ch);
 864         return (0);
 865 }
 866
 867 static int
 868 uaudio_probe(device_t dev)
 869 {
 870         struct usb_attach_arg *uaa = device_get_ivars(dev);
 871
 872         if (uaa->usb_mode != USB_MODE_HOST)
 873                 return (ENXIO);
 874
 875         /* lookup non-standard device(s) */
 876
 877         if (usbd_lookup_id_by_uaa(uaudio_vendor_midi,
 878             sizeof(uaudio_vendor_midi), uaa) == 0) {
 879                 return (BUS_PROBE_SPECIFIC);
 880         }
 881
 882         if (uaa->info.bInterfaceClass != UICLASS_AUDIO) {
 883                 if (uaa->info.bInterfaceClass != UICLASS_VENDOR ||
 884                     usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS) == 0)
 885                         return (ENXIO);
 886         }
 887
 888         /* check for AUDIO control interface */
 889
 890         if (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL) {
 891                 if (usb_test_quirk(uaa, UQ_BAD_AUDIO))
 892                         return (ENXIO);
 893                 else
 894                         return (BUS_PROBE_GENERIC);
 895         }
 896
 897         /* check for MIDI stream */
 898
 899         if (uaa->info.bInterfaceSubClass == UISUBCLASS_MIDISTREAM) {
 900                 if (usb_test_quirk(uaa, UQ_BAD_MIDI))
 901                         return (ENXIO);
 902                 else
 903                         return (BUS_PROBE_GENERIC);
 904         }
 905         return (ENXIO);
 906 }
 907
 908 /*
 909  * Set Cmedia CM6206 S/PDIF settings
 910  * Source: CM6206 Datasheet v2.3.
 911  */
 912 static int
 913 uaudio_set_spdif_cm6206(struct uaudio_softc *sc, int flags)
 914 {
 915         uint8_t cmd[2][4] = {
 916                 {0x20, 0x20, 0x00, 0},
 917                 {0x20, 0x30, 0x02, 1}
 918         };
 919         int i;
 920
 921         if (flags & UAUDIO_SPDIF_OUT)
 922                 cmd[1][1] = 0x00;
 923         else
 924                 cmd[1][1] = 0x02;
 925
 926         if (flags & UAUDIO_SPDIF_OUT_96K)
 927                 cmd[0][1] = 0x60;       /* 96K: 3'b110 */
 928
 929         if (flags & UAUDIO_SPDIF_IN_MIX)
 930                 cmd[1][1] = 0x03;       /* SPDIFMIX */
 931
 932         for (i = 0; i < 2; i++) {
 933                 if (usbd_req_set_report(sc->sc_udev, NULL,
 934                     cmd[i], sizeof(cmd[0]),
 935                     sc->sc_mixer_iface_index, UHID_OUTPUT_REPORT, 0) != 0) {
 936                         return (ENXIO);
 937                 }
 938         }
 939         return (0);
 940 }
 941
 942 static int
 943 uaudio_set_spdif_dummy(struct uaudio_softc *sc, int flags)
 944 {
 945         return (0);
 946 }
 947
 948 static int
 949 uaudio_attach(device_t dev)
 950 {
 951         struct usb_attach_arg *uaa = device_get_ivars(dev);
 952         struct uaudio_softc *sc = device_get_softc(dev);
 953         struct usb_interface_descriptor *id;
 954         usb_error_t err;
 955         unsigned i;
 956
 957         sc->sc_udev = uaa->device;
 958         sc->sc_mixer_iface_index = uaa->info.bIfaceIndex;
 959         sc->sc_mixer_iface_no = uaa->info.bIfaceNum;
 960         sc->sc_config_msg[0].hdr.pm_callback = &uaudio_configure_msg;
 961         sc->sc_config_msg[0].sc = sc;
 962         sc->sc_config_msg[1].hdr.pm_callback = &uaudio_configure_msg;
 963         sc->sc_config_msg[1].sc = sc;
 964
 965         if (usb_test_quirk(uaa, UQ_AUDIO_SWAP_LR))
 966                 sc->sc_uq_audio_swap_lr = 1;
 967
 968         if (usb_test_quirk(uaa, UQ_AU_INP_ASYNC))
 969                 sc->sc_uq_au_inp_async = 1;
 970
 971         if (usb_test_quirk(uaa, UQ_AU_NO_XU))
 972                 sc->sc_uq_au_no_xu = 1;
 973
 974         if (usb_test_quirk(uaa, UQ_BAD_ADC))
 975                 sc->sc_uq_bad_adc = 1;
 976
 977         if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS))
 978                 sc->sc_uq_au_vendor_class = 1;
 979
 980         /* set S/PDIF function */
 981         if (usb_test_quirk(uaa, UQ_AU_SET_SPDIF_CM6206))
 982                 sc->sc_set_spdif_fn = uaudio_set_spdif_cm6206;
 983         else
 984                 sc->sc_set_spdif_fn = uaudio_set_spdif_dummy;
 985
 986         umidi_init(dev);
 987
 988         device_set_usb_desc(dev);
 989
 990         id = usbd_get_interface_descriptor(uaa->iface);
 991
 992         /* must fill mixer info before channel info */
 993         uaudio_mixer_fill_info(sc, uaa->device, id);
 994
 995         /* fill channel info */
 996         uaudio_chan_fill_info(sc, uaa->device);
 997
 998         DPRINTF("audio rev %d.%02x\n",
 999             sc->sc_audio_rev >> 8,
1000             sc->sc_audio_rev & 0xff);
1001
1002         if (sc->sc_mixer_count == 0) {
1003                 if (uaa->info.idVendor == USB_VENDOR_MAUDIO &&
1004                     (uaa->info.idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA ||
1005                     uaa->info.idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA8R)) {
1006                         DPRINTF("Generating mixer descriptors\n");
1007                         uaudio_mixer_controls_create_ftu(sc);
1008                 }
1009         }
1010
1011         DPRINTF("%d mixer controls\n",
1012             sc->sc_mixer_count);
1013
1014         for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1015                 uint8_t x;
1016
1017                 if (sc->sc_play_chan[i].num_alt <= 0)
1018                         break;
1019
1020                 /*
1021                  * Need to set a default alternate interface, else
1022                  * some USB audio devices might go into an infinte
1023                  * re-enumeration loop:
1024                  */
1025                 err = usbd_set_alt_interface_index(sc->sc_udev,
1026                     sc->sc_play_chan[i].usb_alt[0].iface_index,
1027                     sc->sc_play_chan[i].usb_alt[0].iface_alt_index);
1028                 if (err) {
1029                         DPRINTF("setting of alternate index failed: %s!\n",
1030                             usbd_errstr(err));
1031                 }
1032                 for (x = 0; x != sc->sc_play_chan[i].num_alt; x++) {
1033                         device_printf(dev, "Play[%u]: %d Hz, %d ch, %s format, "
1034                             "2x%dms buffer.\n", i,
1035                             sc->sc_play_chan[i].usb_alt[x].sample_rate,
1036                             sc->sc_play_chan[i].usb_alt[x].channels,
1037                             sc->sc_play_chan[i].usb_alt[x].p_fmt->description,
1038                             uaudio_buffer_ms);
1039                 }
1040         }
1041         if (i == 0)
1042                 device_printf(dev, "No playback.\n");
1043
1044         for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1045                 uint8_t x;
1046
1047                 if (sc->sc_rec_chan[i].num_alt <= 0)
1048                         break;
1049
1050                 /*
1051                  * Need to set a default alternate interface, else
1052                  * some USB audio devices might go into an infinte
1053                  * re-enumeration loop:
1054                  */
1055                 err = usbd_set_alt_interface_index(sc->sc_udev,
1056                     sc->sc_rec_chan[i].usb_alt[0].iface_index,
1057                     sc->sc_rec_chan[i].usb_alt[0].iface_alt_index);
1058                 if (err) {
1059                         DPRINTF("setting of alternate index failed: %s!\n",
1060                             usbd_errstr(err));
1061                 }
1062                 for (x = 0; x != sc->sc_rec_chan[i].num_alt; x++) {
1063                         device_printf(dev, "Record[%u]: %d Hz, %d ch, %s format, "
1064                             "2x%dms buffer.\n", i,
1065                             sc->sc_rec_chan[i].usb_alt[x].sample_rate,
1066                             sc->sc_rec_chan[i].usb_alt[x].channels,
1067                             sc->sc_rec_chan[i].usb_alt[x].p_fmt->description,
1068                             uaudio_buffer_ms);
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("software controlled main 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_size *
1298             howmany(chan_alt->sample_rate * (UAUDIO_NFRAMES / 8), 1000);
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] = howmany(chan_alt->sample_rate, fps) *
1417             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 | CTLFLAG_MPSAFE, 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 | CTLFLAG_MPSAFE, NULL,
2999                             "Mixer control nodes");
3000
3001                         if (control_tree == NULL)
3002                                 continue;
3003
3004                         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
3005                             SYSCTL_CHILDREN(control_tree),
3006                             OID_AUTO, "val",
3007                             CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
3008                             sc, pmc->wValue[chan],
3009                             uaudio_mixer_sysctl_handler, "I", "Current value");
3010
3011                         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3012                             SYSCTL_CHILDREN(control_tree),
3013                             OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval,
3014                             "Minimum value");
3015
3016                         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3017                             SYSCTL_CHILDREN(control_tree),
3018                             OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval,
3019                             "Maximum value");
3020
3021                         SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
3022                             SYSCTL_CHILDREN(control_tree),
3023                             OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0,
3024                             "Description");
3025                 }
3026         }
3027 }
3028
3029 /* M-Audio FastTrack Ultra Mixer Description */
3030 /* Origin: Linux USB Audio driver */
3031 static void
3032 uaudio_mixer_controls_create_ftu(struct uaudio_softc *sc)
3033 {
3034         int chx;
3035         int chy;
3036
3037         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3038         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3039         MIX(sc).wValue[0] = MAKE_WORD(8, 0);
3040         MIX(sc).type = MIX_UNSIGNED_16;
3041         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3042         MIX(sc).name = "effect";
3043         MIX(sc).minval = 0;
3044         MIX(sc).maxval = 7;
3045         MIX(sc).mul = 7;
3046         MIX(sc).nchan = 1;
3047         MIX(sc).update[0] = 1;
3048         strlcpy(MIX(sc).desc, "Room1,2,3,Hall1,2,Plate,Delay,Echo", sizeof(MIX(sc).desc));
3049         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3050
3051         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3052         MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3053
3054         for (chx = 0; chx != 8; chx++) {
3055                 for (chy = 0; chy != 8; chy++) {
3056
3057                         MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1);
3058                         MIX(sc).type = MIX_SIGNED_16;
3059                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3060                         MIX(sc).name = "mix_rec";
3061                         MIX(sc).nchan = 1;
3062                         MIX(sc).update[0] = 1;
3063                         MIX(sc).val_default = 0;
3064                         snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3065                             "AIn%d - Out%d Record Volume", chy + 1, chx + 1);
3066
3067                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3068
3069                         MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1 + 8);
3070                         MIX(sc).type = MIX_SIGNED_16;
3071                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3072                         MIX(sc).name = "mix_play";
3073                         MIX(sc).nchan = 1;
3074                         MIX(sc).update[0] = 1;
3075                         MIX(sc).val_default = (chx == chy) ? 2 : 0;
3076                         snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3077                             "DIn%d - Out%d Playback Volume", chy + 1, chx + 1);
3078
3079                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3080                 }
3081         }
3082
3083         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3084         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3085         MIX(sc).wValue[0] = MAKE_WORD(2, 0);
3086         MIX(sc).type = MIX_SIGNED_8;
3087         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3088         MIX(sc).name = "effect_vol";
3089         MIX(sc).nchan = 1;
3090         MIX(sc).update[0] = 1;
3091         MIX(sc).minval = 0;
3092         MIX(sc).maxval = 0x7f;
3093         MIX(sc).mul = 0x7f;
3094         MIX(sc).nchan = 1;
3095         MIX(sc).update[0] = 1;
3096         strlcpy(MIX(sc).desc, "Effect Volume", sizeof(MIX(sc).desc));
3097         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3098
3099         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3100         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3101         MIX(sc).wValue[0] = MAKE_WORD(3, 0);
3102         MIX(sc).type = MIX_SIGNED_16;
3103         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3104         MIX(sc).name = "effect_dur";
3105         MIX(sc).nchan = 1;
3106         MIX(sc).update[0] = 1;
3107         MIX(sc).minval = 0;
3108         MIX(sc).maxval = 0x7f00;
3109         MIX(sc).mul = 0x7f00;
3110         MIX(sc).nchan = 1;
3111         MIX(sc).update[0] = 1;
3112         strlcpy(MIX(sc).desc, "Effect Duration", sizeof(MIX(sc).desc));
3113         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3114
3115         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3116         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3117         MIX(sc).wValue[0] = MAKE_WORD(4, 0);
3118         MIX(sc).type = MIX_SIGNED_8;
3119         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3120         MIX(sc).name = "effect_fb";
3121         MIX(sc).nchan = 1;
3122         MIX(sc).update[0] = 1;
3123         MIX(sc).minval = 0;
3124         MIX(sc).maxval = 0x7f;
3125         MIX(sc).mul = 0x7f;
3126         MIX(sc).nchan = 1;
3127         MIX(sc).update[0] = 1;
3128         strlcpy(MIX(sc).desc, "Effect Feedback Volume", sizeof(MIX(sc).desc));
3129         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3130
3131         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3132         MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no);
3133         for (chy = 0; chy != 4; chy++) {
3134
3135                 MIX(sc).wValue[0] = MAKE_WORD(7, chy + 1);
3136                 MIX(sc).type = MIX_SIGNED_16;
3137                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3138                 MIX(sc).name = "effect_ret";
3139                 MIX(sc).nchan = 1;
3140                 MIX(sc).update[0] = 1;
3141                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3142                     "Effect Return %d Volume", chy + 1);
3143
3144                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3145         }
3146
3147         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3148         MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3149
3150         for (chy = 0; chy != 8; chy++) {
3151                 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1);
3152                 MIX(sc).type = MIX_SIGNED_16;
3153                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3154                 MIX(sc).name = "effect_send";
3155                 MIX(sc).nchan = 1;
3156                 MIX(sc).update[0] = 1;
3157                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3158                     "Effect Send AIn%d Volume", chy + 1);
3159
3160                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3161
3162                 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1 + 8);
3163                 MIX(sc).type = MIX_SIGNED_16;
3164                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3165                 MIX(sc).name = "effect_send";
3166                 MIX(sc).nchan = 1;
3167                 MIX(sc).update[0] = 1;
3168                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3169                     "Effect Send DIn%d Volume", chy + 1);
3170
3171                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3172         }
3173 }
3174
3175 static void
3176 uaudio_mixer_reload_all(struct uaudio_softc *sc)
3177 {
3178         struct uaudio_mixer_node *pmc;
3179         int chan;
3180
3181         if (sc->sc_child[0].mixer_lock == NULL)
3182                 return;
3183
3184         mtx_lock(sc->sc_child[0].mixer_lock);
3185         for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
3186                 /* use reset defaults for non-oss controlled settings */
3187                 if (pmc->ctl == SOUND_MIXER_NRDEVICES)
3188                         continue;
3189                 for (chan = 0; chan < pmc->nchan; chan++)
3190                         pmc->update[chan / 8] |= (1 << (chan % 8));
3191         }
3192         usbd_transfer_start(sc->sc_mixer_xfer[0]);
3193
3194         /* start HID volume keys, if any */
3195         usbd_transfer_start(sc->sc_hid.xfer[0]);
3196         mtx_unlock(sc->sc_child[0].mixer_lock);
3197 }
3198
3199 static void
3200 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3201 {
3202         struct uaudio_mixer_node *p_mc_new =
3203             malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK);
3204         int ch;
3205
3206         if (p_mc_new != NULL) {
3207                 memcpy(p_mc_new, mc, sizeof(*p_mc_new));
3208                 p_mc_new->next = sc->sc_mixer_root;
3209                 sc->sc_mixer_root = p_mc_new;
3210                 sc->sc_mixer_count++;
3211
3212                 /* set default value for all channels */
3213                 for (ch = 0; ch < p_mc_new->nchan; ch++) {
3214                         switch (p_mc_new->val_default) {
3215                         case 1:
3216                                 /* 50% */
3217                                 p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2;
3218                                 break;
3219                         case 2:
3220                                 /* 100% */
3221                                 p_mc_new->wData[ch] = p_mc_new->maxval;
3222                                 break;
3223                         default:
3224                                 /* 0% */
3225                                 p_mc_new->wData[ch] = p_mc_new->minval;
3226                                 break;
3227                         }
3228                 }
3229         } else {
3230                 DPRINTF("out of memory\n");
3231         }
3232 }
3233
3234 static void
3235 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3236 {
3237         int32_t res;
3238
3239         DPRINTF("adding %d\n", mc->ctl);
3240
3241         if (mc->type == MIX_ON_OFF) {
3242                 mc->minval = 0;
3243                 mc->maxval = 1;
3244         } else if (mc->type == MIX_SELECTOR) {
3245         } else {
3246
3247                 /* determine min and max values */
3248
3249                 mc->minval = uaudio_mixer_get(sc->sc_udev,
3250                     sc->sc_audio_rev, GET_MIN, mc);
3251                 mc->maxval = uaudio_mixer_get(sc->sc_udev,
3252                     sc->sc_audio_rev, GET_MAX, mc);
3253
3254                 /* check if max and min was swapped */
3255
3256                 if (mc->maxval < mc->minval) {
3257                         res = mc->maxval;
3258                         mc->maxval = mc->minval;
3259                         mc->minval = res;
3260                 }
3261
3262                 /* compute value range */
3263                 mc->mul = mc->maxval - mc->minval;
3264                 if (mc->mul == 0)
3265                         mc->mul = 1;
3266
3267                 /* compute value alignment */
3268                 res = uaudio_mixer_get(sc->sc_udev,
3269                     sc->sc_audio_rev, GET_RES, mc);
3270
3271                 DPRINTF("Resolution = %d\n", (int)res);
3272         }
3273
3274         uaudio_mixer_add_ctl_sub(sc, mc);
3275
3276 #ifdef USB_DEBUG
3277         if (uaudio_debug > 2) {
3278                 uint8_t i;
3279
3280                 for (i = 0; i < mc->nchan; i++) {
3281                         DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]);
3282                 }
3283                 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' "
3284                     "min=%d max=%d\n",
3285                     mc->wIndex, mc->type, mc->ctl,
3286                     mc->minval, mc->maxval);
3287         }
3288 #endif
3289 }
3290
3291 static void
3292 uaudio_mixer_add_mixer(struct uaudio_softc *sc,
3293     const struct uaudio_terminal_node *iot, int id)
3294 {
3295         const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu_v1;
3296         const struct usb_audio_mixer_unit_1 *d1;
3297
3298         uint32_t bno;                   /* bit number */
3299         uint32_t p;                     /* bit number accumulator */
3300         uint32_t mo;                    /* matching outputs */
3301         uint32_t mc;                    /* matching channels */
3302         uint32_t ichs;                  /* input channels */
3303         uint32_t ochs;                  /* output channels */
3304         uint32_t c;
3305         uint32_t chs;                   /* channels */
3306         uint32_t i;
3307         uint32_t o;
3308
3309         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3310             d0->bUnitId, d0->bNrInPins);
3311
3312         /* compute the number of input channels */
3313
3314         ichs = 0;
3315         for (i = 0; i < d0->bNrInPins; i++) {
3316                 ichs += uaudio_mixer_get_cluster(
3317                     d0->baSourceId[i], iot).bNrChannels;
3318         }
3319
3320         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3321
3322         /* and the number of output channels */
3323
3324         ochs = d1->bNrChannels;
3325
3326         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3327
3328         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3329
3330         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3331         MIX(sc).type = MIX_SIGNED_16;
3332
3333         if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3334                 return;
3335
3336         for (p = i = 0; i < d0->bNrInPins; i++) {
3337                 chs = uaudio_mixer_get_cluster(
3338                     d0->baSourceId[i], iot).bNrChannels;
3339                 mc = 0;
3340                 for (c = 0; c < chs; c++) {
3341                         mo = 0;
3342                         for (o = 0; o < ochs; o++) {
3343                                 bno = ((p + c) * ochs) + o;
3344                                 if (BIT_TEST(d1->bmControls, bno))
3345                                         mo++;
3346                         }
3347                         if (mo == 1)
3348                                 mc++;
3349                 }
3350                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3351
3352                         /* repeat bit-scan */
3353
3354                         mc = 0;
3355                         for (c = 0; c < chs; c++) {
3356                                 for (o = 0; o < ochs; o++) {
3357                                         bno = ((p + c) * ochs) + o;
3358                                         if (BIT_TEST(d1->bmControls, bno))
3359                                                 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3360                                 }
3361                         }
3362                         MIX(sc).nchan = chs;
3363                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3364                 }
3365                 p += chs;
3366         }
3367 }
3368
3369 static void
3370 uaudio20_mixer_add_mixer(struct uaudio_softc *sc,
3371     const struct uaudio_terminal_node *iot, int id)
3372 {
3373         const struct usb_audio20_mixer_unit_0 *d0 = iot[id].u.mu_v2;
3374         const struct usb_audio20_mixer_unit_1 *d1;
3375
3376         uint32_t bno;                   /* bit number */
3377         uint32_t p;                     /* bit number accumulator */
3378         uint32_t mo;                    /* matching outputs */
3379         uint32_t mc;                    /* matching channels */
3380         uint32_t ichs;                  /* input channels */
3381         uint32_t ochs;                  /* output channels */
3382         uint32_t c;
3383         uint32_t chs;                   /* channels */
3384         uint32_t i;
3385         uint32_t o;
3386
3387         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3388             d0->bUnitId, d0->bNrInPins);
3389
3390         /* compute the number of input channels */
3391
3392         ichs = 0;
3393         for (i = 0; i < d0->bNrInPins; i++) {
3394                 ichs += uaudio20_mixer_get_cluster(
3395                     d0->baSourceId[i], iot).bNrChannels;
3396         }
3397
3398         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3399
3400         /* and the number of output channels */
3401
3402         ochs = d1->bNrChannels;
3403
3404         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3405
3406         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3407
3408         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3409         MIX(sc).type = MIX_SIGNED_16;
3410
3411         if (uaudio20_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3412                 return;
3413
3414         for (p = i = 0; i < d0->bNrInPins; i++) {
3415                 chs = uaudio20_mixer_get_cluster(
3416                     d0->baSourceId[i], iot).bNrChannels;
3417                 mc = 0;
3418                 for (c = 0; c < chs; c++) {
3419                         mo = 0;
3420                         for (o = 0; o < ochs; o++) {
3421                                 bno = ((p + c) * ochs) + o;
3422                                 if (BIT_TEST(d1->bmControls, bno))
3423                                         mo++;
3424                         }
3425                         if (mo == 1)
3426                                 mc++;
3427                 }
3428                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3429
3430                         /* repeat bit-scan */
3431
3432                         mc = 0;
3433                         for (c = 0; c < chs; c++) {
3434                                 for (o = 0; o < ochs; o++) {
3435                                         bno = ((p + c) * ochs) + o;
3436                                         if (BIT_TEST(d1->bmControls, bno))
3437                                                 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3438                                 }
3439                         }
3440                         MIX(sc).nchan = chs;
3441                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3442                 }
3443                 p += chs;
3444         }
3445 }
3446
3447 static void
3448 uaudio_mixer_check_selectors(struct uaudio_softc *sc)
3449 {
3450         uint8_t reserve_feature[] = {
3451             SOUND_MIXER_LINE,
3452             SOUND_MIXER_LINE1,
3453             SOUND_MIXER_LINE2,
3454             SOUND_MIXER_LINE3,
3455             SOUND_MIXER_DIGITAL1,
3456             SOUND_MIXER_DIGITAL2,
3457             SOUND_MIXER_DIGITAL3,
3458         };
3459         const uint16_t reserve_max =
3460             sizeof(reserve_feature) / sizeof(reserve_feature[0]);
3461         uint16_t i;
3462         uint16_t j;
3463         uint16_t k;
3464
3465         /* remove existing selector types from the reserve */
3466         for (i = 0; i < MIX(sc).maxval; i++) {
3467                 if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES)
3468                         continue;
3469                 for (j = 0; j != reserve_max; j++) {
3470                         if (reserve_feature[j] == MIX(sc).slctrtype[i])
3471                                 reserve_feature[j] = SOUND_MIXER_NRDEVICES;
3472                 }
3473         }
3474
3475         /* make sure selector types are not overlapping */
3476         for (i = 0; i < MIX(sc).maxval; i++) {
3477                 if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES)
3478                         continue;
3479                 for (j = i + 1; j < MIX(sc).maxval; j++) {
3480                         if (MIX(sc).slctrtype[j] == SOUND_MIXER_NRDEVICES)
3481                                 continue;
3482                         if (MIX(sc).slctrtype[i] != MIX(sc).slctrtype[j])
3483                                 continue;
3484                         for (k = 0; k != reserve_max; k++) {
3485                                 if (reserve_feature[k] == SOUND_MIXER_NRDEVICES)
3486                                         continue;
3487                                 MIX(sc).slctrtype[j] = reserve_feature[k];
3488                                 reserve_feature[k] = SOUND_MIXER_NRDEVICES;
3489                                 break;
3490                         }
3491                         if (k == reserve_max) {
3492                                 DPRINTF("Selector type %d is not selectable!\n", j);
3493                                 MIX(sc).slctrtype[j] = SOUND_MIXER_NRDEVICES;
3494                         }
3495                 }
3496         }
3497 }
3498
3499 static void
3500 uaudio_mixer_add_selector(struct uaudio_softc *sc,
3501     const struct uaudio_terminal_node *iot, int id)
3502 {
3503         const struct usb_audio_selector_unit *d = iot[id].u.su_v1;
3504         uint16_t i;
3505
3506         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3507             d->bUnitId, d->bNrInPins);
3508
3509         if (d->bNrInPins == 0)
3510                 return;
3511
3512         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3513
3514         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3515         MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3516         MIX(sc).nchan = 1;
3517         MIX(sc).type = MIX_SELECTOR;
3518         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3519         MIX(sc).minval = 1;
3520         MIX(sc).maxval = d->bNrInPins;
3521         MIX(sc).name = "selector";
3522
3523         i = d->baSourceId[d->bNrInPins];
3524         if (i == 0 ||
3525             usbd_req_get_string_any(sc->sc_udev, NULL,
3526             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3527                 MIX(sc).desc[0] = 0;
3528         }
3529
3530         if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3531                 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3532
3533         MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval;
3534
3535         for (i = 0; i < MIX(sc).maxval; i++) {
3536                 MIX(sc).slctrtype[i] =
3537                     uaudio_mixer_determine_class(&iot[d->baSourceId[i]]);
3538         }
3539         for (; i < MAX_SELECTOR_INPUT_PIN; i++)
3540                 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3541
3542         uaudio_mixer_check_selectors(sc);
3543         uaudio_mixer_add_ctl(sc, &MIX(sc));
3544 }
3545
3546 static void
3547 uaudio20_mixer_add_selector(struct uaudio_softc *sc,
3548     const struct uaudio_terminal_node *iot, int id)
3549 {
3550         const struct usb_audio20_selector_unit *d = iot[id].u.su_v2;
3551         uint16_t i;
3552
3553         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3554             d->bUnitId, d->bNrInPins);
3555
3556         if (d->bNrInPins == 0)
3557                 return;
3558
3559         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3560
3561         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3562         MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3563         MIX(sc).nchan = 1;
3564         MIX(sc).type = MIX_SELECTOR;
3565         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3566         MIX(sc).minval = 1;
3567         MIX(sc).maxval = d->bNrInPins;
3568         MIX(sc).name = "selector";
3569
3570         i = d->baSourceId[d->bNrInPins];
3571         if (i == 0 ||
3572             usbd_req_get_string_any(sc->sc_udev, NULL,
3573             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3574                 MIX(sc).desc[0] = 0;
3575         }
3576
3577         if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3578                 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3579
3580         MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval;
3581
3582         for (i = 0; i < MIX(sc).maxval; i++) {
3583                 MIX(sc).slctrtype[i] =
3584                     uaudio20_mixer_determine_class(&iot[d->baSourceId[i]]);
3585         }
3586         for (; i < MAX_SELECTOR_INPUT_PIN; i++)
3587                 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3588
3589         uaudio_mixer_check_selectors(sc);
3590         uaudio_mixer_add_ctl(sc, &MIX(sc));
3591 }
3592
3593 static uint32_t
3594 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d,
3595     uint8_t i)
3596 {
3597         uint32_t temp = 0;
3598         uint32_t offset = (i * d->bControlSize);
3599
3600         if (d->bControlSize > 0) {
3601                 temp |= d->bmaControls[offset];
3602                 if (d->bControlSize > 1) {
3603                         temp |= d->bmaControls[offset + 1] << 8;
3604                         if (d->bControlSize > 2) {
3605                                 temp |= d->bmaControls[offset + 2] << 16;
3606                                 if (d->bControlSize > 3) {
3607                                         temp |= d->bmaControls[offset + 3] << 24;
3608                                 }
3609                         }
3610                 }
3611         }
3612         return (temp);
3613 }
3614
3615 static void
3616 uaudio_mixer_add_feature(struct uaudio_softc *sc,
3617     const struct uaudio_terminal_node *iot, int id)
3618 {
3619         const struct usb_audio_feature_unit *d = iot[id].u.fu_v1;
3620         uint32_t fumask;
3621         uint32_t mmask;
3622         uint32_t cmask;
3623         uint16_t mixernumber;
3624         uint8_t nchan;
3625         uint8_t chan;
3626         uint8_t ctl;
3627         uint8_t i;
3628
3629         if (d->bControlSize == 0)
3630                 return;
3631
3632         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3633
3634         nchan = (d->bLength - 7) / d->bControlSize;
3635         mmask = uaudio_mixer_feature_get_bmaControls(d, 0);
3636         cmask = 0;
3637
3638         if (nchan == 0)
3639                 return;
3640
3641         /* figure out what we can control */
3642
3643         for (chan = 1; chan < nchan; chan++) {
3644                 DPRINTFN(10, "chan=%d mask=%x\n",
3645                     chan, uaudio_mixer_feature_get_bmaControls(d, chan));
3646
3647                 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan);
3648         }
3649
3650         if (nchan > MIX_MAX_CHAN)
3651                 nchan = MIX_MAX_CHAN;
3652
3653         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3654
3655         i = d->bmaControls[d->bControlSize];
3656         if (i == 0 ||
3657             usbd_req_get_string_any(sc->sc_udev, NULL,
3658             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3659                 MIX(sc).desc[0] = 0;
3660         }
3661
3662         for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) {
3663
3664                 fumask = FU_MASK(ctl);
3665
3666                 DPRINTFN(5, "ctl=%d fumask=0x%04x\n",
3667                     ctl, fumask);
3668
3669                 if (mmask & fumask) {
3670                         MIX(sc).nchan = 1;
3671                         MIX(sc).wValue[0] = MAKE_WORD(ctl, 0);
3672                 } else if (cmask & fumask) {
3673                         MIX(sc).nchan = nchan - 1;
3674                         for (i = 1; i < nchan; i++) {
3675                                 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask)
3676                                         MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i);
3677                                 else
3678                                         MIX(sc).wValue[i - 1] = -1;
3679                         }
3680                 } else {
3681                         continue;
3682                 }
3683
3684                 mixernumber = uaudio_mixer_determine_class(&iot[id]);
3685
3686                 switch (ctl) {
3687                 case MUTE_CONTROL:
3688                         MIX(sc).type = MIX_ON_OFF;
3689                         MIX(sc).ctl = SOUND_MIXER_MUTE;
3690                         MIX(sc).name = "mute";
3691                         break;
3692
3693                 case VOLUME_CONTROL:
3694                         MIX(sc).type = MIX_SIGNED_16;
3695                         MIX(sc).ctl = mixernumber;
3696                         MIX(sc).name = "vol";
3697                         break;
3698
3699                 case BASS_CONTROL:
3700                         MIX(sc).type = MIX_SIGNED_8;
3701                         MIX(sc).ctl = SOUND_MIXER_BASS;
3702                         MIX(sc).name = "bass";
3703                         break;
3704
3705                 case MID_CONTROL:
3706                         MIX(sc).type = MIX_SIGNED_8;
3707                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3708                         MIX(sc).name = "mid";
3709                         break;
3710
3711                 case TREBLE_CONTROL:
3712                         MIX(sc).type = MIX_SIGNED_8;
3713                         MIX(sc).ctl = SOUND_MIXER_TREBLE;
3714                         MIX(sc).name = "treble";
3715                         break;
3716
3717                 case GRAPHIC_EQUALIZER_CONTROL:
3718                         continue;       /* XXX don't add anything */
3719
3720                 case AGC_CONTROL:
3721                         MIX(sc).type = MIX_ON_OFF;
3722                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3723                         MIX(sc).name = "agc";
3724                         break;
3725
3726                 case DELAY_CONTROL:
3727                         MIX(sc).type = MIX_UNSIGNED_16;
3728                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3729                         MIX(sc).name = "delay";
3730                         break;
3731
3732                 case BASS_BOOST_CONTROL:
3733                         MIX(sc).type = MIX_ON_OFF;
3734                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3735                         MIX(sc).name = "boost";
3736                         break;
3737
3738                 case LOUDNESS_CONTROL:
3739                         MIX(sc).type = MIX_ON_OFF;
3740                         MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3741                         MIX(sc).name = "loudness";
3742                         break;
3743
3744                 default:
3745                         MIX(sc).type = MIX_UNKNOWN;
3746                         break;
3747                 }
3748
3749                 if (MIX(sc).type != MIX_UNKNOWN)
3750                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3751         }
3752 }
3753
3754 static void
3755 uaudio20_mixer_add_feature(struct uaudio_softc *sc,
3756     const struct uaudio_terminal_node *iot, int id)
3757 {
3758         const struct usb_audio20_feature_unit *d = iot[id].u.fu_v2;
3759         uint32_t ctl;
3760         uint32_t mmask;
3761         uint32_t cmask;
3762         uint16_t mixernumber;
3763         uint8_t nchan;
3764         uint8_t chan;
3765         uint8_t i;
3766         uint8_t what;
3767
3768         if (UGETDW(d->bmaControls[0]) == 0)
3769                 return;
3770
3771         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3772
3773         nchan = (d->bLength - 6) / 4;
3774         mmask = UGETDW(d->bmaControls[0]);
3775         cmask = 0;
3776
3777         if (nchan == 0)
3778                 return;
3779
3780         /* figure out what we can control */
3781
3782         for (chan = 1; chan < nchan; chan++)
3783                 cmask |= UGETDW(d->bmaControls[chan]);
3784
3785         if (nchan > MIX_MAX_CHAN)
3786                 nchan = MIX_MAX_CHAN;
3787
3788         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3789
3790         i = d->bmaControls[nchan][0];
3791         if (i == 0 ||
3792             usbd_req_get_string_any(sc->sc_udev, NULL,
3793             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3794                 MIX(sc).desc[0] = 0;
3795         }
3796
3797         for (ctl = 3; ctl != 0; ctl <<= 2) {
3798
3799                 mixernumber = uaudio20_mixer_determine_class(&iot[id]);
3800
3801                 switch (ctl) {
3802                 case (3 << 0):
3803                         MIX(sc).type = MIX_ON_OFF;
3804                         MIX(sc).ctl = SOUND_MIXER_MUTE;
3805                         MIX(sc).name = "mute";
3806                         what = MUTE_CONTROL;
3807                         break;
3808                 case (3 << 2):
3809                         MIX(sc).type = MIX_SIGNED_16;
3810                         MIX(sc).ctl = mixernumber;
3811                         MIX(sc).name = "vol";
3812                         what = VOLUME_CONTROL;
3813                         break;
3814                 case (3 << 4):
3815                         MIX(sc).type = MIX_SIGNED_8;
3816                         MIX(sc).ctl = SOUND_MIXER_BASS;
3817                         MIX(sc).name = "bass";
3818                         what = BASS_CONTROL;
3819                         break;
3820                 case (3 << 6):
3821                         MIX(sc).type = MIX_SIGNED_8;
3822                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3823                         MIX(sc).name = "mid";
3824                         what = MID_CONTROL;
3825                         break;
3826                 case (3 << 8):
3827                         MIX(sc).type = MIX_SIGNED_8;
3828                         MIX(sc).ctl = SOUND_MIXER_TREBLE;
3829                         MIX(sc).name = "treble";
3830                         what = TREBLE_CONTROL;
3831                         break;
3832                 case (3 << 12):
3833                         MIX(sc).type = MIX_ON_OFF;
3834                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3835                         MIX(sc).name = "agc";
3836                         what = AGC_CONTROL;
3837                         break;
3838                 case (3 << 14):
3839                         MIX(sc).type = MIX_UNSIGNED_16;
3840                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3841                         MIX(sc).name = "delay";
3842                         what = DELAY_CONTROL;
3843                         break;
3844                 case (3 << 16):
3845                         MIX(sc).type = MIX_ON_OFF;
3846                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3847                         MIX(sc).name = "boost";
3848                         what = BASS_BOOST_CONTROL;
3849                         break;
3850                 case (3 << 18):
3851                         MIX(sc).type = MIX_ON_OFF;
3852                         MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3853                         MIX(sc).name = "loudness";
3854                         what = LOUDNESS_CONTROL;
3855                         break;
3856                 case (3 << 20):
3857                         MIX(sc).type = MIX_SIGNED_16;
3858                         MIX(sc).ctl = mixernumber;
3859                         MIX(sc).name = "igain";
3860                         what = INPUT_GAIN_CONTROL;
3861                         break;
3862                 case (3 << 22):
3863                         MIX(sc).type = MIX_SIGNED_16;
3864                         MIX(sc).ctl = mixernumber;
3865                         MIX(sc).name = "igainpad";
3866                         what = INPUT_GAIN_PAD_CONTROL;
3867                         break;
3868                 default:
3869                         continue;
3870                 }
3871
3872                 if ((mmask & ctl) == ctl) {
3873                         MIX(sc).nchan = 1;
3874                         MIX(sc).wValue[0] = MAKE_WORD(what, 0);
3875                 } else if ((cmask & ctl) == ctl) {
3876                         MIX(sc).nchan = nchan - 1;
3877                         for (i = 1; i < nchan; i++) {
3878                                 if ((UGETDW(d->bmaControls[i]) & ctl) == ctl)
3879                                         MIX(sc).wValue[i - 1] = MAKE_WORD(what, i);
3880                                 else
3881                                         MIX(sc).wValue[i - 1] = -1;
3882                         }
3883                 } else {
3884                         continue;
3885                 }
3886
3887                 if (MIX(sc).type != MIX_UNKNOWN)
3888                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3889         }
3890 }
3891
3892 static void
3893 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc,
3894     const struct uaudio_terminal_node *iot, int id)
3895 {
3896         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3897         const struct usb_audio_processing_unit_1 *d1 =
3898             (const void *)(d0->baSourceId + d0->bNrInPins);
3899         const struct usb_audio_processing_unit_updown *ud =
3900             (const void *)(d1->bmControls + d1->bControlSize);
3901         uint8_t i;
3902
3903         if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) {
3904                 return;
3905         }
3906         if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes))
3907             == NULL) {
3908                 return;
3909         }
3910         DPRINTFN(3, "bUnitId=%d bNrModes=%d\n",
3911             d0->bUnitId, ud->bNrModes);
3912
3913         if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
3914                 DPRINTF("no mode select\n");
3915                 return;
3916         }
3917         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3918
3919         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3920         MIX(sc).nchan = 1;
3921         MIX(sc).wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0);
3922         MIX(sc).type = MIX_ON_OFF;              /* XXX */
3923
3924         for (i = 0; i < ud->bNrModes; i++) {
3925                 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i]));
3926                 /* XXX */
3927         }
3928
3929         uaudio_mixer_add_ctl(sc, &MIX(sc));
3930 }
3931
3932 static void
3933 uaudio_mixer_add_processing(struct uaudio_softc *sc,
3934     const struct uaudio_terminal_node *iot, int id)
3935 {
3936         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3937         const struct usb_audio_processing_unit_1 *d1 =
3938             (const void *)(d0->baSourceId + d0->bNrInPins);
3939         uint16_t ptype;
3940
3941         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3942
3943         ptype = UGETW(d0->wProcessType);
3944
3945         DPRINTFN(3, "wProcessType=%d bUnitId=%d "
3946             "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins);
3947
3948         if (d1->bControlSize == 0) {
3949                 return;
3950         }
3951         if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
3952                 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3953                 MIX(sc).nchan = 1;
3954                 MIX(sc).wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0);
3955                 MIX(sc).type = MIX_ON_OFF;
3956                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3957         }
3958         switch (ptype) {
3959         case UPDOWNMIX_PROCESS:
3960                 uaudio_mixer_add_processing_updown(sc, iot, id);
3961                 break;
3962
3963         case DOLBY_PROLOGIC_PROCESS:
3964         case P3D_STEREO_EXTENDER_PROCESS:
3965         case REVERBATION_PROCESS:
3966         case CHORUS_PROCESS:
3967         case DYN_RANGE_COMP_PROCESS:
3968         default:
3969                 DPRINTF("unit %d, type=%d is not implemented\n",
3970                     d0->bUnitId, ptype);
3971                 break;
3972         }
3973 }
3974
3975 static void
3976 uaudio_mixer_add_extension(struct uaudio_softc *sc,
3977     const struct uaudio_terminal_node *iot, int id)
3978 {
3979         const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu_v1;
3980         const struct usb_audio_extension_unit_1 *d1 =
3981             (const void *)(d0->baSourceId + d0->bNrInPins);
3982
3983         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3984             d0->bUnitId, d0->bNrInPins);
3985
3986         if (sc->sc_uq_au_no_xu) {
3987                 return;
3988         }
3989         if (d1->bControlSize == 0) {
3990                 return;
3991         }
3992         if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
3993
3994                 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3995
3996                 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3997                 MIX(sc).nchan = 1;
3998                 MIX(sc).wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0);
3999                 MIX(sc).type = MIX_ON_OFF;
4000
4001                 uaudio_mixer_add_ctl(sc, &MIX(sc));
4002         }
4003 }
4004
4005 static const void *
4006 uaudio_mixer_verify_desc(const void *arg, uint32_t len)
4007 {
4008         const struct usb_audio_mixer_unit_1 *d1;
4009         const struct usb_audio_extension_unit_1 *e1;
4010         const struct usb_audio_processing_unit_1 *u1;
4011
4012         union {
4013                 const struct usb_descriptor *desc;
4014                 const struct usb_audio_input_terminal *it;
4015                 const struct usb_audio_output_terminal *ot;
4016                 const struct usb_audio_mixer_unit_0 *mu;
4017                 const struct usb_audio_selector_unit *su;
4018                 const struct usb_audio_feature_unit *fu;
4019                 const struct usb_audio_processing_unit_0 *pu;
4020                 const struct usb_audio_extension_unit_0 *eu;
4021         }     u;
4022
4023         u.desc = arg;
4024
4025         if (u.desc == NULL) {
4026                 goto error;
4027         }
4028         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) {
4029                 goto error;
4030         }
4031         switch (u.desc->bDescriptorSubtype) {
4032         case UDESCSUB_AC_INPUT:
4033                 len += sizeof(*u.it);
4034                 break;
4035
4036         case UDESCSUB_AC_OUTPUT:
4037                 len += sizeof(*u.ot);
4038                 break;
4039
4040         case UDESCSUB_AC_MIXER:
4041                 len += sizeof(*u.mu);
4042
4043                 if (u.desc->bLength < len) {
4044                         goto error;
4045                 }
4046                 len += u.mu->bNrInPins;
4047
4048                 if (u.desc->bLength < len) {
4049                         goto error;
4050                 }
4051                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4052
4053                 len += sizeof(*d1);
4054                 break;
4055
4056         case UDESCSUB_AC_SELECTOR:
4057                 len += sizeof(*u.su);
4058
4059                 if (u.desc->bLength < len) {
4060                         goto error;
4061                 }
4062                 len += u.su->bNrInPins + 1;
4063                 break;
4064
4065         case UDESCSUB_AC_FEATURE:
4066                 len += sizeof(*u.fu) + 1;
4067
4068                 if (u.desc->bLength < len)
4069                         goto error;
4070
4071                 len += u.fu->bControlSize;
4072                 break;
4073
4074         case UDESCSUB_AC_PROCESSING:
4075                 len += sizeof(*u.pu);
4076
4077                 if (u.desc->bLength < len) {
4078                         goto error;
4079                 }
4080                 len += u.pu->bNrInPins;
4081
4082                 if (u.desc->bLength < len) {
4083                         goto error;
4084                 }
4085                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4086
4087                 len += sizeof(*u1);
4088
4089                 if (u.desc->bLength < len) {
4090                         goto error;
4091                 }
4092                 len += u1->bControlSize;
4093
4094                 break;
4095
4096         case UDESCSUB_AC_EXTENSION:
4097                 len += sizeof(*u.eu);
4098
4099                 if (u.desc->bLength < len) {
4100                         goto error;
4101                 }
4102                 len += u.eu->bNrInPins;
4103
4104                 if (u.desc->bLength < len) {
4105                         goto error;
4106                 }
4107                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4108
4109                 len += sizeof(*e1);
4110
4111                 if (u.desc->bLength < len) {
4112                         goto error;
4113                 }
4114                 len += e1->bControlSize;
4115                 break;
4116
4117         default:
4118                 goto error;
4119         }
4120
4121         if (u.desc->bLength < len) {
4122                 goto error;
4123         }
4124         return (u.desc);
4125
4126 error:
4127         if (u.desc) {
4128                 DPRINTF("invalid descriptor, type=%d, "
4129                     "sub_type=%d, len=%d of %d bytes\n",
4130                     u.desc->bDescriptorType,
4131                     u.desc->bDescriptorSubtype,
4132                     u.desc->bLength, len);
4133         }
4134         return (NULL);
4135 }
4136
4137 static const void *
4138 uaudio20_mixer_verify_desc(const void *arg, uint32_t len)
4139 {
4140         const struct usb_audio20_mixer_unit_1 *d1;
4141         const struct usb_audio20_extension_unit_1 *e1;
4142         const struct usb_audio20_processing_unit_1 *u1;
4143         const struct usb_audio20_clock_selector_unit_1 *c1;
4144
4145         union {
4146                 const struct usb_descriptor *desc;
4147                 const struct usb_audio20_clock_source_unit *csrc;
4148                 const struct usb_audio20_clock_selector_unit_0 *csel;
4149                 const struct usb_audio20_clock_multiplier_unit *cmul;
4150                 const struct usb_audio20_input_terminal *it;
4151                 const struct usb_audio20_output_terminal *ot;
4152                 const struct usb_audio20_mixer_unit_0 *mu;
4153                 const struct usb_audio20_selector_unit *su;
4154                 const struct usb_audio20_feature_unit *fu;
4155                 const struct usb_audio20_sample_rate_unit *ru;
4156                 const struct usb_audio20_processing_unit_0 *pu;
4157                 const struct usb_audio20_extension_unit_0 *eu;
4158                 const struct usb_audio20_effect_unit *ef;
4159         }     u;
4160
4161         u.desc = arg;
4162
4163         if (u.desc == NULL)
4164                 goto error;
4165
4166         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE)
4167                 goto error;
4168
4169         switch (u.desc->bDescriptorSubtype) {
4170         case UDESCSUB_AC_INPUT:
4171                 len += sizeof(*u.it);
4172                 break;
4173
4174         case UDESCSUB_AC_OUTPUT:
4175                 len += sizeof(*u.ot);
4176                 break;
4177
4178         case UDESCSUB_AC_MIXER:
4179                 len += sizeof(*u.mu);
4180
4181                 if (u.desc->bLength < len)
4182                         goto error;
4183                 len += u.mu->bNrInPins;
4184
4185                 if (u.desc->bLength < len)
4186                         goto error;
4187
4188                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4189
4190                 len += sizeof(*d1) + d1->bNrChannels;
4191                 break;
4192
4193         case UDESCSUB_AC_SELECTOR:
4194                 len += sizeof(*u.su);
4195
4196                 if (u.desc->bLength < len)
4197                         goto error;
4198
4199                 len += u.su->bNrInPins + 1;
4200                 break;
4201
4202         case UDESCSUB_AC_FEATURE:
4203                 len += sizeof(*u.fu) + 1;
4204                 break;
4205
4206         case UDESCSUB_AC_EFFECT:
4207                 len += sizeof(*u.ef) + 4;
4208                 break;
4209
4210         case UDESCSUB_AC_PROCESSING_V2:
4211                 len += sizeof(*u.pu);
4212
4213                 if (u.desc->bLength < len)
4214                         goto error;
4215
4216                 len += u.pu->bNrInPins;
4217
4218                 if (u.desc->bLength < len)
4219                         goto error;
4220
4221                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4222
4223                 len += sizeof(*u1);
4224                 break;
4225
4226         case UDESCSUB_AC_EXTENSION_V2:
4227                 len += sizeof(*u.eu);
4228
4229                 if (u.desc->bLength < len)
4230                         goto error;
4231
4232                 len += u.eu->bNrInPins;
4233
4234                 if (u.desc->bLength < len)
4235                         goto error;
4236
4237                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4238
4239                 len += sizeof(*e1);
4240                 break;
4241
4242         case UDESCSUB_AC_CLOCK_SRC:
4243                 len += sizeof(*u.csrc);
4244                 break;
4245
4246         case UDESCSUB_AC_CLOCK_SEL:
4247                 len += sizeof(*u.csel);
4248
4249                 if (u.desc->bLength < len)
4250                         goto error;
4251
4252                 len += u.csel->bNrInPins;
4253
4254                 if (u.desc->bLength < len)
4255                         goto error;
4256
4257                 c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins);
4258
4259                 len += sizeof(*c1);
4260                 break;
4261
4262         case UDESCSUB_AC_CLOCK_MUL:
4263                 len += sizeof(*u.cmul);
4264                 break;
4265
4266         case UDESCSUB_AC_SAMPLE_RT:
4267                 len += sizeof(*u.ru);
4268                 break;
4269
4270         default:
4271                 goto error;
4272         }
4273
4274         if (u.desc->bLength < len)
4275                 goto error;
4276
4277         return (u.desc);
4278
4279 error:
4280         if (u.desc) {
4281                 DPRINTF("invalid descriptor, type=%d, "
4282                     "sub_type=%d, len=%d of %d bytes\n",
4283                     u.desc->bDescriptorType,
4284                     u.desc->bDescriptorSubtype,
4285                     u.desc->bLength, len);
4286         }
4287         return (NULL);
4288 }
4289
4290 static struct usb_audio_cluster
4291 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4292 {
4293         struct usb_audio_cluster r;
4294         const struct usb_descriptor *dp;
4295         uint8_t i;
4296
4297         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
4298                 dp = iot[id].u.desc;
4299                 if (dp == NULL) {
4300                         goto error;
4301                 }
4302                 switch (dp->bDescriptorSubtype) {
4303                 case UDESCSUB_AC_INPUT:
4304                         r.bNrChannels = iot[id].u.it_v1->bNrChannels;
4305                         r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0];
4306                         r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1];
4307                         r.iChannelNames = iot[id].u.it_v1->iChannelNames;
4308                         goto done;
4309
4310                 case UDESCSUB_AC_OUTPUT:
4311                         id = iot[id].u.ot_v1->bSourceId;
4312                         break;
4313
4314                 case UDESCSUB_AC_MIXER:
4315                         r = *(const struct usb_audio_cluster *)
4316                             &iot[id].u.mu_v1->baSourceId[
4317                             iot[id].u.mu_v1->bNrInPins];
4318                         goto done;
4319
4320                 case UDESCSUB_AC_SELECTOR:
4321                         if (iot[id].u.su_v1->bNrInPins > 0) {
4322                                 /* XXX This is not really right */
4323                                 id = iot[id].u.su_v1->baSourceId[0];
4324                         }
4325                         break;
4326
4327                 case UDESCSUB_AC_FEATURE:
4328                         id = iot[id].u.fu_v1->bSourceId;
4329                         break;
4330
4331                 case UDESCSUB_AC_PROCESSING:
4332                         r = *((const struct usb_audio_cluster *)
4333                             &iot[id].u.pu_v1->baSourceId[
4334                             iot[id].u.pu_v1->bNrInPins]);
4335                         goto done;
4336
4337                 case UDESCSUB_AC_EXTENSION:
4338                         r = *((const struct usb_audio_cluster *)
4339                             &iot[id].u.eu_v1->baSourceId[
4340                             iot[id].u.eu_v1->bNrInPins]);
4341                         goto done;
4342
4343                 default:
4344                         goto error;
4345                 }
4346         }
4347 error:
4348         DPRINTF("bad data\n");
4349         memset(&r, 0, sizeof(r));
4350 done:
4351         return (r);
4352 }
4353
4354 static struct usb_audio20_cluster
4355 uaudio20_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4356 {
4357         struct usb_audio20_cluster r;
4358         const struct usb_descriptor *dp;
4359         uint8_t i;
4360
4361         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
4362                 dp = iot[id].u.desc;
4363                 if (dp == NULL)
4364                         goto error;
4365
4366                 switch (dp->bDescriptorSubtype) {
4367                 case UDESCSUB_AC_INPUT:
4368                         r.bNrChannels = iot[id].u.it_v2->bNrChannels;
4369                         r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0];
4370                         r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1];
4371                         r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2];
4372                         r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3];
4373                         r.iChannelNames = iot[id].u.it_v2->iTerminal;
4374                         goto done;
4375
4376                 case UDESCSUB_AC_OUTPUT:
4377                         id = iot[id].u.ot_v2->bSourceId;
4378                         break;
4379
4380                 case UDESCSUB_AC_MIXER:
4381                         r = *(const struct usb_audio20_cluster *)
4382                             &iot[id].u.mu_v2->baSourceId[
4383                             iot[id].u.mu_v2->bNrInPins];
4384                         goto done;
4385
4386                 case UDESCSUB_AC_SELECTOR:
4387                         if (iot[id].u.su_v2->bNrInPins > 0) {
4388                                 /* XXX This is not really right */
4389                                 id = iot[id].u.su_v2->baSourceId[0];
4390                         }
4391                         break;
4392
4393                 case UDESCSUB_AC_SAMPLE_RT:
4394                         id = iot[id].u.ru_v2->bSourceId;
4395                         break;
4396
4397                 case UDESCSUB_AC_EFFECT:
4398                         id = iot[id].u.ef_v2->bSourceId;
4399                         break;
4400
4401                 case UDESCSUB_AC_FEATURE:
4402                         id = iot[id].u.fu_v2->bSourceId;
4403                         break;
4404
4405                 case UDESCSUB_AC_PROCESSING_V2:
4406                         r = *((const struct usb_audio20_cluster *)
4407                             &iot[id].u.pu_v2->baSourceId[
4408                             iot[id].u.pu_v2->bNrInPins]);
4409                         goto done;
4410
4411                 case UDESCSUB_AC_EXTENSION_V2:
4412                         r = *((const struct usb_audio20_cluster *)
4413                             &iot[id].u.eu_v2->baSourceId[
4414                             iot[id].u.eu_v2->bNrInPins]);
4415                         goto done;
4416
4417                 default:
4418                         goto error;
4419                 }
4420         }
4421 error:
4422         DPRINTF("Bad data!\n");
4423         memset(&r, 0, sizeof(r));
4424 done:
4425         return (r);
4426 }
4427
4428 static bool
4429 uaudio_mixer_foreach_input(const struct uaudio_terminal_node *iot, uint8_t *pindex)
4430 {
4431         uint8_t n;
4432
4433         n = *pindex;
4434
4435         while (1) {
4436                 if (!n--)
4437                         n = iot->usr.id_max;
4438                 if (n == 0)
4439                         return (false);
4440                 if (iot->usr.bit_input[n / 8] & (1 << (n % 8)))
4441                         break;
4442         }
4443         *pindex = n;
4444         return (true);
4445 }
4446
4447 static bool
4448 uaudio_mixer_foreach_output(const struct uaudio_terminal_node *iot, uint8_t *pindex)
4449 {
4450         uint8_t n;
4451
4452         n = *pindex;
4453
4454         while (1) {
4455                 if (!n--)
4456                         n = iot->usr.id_max;
4457                 if (n == 0)
4458                         return (false);
4459                 if (iot->usr.bit_output[n / 8] & (1 << (n % 8)))
4460                         break;
4461         }
4462         *pindex = n;
4463         return (true);
4464 }
4465
4466 struct uaudio_tt_to_feature {
4467         uint16_t terminal_type;
4468         uint16_t feature;
4469 };
4470
4471 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = {
4472
4473         {UATI_MICROPHONE, SOUND_MIXER_MIC},
4474         {UATI_DESKMICROPHONE, SOUND_MIXER_MIC},
4475         {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC},
4476         {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC},
4477         {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC},
4478         {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC},
4479
4480         {UATE_ANALOGCONN, SOUND_MIXER_LINE},
4481         {UATE_LINECONN, SOUND_MIXER_LINE},
4482         {UATE_LEGACYCONN, SOUND_MIXER_LINE},
4483
4484         {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM},
4485         {UATE_SPDIF, SOUND_MIXER_ALTPCM},
4486         {UATE_1394DA, SOUND_MIXER_ALTPCM},
4487         {UATE_1394DV, SOUND_MIXER_ALTPCM},
4488
4489         {UATF_CDPLAYER, SOUND_MIXER_CD},
4490
4491         {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH},
4492
4493         {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO},
4494         {UATF_DVDAUDIO, SOUND_MIXER_VIDEO},
4495         {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO},
4496
4497         {UATF_RADIORECV, SOUND_MIXER_RADIO},
4498         {UATF_RADIOXMIT, SOUND_MIXER_RADIO},
4499
4500         {}      /* END */
4501 };
4502
4503 static uint16_t
4504 uaudio_mixer_get_feature_by_tt(uint16_t terminal_type, uint16_t default_type)
4505 {
4506         const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature;
4507         uint16_t retval;
4508
4509         if (terminal_type == 0) {
4510                 retval = default_type;
4511         } else while (1) {
4512                 if (uat->terminal_type == 0) {
4513                         switch (terminal_type >> 8) {
4514                         case UATI_UNDEFINED >> 8:
4515                                 retval = SOUND_MIXER_RECLEV;
4516                                 goto done;
4517                         case UATO_UNDEFINED >> 8:
4518                                 retval = SOUND_MIXER_PCM;
4519                                 goto done;
4520                         case UATT_UNDEFINED >> 8:
4521                                 retval = SOUND_MIXER_PHONEIN;
4522                                 goto done;
4523                         default:
4524                                 retval = default_type;
4525                                 goto done;
4526                         }
4527                 } else if (uat->terminal_type == terminal_type) {
4528                         retval = uat->feature;
4529                         goto done;
4530                 }
4531                 uat++;
4532         }
4533 done:
4534         DPRINTF("terminal_type=0x%04x RET=%d DEF=%d\n",
4535             terminal_type, retval, default_type);
4536         return (retval);
4537 }
4538
4539 static uint16_t
4540 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot)
4541 {
4542         const struct uaudio_terminal_node *ptr;
4543         uint16_t terminal_type_input = 0;
4544         uint16_t terminal_type_output = 0;
4545         uint16_t temp;
4546         uint8_t match = 0;
4547         uint8_t i;
4548
4549         for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) {
4550                 ptr = iot->root + i;
4551                 temp = UGETW(ptr->u.it_v1->wTerminalType);
4552
4553                 if (temp == 0)
4554                         continue;
4555                 else if (temp == UAT_STREAM)
4556                         match |= 1;
4557                 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4558                         terminal_type_input = temp;
4559         }
4560
4561         for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) {
4562                 ptr = iot->root + i;
4563                 temp = UGETW(ptr->u.ot_v1->wTerminalType);
4564
4565                 if (temp == 0)
4566                         continue;
4567                 else if (temp == UAT_STREAM)
4568                         match |= 2;
4569                 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4570                         terminal_type_output = temp;
4571         }
4572
4573         DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n",
4574             match, terminal_type_input, terminal_type_output);
4575
4576         switch (match) {
4577         case 0: /* not connected to USB */
4578                 if (terminal_type_output != 0) {
4579                         return (uaudio_mixer_get_feature_by_tt(
4580                             terminal_type_output, SOUND_MIXER_MONITOR));
4581                 } else {
4582                         return (uaudio_mixer_get_feature_by_tt(
4583                             terminal_type_input, SOUND_MIXER_MONITOR));
4584                 }
4585         case 3: /* connected to both USB input and USB output */
4586                 return (SOUND_MIXER_IMIX);
4587         case 2: /* connected to USB output */
4588                 return (uaudio_mixer_get_feature_by_tt(
4589                     terminal_type_input, SOUND_MIXER_RECLEV));
4590         case 1: /* connected to USB input */
4591                 return (uaudio_mixer_get_feature_by_tt(
4592                     terminal_type_output, SOUND_MIXER_PCM));
4593         default:
4594                 return (SOUND_MIXER_NRDEVICES);
4595         }
4596 }
4597
4598 static uint16_t
4599 uaudio20_mixer_determine_class(const struct uaudio_terminal_node *iot)
4600 {
4601         const struct uaudio_terminal_node *ptr;
4602         uint16_t terminal_type_input = 0;
4603         uint16_t terminal_type_output = 0;
4604         uint16_t temp;
4605         uint8_t match = 0;
4606         uint8_t i;
4607
4608         for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) {
4609                 ptr = iot->root + i;
4610                 temp = UGETW(ptr->u.it_v2->wTerminalType);
4611
4612                 if (temp == 0)
4613                         continue;
4614                 else if (temp == UAT_STREAM)
4615                         match |= 1;
4616                 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4617                         terminal_type_input = temp;
4618         }
4619
4620         for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) {
4621                 ptr = iot->root + i;
4622                 temp = UGETW(ptr->u.ot_v2->wTerminalType);
4623
4624                 if (temp == 0)
4625                         continue;
4626                 else if (temp == UAT_STREAM)
4627                         match |= 2;
4628                 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4629                         terminal_type_output = temp;
4630         }
4631
4632         DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n",
4633             match, terminal_type_input, terminal_type_output);
4634
4635         switch (match) {
4636         case 0: /* not connected to USB */
4637                 if (terminal_type_output != 0) {
4638                         return (uaudio_mixer_get_feature_by_tt(
4639                             terminal_type_output, SOUND_MIXER_MONITOR));
4640                 } else {
4641                         return (uaudio_mixer_get_feature_by_tt(
4642                             terminal_type_input, SOUND_MIXER_MONITOR));
4643                 }
4644         case 3: /* connected to both USB input and USB output */
4645                 return (SOUND_MIXER_IMIX);
4646         case 2: /* connected to USB output */
4647                 return (uaudio_mixer_get_feature_by_tt(
4648                     terminal_type_input, SOUND_MIXER_RECLEV));
4649         case 1: /* connected to USB input */
4650                 return (uaudio_mixer_get_feature_by_tt(
4651                     terminal_type_output, SOUND_MIXER_PCM));
4652         default:
4653                 return (SOUND_MIXER_NRDEVICES);
4654         }
4655 }
4656
4657 static void
4658 uaudio_mixer_merge_outputs(struct uaudio_search_result *dst,
4659     const struct uaudio_search_result *src)
4660 {
4661         const uint8_t max = sizeof(src->bit_output) / sizeof(src->bit_output[0]);
4662         uint8_t x;
4663
4664         for (x = 0; x != max; x++)
4665                 dst->bit_output[x] |= src->bit_output[x];
4666 }
4667
4668 static void
4669 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4670     const uint8_t *p_id, uint8_t n_id,
4671     struct uaudio_search_result *info)
4672 {
4673         struct uaudio_terminal_node *iot;
4674         uint8_t n;
4675         uint8_t i;
4676
4677         for (n = 0; n < n_id; n++) {
4678
4679                 i = p_id[n];
4680
4681                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4682                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4683                         return;
4684                 }
4685
4686                 info->recurse_level++;
4687
4688                 iot = (root + i);
4689
4690                 if (iot->u.desc == NULL)
4691                         continue;
4692
4693                 switch (iot->u.desc->bDescriptorSubtype) {
4694                 case UDESCSUB_AC_INPUT:
4695                         uaudio_mixer_merge_outputs(&iot->usr, info);
4696                         info->bit_input[i / 8] |= (1 << (i % 8));
4697                         break;
4698
4699                 case UDESCSUB_AC_FEATURE:
4700                         uaudio_mixer_merge_outputs(&iot->usr, info);
4701                         uaudio_mixer_find_inputs_sub(
4702                             root, &iot->u.fu_v1->bSourceId, 1, info);
4703                         break;
4704
4705                 case UDESCSUB_AC_OUTPUT:
4706                         info->bit_output[i / 8] |= (1 << (i % 8));
4707                         uaudio_mixer_find_inputs_sub(
4708                             root, &iot->u.ot_v1->bSourceId, 1, info);
4709                         info->bit_output[i / 8] &= ~(1 << (i % 8));
4710                         break;
4711
4712                 case UDESCSUB_AC_MIXER:
4713                         uaudio_mixer_merge_outputs(&iot->usr, info);
4714                         uaudio_mixer_find_inputs_sub(
4715                             root, iot->u.mu_v1->baSourceId,
4716                             iot->u.mu_v1->bNrInPins, info);
4717                         break;
4718
4719                 case UDESCSUB_AC_SELECTOR:
4720                         uaudio_mixer_merge_outputs(&iot->usr, info);
4721                         uaudio_mixer_find_inputs_sub(
4722                             root, iot->u.su_v1->baSourceId,
4723                             iot->u.su_v1->bNrInPins, info);
4724                         break;
4725
4726                 case UDESCSUB_AC_PROCESSING:
4727                         uaudio_mixer_merge_outputs(&iot->usr, info);
4728                         uaudio_mixer_find_inputs_sub(
4729                             root, iot->u.pu_v1->baSourceId,
4730                             iot->u.pu_v1->bNrInPins, info);
4731                         break;
4732
4733                 case UDESCSUB_AC_EXTENSION:
4734                         uaudio_mixer_merge_outputs(&iot->usr, info);
4735                         uaudio_mixer_find_inputs_sub(
4736                             root, iot->u.eu_v1->baSourceId,
4737                             iot->u.eu_v1->bNrInPins, info);
4738                         break;
4739
4740                 default:
4741                         break;
4742                 }
4743         }
4744 }
4745
4746 static void
4747 uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4748     const uint8_t *p_id, uint8_t n_id,
4749     struct uaudio_search_result *info)
4750 {
4751         struct uaudio_terminal_node *iot;
4752         uint8_t n;
4753         uint8_t i;
4754
4755         for (n = 0; n < n_id; n++) {
4756
4757                 i = p_id[n];
4758
4759                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4760                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4761                         return;
4762                 }
4763
4764                 info->recurse_level++;
4765
4766                 iot = (root + i);
4767
4768                 if (iot->u.desc == NULL)
4769                         continue;
4770
4771                 switch (iot->u.desc->bDescriptorSubtype) {
4772                 case UDESCSUB_AC_INPUT:
4773                         uaudio_mixer_merge_outputs(&iot->usr, info);
4774                         info->bit_input[i / 8] |= (1 << (i % 8));
4775                         break;
4776
4777                 case UDESCSUB_AC_OUTPUT:
4778                         info->bit_output[i / 8] |= (1 << (i % 8));
4779                         uaudio20_mixer_find_inputs_sub(
4780                             root, &iot->u.ot_v2->bSourceId, 1, info);
4781                         info->bit_output[i / 8] &= ~(1 << (i % 8));
4782                         break;
4783
4784                 case UDESCSUB_AC_MIXER:
4785                         uaudio_mixer_merge_outputs(&iot->usr, info);
4786                         uaudio20_mixer_find_inputs_sub(
4787                             root, iot->u.mu_v2->baSourceId,
4788                             iot->u.mu_v2->bNrInPins, info);
4789                         break;
4790
4791                 case UDESCSUB_AC_SELECTOR:
4792                         uaudio_mixer_merge_outputs(&iot->usr, info);
4793                         uaudio20_mixer_find_inputs_sub(
4794                             root, iot->u.su_v2->baSourceId,
4795                             iot->u.su_v2->bNrInPins, info);
4796                         break;
4797
4798                 case UDESCSUB_AC_SAMPLE_RT:
4799                         uaudio_mixer_merge_outputs(&iot->usr, info);
4800                         uaudio20_mixer_find_inputs_sub(
4801                             root, &iot->u.ru_v2->bSourceId,
4802                             1, info);
4803                         break;
4804
4805                 case UDESCSUB_AC_EFFECT:
4806                         uaudio_mixer_merge_outputs(&iot->usr, info);
4807                         uaudio20_mixer_find_inputs_sub(
4808                             root, &iot->u.ef_v2->bSourceId,
4809                             1, info);
4810                         break;
4811
4812                 case UDESCSUB_AC_FEATURE:
4813                         uaudio_mixer_merge_outputs(&iot->usr, info);
4814                         uaudio20_mixer_find_inputs_sub(
4815                             root, &iot->u.fu_v2->bSourceId, 1, info);
4816                         break;
4817
4818                 case UDESCSUB_AC_PROCESSING_V2:
4819                         uaudio_mixer_merge_outputs(&iot->usr, info);
4820                         uaudio20_mixer_find_inputs_sub(
4821                             root, iot->u.pu_v2->baSourceId,
4822                             iot->u.pu_v2->bNrInPins, info);
4823                         break;
4824
4825                 case UDESCSUB_AC_EXTENSION_V2:
4826                         uaudio_mixer_merge_outputs(&iot->usr, info);
4827                         uaudio20_mixer_find_inputs_sub(
4828                             root, iot->u.eu_v2->baSourceId,
4829                             iot->u.eu_v2->bNrInPins, info);
4830                         break;
4831                 default:
4832                         break;
4833                 }
4834         }
4835 }
4836
4837 static void
4838 uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root,
4839     const uint8_t *p_id, uint8_t n_id,
4840     struct uaudio_search_result *info)
4841 {
4842         struct uaudio_terminal_node *iot;
4843         uint8_t n;
4844         uint8_t i;
4845         uint8_t is_last;
4846         uint8_t id;
4847
4848 top:
4849         for (n = 0; n < n_id; n++) {
4850
4851                 i = p_id[n];
4852
4853                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4854                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4855                         return;
4856                 }
4857
4858                 info->recurse_level++;
4859
4860                 iot = (root + i);
4861
4862                 if (iot->u.desc == NULL)
4863                         continue;
4864
4865                 is_last = ((n + 1) == n_id);
4866
4867                 switch (iot->u.desc->bDescriptorSubtype) {
4868                 case UDESCSUB_AC_INPUT:
4869                         info->is_input = 1;
4870                         if (is_last) {
4871                                 p_id = &iot->u.it_v2->bCSourceId;
4872                                 n_id = 1;
4873                                 goto top;
4874                         }
4875                         uaudio20_mixer_find_clocks_sub(root,
4876                             &iot->u.it_v2->bCSourceId, 1, info);
4877                         break;
4878
4879                 case UDESCSUB_AC_OUTPUT:
4880                         info->is_input = 0;
4881                         if (is_last) {
4882                                 p_id = &iot->u.ot_v2->bCSourceId;
4883                                 n_id = 1;
4884                                 goto top;
4885                         }
4886                         uaudio20_mixer_find_clocks_sub(root,
4887                             &iot->u.ot_v2->bCSourceId, 1, info);
4888                         break;
4889
4890                 case UDESCSUB_AC_CLOCK_SEL:
4891                         if (is_last) {
4892                                 p_id = iot->u.csel_v2->baCSourceId;
4893                                 n_id = iot->u.csel_v2->bNrInPins;
4894                                 goto top;
4895                         }
4896                         uaudio20_mixer_find_clocks_sub(root,
4897                             iot->u.csel_v2->baCSourceId,
4898                             iot->u.csel_v2->bNrInPins, info);
4899                         break;
4900
4901                 case UDESCSUB_AC_CLOCK_MUL:
4902                         if (is_last) {
4903                                 p_id = &iot->u.cmul_v2->bCSourceId;
4904                                 n_id = 1;
4905                                 goto top;
4906                         }
4907                         uaudio20_mixer_find_clocks_sub(root,
4908                             &iot->u.cmul_v2->bCSourceId,
4909                             1, info);
4910                         break;
4911
4912                 case UDESCSUB_AC_CLOCK_SRC:
4913
4914                         id = iot->u.csrc_v2->bClockId;
4915
4916                         switch (info->is_input) {
4917                         case 0:
4918                                 info->bit_output[id / 8] |= (1 << (id % 8));
4919                                 break;
4920                         case 1:
4921                                 info->bit_input[id / 8] |= (1 << (id % 8));
4922                                 break;
4923                         default:
4924                                 break;
4925                         }
4926                         break;
4927
4928                 default:
4929                         break;
4930                 }
4931         }
4932 }
4933
4934 static void
4935 uaudio_mixer_fill_info(struct uaudio_softc *sc,
4936     struct usb_device *udev, void *desc)
4937 {
4938         const struct usb_audio_control_descriptor *acdp;
4939         struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
4940         const struct usb_descriptor *dp;
4941         const struct usb_audio_unit *au;
4942         struct uaudio_terminal_node *iot = NULL;
4943         uint16_t wTotalLen;
4944         uint8_t ID_max = 0;             /* inclusive */
4945         uint8_t i;
4946
4947         desc = usb_desc_foreach(cd, desc);
4948
4949         if (desc == NULL) {
4950                 DPRINTF("no Audio Control header\n");
4951                 goto done;
4952         }
4953         acdp = desc;
4954
4955         if ((acdp->bLength < sizeof(*acdp)) ||
4956             (acdp->bDescriptorType != UDESC_CS_INTERFACE) ||
4957             (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) {
4958                 DPRINTF("invalid Audio Control header\n");
4959                 goto done;
4960         }
4961         /* "wTotalLen" is allowed to be corrupt */
4962         wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength;
4963
4964         /* get USB audio revision */
4965         sc->sc_audio_rev = UGETW(acdp->bcdADC);
4966
4967         DPRINTFN(3, "found AC header, vers=%03x, len=%d\n",
4968             sc->sc_audio_rev, wTotalLen);
4969
4970         iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP,
4971             M_WAITOK | M_ZERO);
4972
4973         while ((desc = usb_desc_foreach(cd, desc))) {
4974
4975                 dp = desc;
4976
4977                 if (dp->bLength > wTotalLen) {
4978                         break;
4979                 } else {
4980                         wTotalLen -= dp->bLength;
4981                 }
4982
4983                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30)
4984                         au = NULL;
4985                 else if (sc->sc_audio_rev >= UAUDIO_VERSION_20)
4986                         au = uaudio20_mixer_verify_desc(dp, 0);
4987                 else
4988                         au = uaudio_mixer_verify_desc(dp, 0);
4989
4990                 if (au) {
4991                         iot[au->bUnitId].u.desc = (const void *)au;
4992                         if (au->bUnitId > ID_max)
4993                                 ID_max = au->bUnitId;
4994                 }
4995         }
4996
4997         DPRINTF("Maximum ID=%d\n", ID_max);
4998
4999         /*
5000          * determine sourcing inputs for
5001          * all nodes in the tree:
5002          */
5003         i = ID_max;
5004         do {
5005                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5006                         /* FALLTHROUGH */
5007                 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5008                         uaudio20_mixer_find_inputs_sub(iot,
5009                             &i, 1, &((iot + i)->usr));
5010
5011                         sc->sc_mixer_clocks.is_input = 255;
5012                         sc->sc_mixer_clocks.recurse_level = 0;
5013
5014                         uaudio20_mixer_find_clocks_sub(iot,
5015                             &i, 1, &sc->sc_mixer_clocks);
5016                 } else {
5017                         uaudio_mixer_find_inputs_sub(iot,
5018                             &i, 1, &((iot + i)->usr));
5019                 }
5020         } while (i--);
5021
5022         /* set "id_max" and "root" */
5023
5024         i = ID_max;
5025         do {
5026                 (iot + i)->usr.id_max = ID_max;
5027                 (iot + i)->root = iot;
5028         } while (i--);
5029
5030         /*
5031          * Scan the config to create a linked list of "mixer" nodes:
5032          */
5033
5034         i = ID_max;
5035         do {
5036                 dp = iot[i].u.desc;
5037
5038                 if (dp == NULL)
5039                         continue;
5040
5041                 DPRINTFN(11, "id=%d subtype=%d\n",
5042                     i, dp->bDescriptorSubtype);
5043
5044                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5045                         continue;
5046                 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5047
5048                         switch (dp->bDescriptorSubtype) {
5049                         case UDESCSUB_AC_HEADER:
5050                                 DPRINTF("unexpected AC header\n");
5051                                 break;
5052
5053                         case UDESCSUB_AC_INPUT:
5054                         case UDESCSUB_AC_OUTPUT:
5055                         case UDESCSUB_AC_PROCESSING_V2:
5056                         case UDESCSUB_AC_EXTENSION_V2:
5057                         case UDESCSUB_AC_EFFECT:
5058                         case UDESCSUB_AC_CLOCK_SRC:
5059                         case UDESCSUB_AC_CLOCK_SEL:
5060                         case UDESCSUB_AC_CLOCK_MUL:
5061                         case UDESCSUB_AC_SAMPLE_RT:
5062                                 break;
5063
5064                         case UDESCSUB_AC_MIXER:
5065                                 uaudio20_mixer_add_mixer(sc, iot, i);
5066                                 break;
5067
5068                         case UDESCSUB_AC_SELECTOR:
5069                                 uaudio20_mixer_add_selector(sc, iot, i);
5070                                 break;
5071
5072                         case UDESCSUB_AC_FEATURE:
5073                                 uaudio20_mixer_add_feature(sc, iot, i);
5074                                 break;
5075
5076                         default:
5077                                 DPRINTF("bad AC desc subtype=0x%02x\n",
5078                                     dp->bDescriptorSubtype);
5079                                 break;
5080                         }
5081                         continue;
5082                 }
5083
5084                 switch (dp->bDescriptorSubtype) {
5085                 case UDESCSUB_AC_HEADER:
5086                         DPRINTF("unexpected AC header\n");
5087                         break;
5088
5089                 case UDESCSUB_AC_INPUT:
5090                 case UDESCSUB_AC_OUTPUT:
5091                         break;
5092
5093                 case UDESCSUB_AC_MIXER:
5094                         uaudio_mixer_add_mixer(sc, iot, i);
5095                         break;
5096
5097                 case UDESCSUB_AC_SELECTOR:
5098                         uaudio_mixer_add_selector(sc, iot, i);
5099                         break;
5100
5101                 case UDESCSUB_AC_FEATURE:
5102                         uaudio_mixer_add_feature(sc, iot, i);
5103                         break;
5104
5105                 case UDESCSUB_AC_PROCESSING:
5106                         uaudio_mixer_add_processing(sc, iot, i);
5107                         break;
5108
5109                 case UDESCSUB_AC_EXTENSION:
5110                         uaudio_mixer_add_extension(sc, iot, i);
5111                         break;
5112
5113                 default:
5114                         DPRINTF("bad AC desc subtype=0x%02x\n",
5115                             dp->bDescriptorSubtype);
5116                         break;
5117                 }
5118
5119         } while (i--);
5120
5121 done:
5122         free(iot, M_TEMP);
5123 }
5124
5125 static int
5126 uaudio_mixer_get(struct usb_device *udev, uint16_t audio_rev,
5127     uint8_t what, struct uaudio_mixer_node *mc)
5128 {
5129         struct usb_device_request req;
5130         int val;
5131         uint8_t data[2 + (2 * 3)];
5132         usb_error_t err;
5133
5134         if (mc->wValue[0] == -1)
5135                 return (0);
5136
5137         if (audio_rev >= UAUDIO_VERSION_30)
5138                 return (0);
5139         else if (audio_rev >= UAUDIO_VERSION_20) {
5140                 if (what == GET_CUR) {
5141                         req.bRequest = UA20_CS_CUR;
5142                         USETW(req.wLength, 2);
5143                 } else {
5144                         req.bRequest = UA20_CS_RANGE;
5145                         USETW(req.wLength, 8);
5146                 }
5147         } else {
5148                 uint16_t len = MIX_SIZE(mc->type);
5149
5150                 req.bRequest = what;
5151                 USETW(req.wLength, len);
5152         }
5153
5154         req.bmRequestType = UT_READ_CLASS_INTERFACE;
5155         USETW(req.wValue, mc->wValue[0]);
5156         USETW(req.wIndex, mc->wIndex);
5157
5158         memset(data, 0, sizeof(data));
5159
5160         err = usbd_do_request(udev, NULL, &req, data);
5161         if (err) {
5162                 DPRINTF("err=%s\n", usbd_errstr(err));
5163                 return (0);
5164         }
5165
5166         if (audio_rev >= UAUDIO_VERSION_30) {
5167                 val = 0;
5168         } else if (audio_rev >= UAUDIO_VERSION_20) {
5169                 switch (what) {
5170                 case GET_CUR:
5171                         val = (data[0] | (data[1] << 8));
5172                         break;
5173                 case GET_MIN:
5174                         val = (data[2] | (data[3] << 8));
5175                         break;
5176                 case GET_MAX:
5177                         val = (data[4] | (data[5] << 8));
5178                         break;
5179                 case GET_RES:
5180                         val = (data[6] | (data[7] << 8));
5181                         break;
5182                 default:
5183                         val = 0;
5184                         break;
5185                 }
5186         } else {
5187                 val = (data[0] | (data[1] << 8));
5188         }
5189
5190         if (what == GET_CUR || what == GET_MIN || what == GET_MAX)
5191                 val = uaudio_mixer_signext(mc->type, val);
5192
5193         DPRINTFN(3, "val=%d\n", val);
5194
5195         return (val);
5196 }
5197
5198 static void
5199 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error)
5200 {
5201         struct usb_device_request req;
5202         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
5203         struct uaudio_mixer_node *mc = sc->sc_mixer_curr;
5204         struct usb_page_cache *pc;
5205         uint16_t len;
5206         uint8_t repeat = 1;
5207         uint8_t update;
5208         uint8_t chan;
5209         uint8_t buf[2];
5210
5211         DPRINTF("\n");
5212
5213         switch (USB_GET_STATE(xfer)) {
5214         case USB_ST_TRANSFERRED:
5215 tr_transferred:
5216         case USB_ST_SETUP:
5217 tr_setup:
5218
5219                 if (mc == NULL) {
5220                         mc = sc->sc_mixer_root;
5221                         sc->sc_mixer_curr = mc;
5222                         sc->sc_mixer_chan = 0;
5223                         repeat = 0;
5224                 }
5225                 while (mc) {
5226                         while (sc->sc_mixer_chan < mc->nchan) {
5227
5228                                 chan = sc->sc_mixer_chan;
5229
5230                                 sc->sc_mixer_chan++;
5231
5232                                 update = ((mc->update[chan / 8] & (1 << (chan % 8))) &&
5233                                     (mc->wValue[chan] != -1));
5234
5235                                 mc->update[chan / 8] &= ~(1 << (chan % 8));
5236
5237                                 if (update) {
5238
5239                                         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5240                                         USETW(req.wValue, mc->wValue[chan]);
5241                                         USETW(req.wIndex, mc->wIndex);
5242
5243                                         if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5244                                                 return;
5245                                         } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5246                                                 len = 2;
5247                                                 req.bRequest = UA20_CS_CUR;
5248                                                 USETW(req.wLength, len);
5249                                         } else {
5250                                                 len = MIX_SIZE(mc->type);
5251                                                 req.bRequest = SET_CUR;
5252                                                 USETW(req.wLength, len);
5253                                         }
5254
5255                                         buf[0] = (mc->wData[chan] & 0xFF);
5256                                         buf[1] = (mc->wData[chan] >> 8) & 0xFF;
5257
5258                                         pc = usbd_xfer_get_frame(xfer, 0);
5259                                         usbd_copy_in(pc, 0, &req, sizeof(req));
5260                                         pc = usbd_xfer_get_frame(xfer, 1);
5261                                         usbd_copy_in(pc, 0, buf, len);
5262
5263                                         usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
5264                                         usbd_xfer_set_frame_len(xfer, 1, len);
5265                                         usbd_xfer_set_frames(xfer, len ? 2 : 1);
5266                                         usbd_transfer_submit(xfer);
5267                                         return;
5268                                 }
5269                         }
5270
5271                         mc = mc->next;
5272                         sc->sc_mixer_curr = mc;
5273                         sc->sc_mixer_chan = 0;
5274                 }
5275
5276                 if (repeat) {
5277                         goto tr_setup;
5278                 }
5279                 break;
5280
5281         default:                        /* Error */
5282                 DPRINTF("error=%s\n", usbd_errstr(error));
5283                 if (error == USB_ERR_CANCELLED) {
5284                         /* do nothing - we are detaching */
5285                         break;
5286                 }
5287                 goto tr_transferred;
5288         }
5289 }
5290
5291 static usb_error_t
5292 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)
5293 {
5294         struct usb_device_request req;
5295         uint8_t data[3];
5296
5297         DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed);
5298
5299         req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
5300         req.bRequest = SET_CUR;
5301         USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
5302         USETW(req.wIndex, endpt);
5303         USETW(req.wLength, 3);
5304         data[0] = speed;
5305         data[1] = speed >> 8;
5306         data[2] = speed >> 16;
5307
5308         return (usbd_do_request(udev, NULL, &req, data));
5309 }
5310
5311 static usb_error_t
5312 uaudio20_set_speed(struct usb_device *udev, uint8_t iface_no,
5313     uint8_t clockid, uint32_t speed)
5314 {
5315         struct usb_device_request req;
5316         uint8_t data[4];
5317
5318         DPRINTFN(6, "ifaceno=%d clockid=%d speed=%u\n",
5319             iface_no, clockid, speed);
5320
5321         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5322         req.bRequest = UA20_CS_CUR;
5323         USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
5324         USETW2(req.wIndex, clockid, iface_no);
5325         USETW(req.wLength, 4);
5326         data[0] = speed;
5327         data[1] = speed >> 8;
5328         data[2] = speed >> 16;
5329         data[3] = speed >> 24;
5330
5331         return (usbd_do_request(udev, NULL, &req, data));
5332 }
5333
5334 static int
5335 uaudio_mixer_signext(uint8_t type, int val)
5336 {
5337         if (!MIX_UNSIGNED(type)) {
5338                 if (MIX_SIZE(type) == 2) {
5339                         val = (int16_t)val;
5340                 } else {
5341                         val = (int8_t)val;
5342                 }
5343         }
5344         return (val);
5345 }
5346
5347 static int
5348 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int val)
5349 {
5350         if (mc->type == MIX_ON_OFF) {
5351                 val = (val != 0);
5352         } else if (mc->type != MIX_SELECTOR) {
5353
5354                 /* compute actual volume */
5355                 val = (val * mc->mul) / 100;
5356
5357                 /* add lower offset */
5358                 val = val + mc->minval;
5359         }
5360         /* make sure we don't write a value out of range */
5361         if (val > mc->maxval)
5362                 val = mc->maxval;
5363         else if (val < mc->minval)
5364                 val = mc->minval;
5365
5366         DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n",
5367             mc->type, val, mc->minval, mc->maxval, val);
5368         return (val);
5369 }
5370
5371 static void
5372 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc,
5373     uint8_t chan, int val)
5374 {
5375         val = uaudio_mixer_bsd2value(mc, val);
5376
5377         mc->update[chan / 8] |= (1 << (chan % 8));
5378         mc->wData[chan] = val;
5379
5380         /* start the transfer, if not already started */
5381
5382         usbd_transfer_start(sc->sc_mixer_xfer[0]);
5383 }
5384
5385 static void
5386 uaudio_mixer_init(struct uaudio_softc *sc, unsigned index)
5387 {
5388         struct uaudio_mixer_node *mc;
5389         int32_t i;
5390
5391         if (index != 0)
5392                 return;
5393         for (mc = sc->sc_mixer_root; mc; mc = mc->next) {
5394
5395                 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
5396                         /*
5397                          * Set device mask bits. See
5398                          * /usr/include/machine/soundcard.h
5399                          */
5400                         sc->sc_child[index].mix_info |= 1U << mc->ctl;
5401                 }
5402                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5403                     (mc->type == MIX_SELECTOR)) {
5404
5405                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5406                                 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES)
5407                                         continue;
5408                                 sc->sc_child[index].recsrc_info |= 1U << mc->slctrtype[i - 1];
5409                         }
5410                 }
5411         }
5412 }
5413
5414 int
5415 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5416 {
5417         unsigned i = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5418
5419         DPRINTF("child=%u\n", i);
5420
5421         sc->sc_child[i].mixer_lock = mixer_get_lock(m);
5422         sc->sc_child[i].mixer_dev = m;
5423
5424         if (i == 0 &&
5425             usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
5426             sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
5427             sc->sc_child[i].mixer_lock)) {
5428                 DPRINTFN(0, "could not allocate USB transfer for mixer!\n");
5429                 return (ENOMEM);
5430         }
5431
5432         if (sc->sc_play_chan[i].num_alt > 0 &&
5433             (sc->sc_child[i].mix_info & SOUND_MASK_VOLUME) == 0) {
5434                 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM);
5435                 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE);
5436         }
5437         mix_setdevs(m, sc->sc_child[i].mix_info);
5438         mix_setrecdevs(m, sc->sc_child[i].recsrc_info);
5439         return (0);
5440 }
5441
5442 int
5443 uaudio_mixer_uninit_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5444 {
5445         unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5446
5447         DPRINTF("child=%u\n", index);
5448
5449         if (index == 0)
5450                 usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
5451
5452         sc->sc_child[index].mixer_lock = NULL;
5453
5454         return (0);
5455 }
5456
5457 void
5458 uaudio_mixer_set(struct uaudio_softc *sc, struct snd_mixer *m,
5459     unsigned type, unsigned left, unsigned right)
5460 {
5461         unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5462         struct uaudio_mixer_node *mc;
5463         int chan;
5464
5465         if (index != 0)
5466                 return;
5467         for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) {
5468                 if (mc->ctl == type) {
5469                         for (chan = 0; chan < mc->nchan; chan++) {
5470                                 uaudio_mixer_ctl_set(sc, mc, chan,
5471                                     chan == 0 ? left : right);
5472                         }
5473                 }
5474         }
5475 }
5476
5477 uint32_t
5478 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, struct snd_mixer *m, uint32_t src)
5479 {
5480         unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5481         struct uaudio_mixer_node *mc;
5482         uint32_t mask;
5483         uint32_t temp;
5484         int32_t i;
5485
5486         if (index != 0)
5487                 return (0);
5488         for (mc = sc->sc_mixer_root; mc; mc = mc->next) {
5489
5490                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5491                     (mc->type == MIX_SELECTOR)) {
5492
5493                         /* compute selector mask */
5494
5495                         mask = 0;
5496                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++)
5497                                 mask |= 1U << mc->slctrtype[i - 1];
5498
5499                         temp = mask & src;
5500                         if (temp == 0)
5501                                 continue;
5502
5503                         /* find the first set bit */
5504                         temp = (-temp) & temp;
5505
5506                         /* update "src" */
5507                         src &= ~mask;
5508                         src |= temp;
5509
5510                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5511                                 if (temp != (1U << mc->slctrtype[i - 1]))
5512                                         continue;
5513                                 uaudio_mixer_ctl_set(sc, mc, 0, i);
5514                                 break;
5515                         }
5516                 }
5517         }
5518         return (src);
5519 }
5520
5521 /*========================================================================*
5522  * MIDI support routines
5523  *========================================================================*/
5524
5525 static void
5526 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
5527 {
5528         struct umidi_chan *chan = usbd_xfer_softc(xfer);
5529         struct umidi_sub_chan *sub;
5530         struct usb_page_cache *pc;
5531         uint8_t buf[4];
5532         uint8_t cmd_len;
5533         uint8_t cn;
5534         uint16_t pos;
5535         int actlen;
5536
5537         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
5538
5539         switch (USB_GET_STATE(xfer)) {
5540         case USB_ST_TRANSFERRED:
5541
5542                 DPRINTF("actlen=%d bytes\n", actlen);
5543
5544                 pos = 0;
5545                 pc = usbd_xfer_get_frame(xfer, 0);
5546
5547                 while (actlen >= 4) {
5548
5549                         /* copy out the MIDI data */
5550                         usbd_copy_out(pc, pos, buf, 4);
5551                         /* command length */
5552                         cmd_len = umidi_cmd_to_len[buf[0] & 0xF];
5553                         /* cable number */
5554                         cn = buf[0] >> 4;
5555                         /*
5556                          * Lookup sub-channel. The index is range
5557                          * checked below.
5558                          */
5559                         sub = &chan->sub[cn];
5560
5561                         if ((cmd_len != 0) && (cn < chan->max_emb_jack) &&
5562                             (sub->read_open != 0)) {
5563
5564                                 /* Send data to the application */
5565                                 usb_fifo_put_data_linear(
5566                                     sub->fifo.fp[USB_FIFO_RX],
5567                                     buf + 1, cmd_len, 1);
5568                         }
5569                         actlen -= 4;
5570                         pos += 4;
5571                 }
5572
5573         case USB_ST_SETUP:
5574                 DPRINTF("start\n");
5575 tr_setup:
5576                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
5577                 usbd_transfer_submit(xfer);
5578                 break;
5579
5580         default:
5581                 DPRINTF("error=%s\n", usbd_errstr(error));
5582
5583                 if (error != USB_ERR_CANCELLED) {
5584                         /* try to clear stall first */
5585                         usbd_xfer_set_stall(xfer);
5586                         goto tr_setup;
5587                 }
5588                 break;
5589         }
5590 }
5591
5592 /*
5593  * The following statemachine, that converts MIDI commands to
5594  * USB MIDI packets, derives from Linux's usbmidi.c, which
5595  * was written by "Clemens Ladisch":
5596  *
5597  * Returns:
5598  *    0: No command
5599  * Else: Command is complete
5600  */
5601 static uint8_t
5602 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b)
5603 {
5604         uint8_t p0 = (cn << 4);
5605
5606         if (b >= 0xf8) {
5607                 sub->temp_0[0] = p0 | 0x0f;
5608                 sub->temp_0[1] = b;
5609                 sub->temp_0[2] = 0;
5610                 sub->temp_0[3] = 0;
5611                 sub->temp_cmd = sub->temp_0;
5612                 return (1);
5613
5614         } else if (b >= 0xf0) {
5615                 switch (b) {
5616                 case 0xf0:              /* system exclusive begin */
5617                         sub->temp_1[1] = b;
5618                         sub->state = UMIDI_ST_SYSEX_1;
5619                         break;
5620                 case 0xf1:              /* MIDI time code */
5621                 case 0xf3:              /* song select */
5622                         sub->temp_1[1] = b;
5623                         sub->state = UMIDI_ST_1PARAM;
5624                         break;
5625                 case 0xf2:              /* song position pointer */
5626                         sub->temp_1[1] = b;
5627                         sub->state = UMIDI_ST_2PARAM_1;
5628                         break;
5629                 case 0xf4:              /* unknown */
5630                 case 0xf5:              /* unknown */
5631                         sub->state = UMIDI_ST_UNKNOWN;
5632                         break;
5633                 case 0xf6:              /* tune request */
5634                         sub->temp_1[0] = p0 | 0x05;
5635                         sub->temp_1[1] = 0xf6;
5636                         sub->temp_1[2] = 0;
5637                         sub->temp_1[3] = 0;
5638                         sub->temp_cmd = sub->temp_1;
5639                         sub->state = UMIDI_ST_UNKNOWN;
5640                         return (1);
5641
5642                 case 0xf7:              /* system exclusive end */
5643                         switch (sub->state) {
5644                         case UMIDI_ST_SYSEX_0:
5645                                 sub->temp_1[0] = p0 | 0x05;
5646                                 sub->temp_1[1] = 0xf7;
5647                                 sub->temp_1[2] = 0;
5648                                 sub->temp_1[3] = 0;
5649                                 sub->temp_cmd = sub->temp_1;
5650                                 sub->state = UMIDI_ST_UNKNOWN;
5651                                 return (1);
5652                         case UMIDI_ST_SYSEX_1:
5653                                 sub->temp_1[0] = p0 | 0x06;
5654                                 sub->temp_1[2] = 0xf7;
5655                                 sub->temp_1[3] = 0;
5656                                 sub->temp_cmd = sub->temp_1;
5657                                 sub->state = UMIDI_ST_UNKNOWN;
5658                                 return (1);
5659                         case UMIDI_ST_SYSEX_2:
5660                                 sub->temp_1[0] = p0 | 0x07;
5661                                 sub->temp_1[3] = 0xf7;
5662                                 sub->temp_cmd = sub->temp_1;
5663                                 sub->state = UMIDI_ST_UNKNOWN;
5664                                 return (1);
5665                         }
5666                         sub->state = UMIDI_ST_UNKNOWN;
5667                         break;
5668                 }
5669         } else if (b >= 0x80) {
5670                 sub->temp_1[1] = b;
5671                 if ((b >= 0xc0) && (b <= 0xdf)) {
5672                         sub->state = UMIDI_ST_1PARAM;
5673                 } else {
5674                         sub->state = UMIDI_ST_2PARAM_1;
5675                 }
5676         } else {                        /* b < 0x80 */
5677                 switch (sub->state) {
5678                 case UMIDI_ST_1PARAM:
5679                         if (sub->temp_1[1] < 0xf0) {
5680                                 p0 |= sub->temp_1[1] >> 4;
5681                         } else {
5682                                 p0 |= 0x02;
5683                                 sub->state = UMIDI_ST_UNKNOWN;
5684                         }
5685                         sub->temp_1[0] = p0;
5686                         sub->temp_1[2] = b;
5687                         sub->temp_1[3] = 0;
5688                         sub->temp_cmd = sub->temp_1;
5689                         return (1);
5690                 case UMIDI_ST_2PARAM_1:
5691                         sub->temp_1[2] = b;
5692                         sub->state = UMIDI_ST_2PARAM_2;
5693                         break;
5694                 case UMIDI_ST_2PARAM_2:
5695                         if (sub->temp_1[1] < 0xf0) {
5696                                 p0 |= sub->temp_1[1] >> 4;
5697                                 sub->state = UMIDI_ST_2PARAM_1;
5698                         } else {
5699                                 p0 |= 0x03;
5700                                 sub->state = UMIDI_ST_UNKNOWN;
5701                         }
5702                         sub->temp_1[0] = p0;
5703                         sub->temp_1[3] = b;
5704                         sub->temp_cmd = sub->temp_1;
5705                         return (1);
5706                 case UMIDI_ST_SYSEX_0:
5707                         sub->temp_1[1] = b;
5708                         sub->state = UMIDI_ST_SYSEX_1;
5709                         break;
5710                 case UMIDI_ST_SYSEX_1:
5711                         sub->temp_1[2] = b;
5712                         sub->state = UMIDI_ST_SYSEX_2;
5713                         break;
5714                 case UMIDI_ST_SYSEX_2:
5715                         sub->temp_1[0] = p0 | 0x04;
5716                         sub->temp_1[3] = b;
5717                         sub->temp_cmd = sub->temp_1;
5718                         sub->state = UMIDI_ST_SYSEX_0;
5719                         return (1);
5720                 default:
5721                         break;
5722                 }
5723         }
5724         return (0);
5725 }
5726
5727 static void
5728 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
5729 {
5730         struct umidi_chan *chan = usbd_xfer_softc(xfer);
5731         struct umidi_sub_chan *sub;
5732         struct usb_page_cache *pc;
5733         uint32_t actlen;
5734         uint16_t nframes;
5735         uint8_t buf;
5736         uint8_t start_cable;
5737         uint8_t tr_any;
5738         int len;
5739
5740         usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
5741
5742         /*
5743          * NOTE: Some MIDI devices only accept 4 bytes of data per
5744          * short terminated USB transfer.
5745          */
5746         switch (USB_GET_STATE(xfer)) {
5747         case USB_ST_TRANSFERRED:
5748                 DPRINTF("actlen=%d bytes\n", len);
5749
5750         case USB_ST_SETUP:
5751 tr_setup:
5752                 DPRINTF("start\n");
5753
5754                 nframes = 0;    /* reset */
5755                 start_cable = chan->curr_cable;
5756                 tr_any = 0;
5757                 pc = usbd_xfer_get_frame(xfer, 0);
5758
5759                 while (1) {
5760
5761                         /* round robin de-queueing */
5762
5763                         sub = &chan->sub[chan->curr_cable];
5764
5765                         if (sub->write_open) {
5766                                 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX],
5767                                     &buf, 1, &actlen, 0);
5768                         } else {
5769                                 actlen = 0;
5770                         }
5771
5772                         if (actlen) {
5773
5774                                 tr_any = 1;
5775
5776                                 DPRINTF("byte=0x%02x from FIFO %u\n", buf,
5777                                     (unsigned int)chan->curr_cable);
5778
5779                                 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) {
5780
5781                                         DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n",
5782                                             sub->temp_cmd[0], sub->temp_cmd[1],
5783                                             sub->temp_cmd[2], sub->temp_cmd[3]);
5784
5785                                         usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4);
5786
5787                                         nframes++;
5788
5789                                         if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0))
5790                                                 break;
5791                                 } else {
5792                                         continue;
5793                                 }
5794                         }
5795
5796                         chan->curr_cable++;
5797                         if (chan->curr_cable >= chan->max_emb_jack)
5798                                 chan->curr_cable = 0;
5799
5800                         if (chan->curr_cable == start_cable) {
5801                                 if (tr_any == 0)
5802                                         break;
5803                                 tr_any = 0;
5804                         }
5805                 }
5806
5807                 if (nframes != 0) {
5808                         DPRINTF("Transferring %d frames\n", (int)nframes);
5809                         usbd_xfer_set_frame_len(xfer, 0, 4 * nframes);
5810                         usbd_transfer_submit(xfer);
5811                 }
5812                 break;
5813
5814         default:                        /* Error */
5815
5816                 DPRINTF("error=%s\n", usbd_errstr(error));
5817
5818                 if (error != USB_ERR_CANCELLED) {
5819                         /* try to clear stall first */
5820                         usbd_xfer_set_stall(xfer);
5821                         goto tr_setup;
5822                 }
5823                 break;
5824         }
5825 }
5826
5827 static struct umidi_sub_chan *
5828 umidi_sub_by_fifo(struct usb_fifo *fifo)
5829 {
5830         struct umidi_chan *chan = usb_fifo_softc(fifo);
5831         struct umidi_sub_chan *sub;
5832         uint32_t n;
5833
5834         for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) {
5835                 sub = &chan->sub[n];
5836                 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) ||
5837                     (sub->fifo.fp[USB_FIFO_TX] == fifo)) {
5838                         return (sub);
5839                 }
5840         }
5841
5842         panic("%s:%d cannot find usb_fifo!\n",
5843             __FILE__, __LINE__);
5844
5845         return (NULL);
5846 }
5847
5848 static void
5849 umidi_start_read(struct usb_fifo *fifo)
5850 {
5851         struct umidi_chan *chan = usb_fifo_softc(fifo);
5852
5853         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
5854 }
5855
5856 static void
5857 umidi_stop_read(struct usb_fifo *fifo)
5858 {
5859         struct umidi_chan *chan = usb_fifo_softc(fifo);
5860         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5861
5862         DPRINTF("\n");
5863
5864         sub->read_open = 0;
5865
5866         if (--(chan->read_open_refcount) == 0) {
5867                 /*
5868                  * XXX don't stop the read transfer here, hence that causes
5869                  * problems with some MIDI adapters
5870                  */
5871                 DPRINTF("(stopping read transfer)\n");
5872         }
5873 }
5874
5875 static void
5876 umidi_start_write(struct usb_fifo *fifo)
5877 {
5878         struct umidi_chan *chan = usb_fifo_softc(fifo);
5879
5880         if (chan->xfer[UMIDI_TX_TRANSFER] == NULL) {
5881                 uint8_t buf[1];
5882                 int actlen;
5883                 do {
5884                         /* dump data */
5885                         usb_fifo_get_data_linear(fifo, buf, 1, &actlen, 0);
5886                 } while (actlen > 0);
5887         } else {
5888                 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]);
5889         }
5890 }
5891
5892 static void
5893 umidi_stop_write(struct usb_fifo *fifo)
5894 {
5895         struct umidi_chan *chan = usb_fifo_softc(fifo);
5896         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5897
5898         DPRINTF("\n");
5899
5900         sub->write_open = 0;
5901
5902         if (--(chan->write_open_refcount) == 0) {
5903                 DPRINTF("(stopping write transfer)\n");
5904                 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]);
5905         }
5906 }
5907
5908 static int
5909 umidi_open(struct usb_fifo *fifo, int fflags)
5910 {
5911         struct umidi_chan *chan = usb_fifo_softc(fifo);
5912         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5913
5914         if (fflags & FREAD) {
5915                 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
5916                         return (ENOMEM);
5917                 }
5918                 mtx_lock(&chan->mtx);
5919                 chan->read_open_refcount++;
5920                 sub->read_open = 1;
5921                 mtx_unlock(&chan->mtx);
5922         }
5923         if (fflags & FWRITE) {
5924                 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
5925                         return (ENOMEM);
5926                 }
5927                 /* clear stall first */
5928                 mtx_lock(&chan->mtx);
5929                 chan->write_open_refcount++;
5930                 sub->write_open = 1;
5931
5932                 /* reset */
5933                 sub->state = UMIDI_ST_UNKNOWN;
5934                 mtx_unlock(&chan->mtx);
5935         }
5936         return (0);                     /* success */
5937 }
5938
5939 static void
5940 umidi_close(struct usb_fifo *fifo, int fflags)
5941 {
5942         if (fflags & FREAD) {
5943                 usb_fifo_free_buffer(fifo);
5944         }
5945         if (fflags & FWRITE) {
5946                 usb_fifo_free_buffer(fifo);
5947         }
5948 }
5949
5950
5951 static int
5952 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data,
5953     int fflags)
5954 {
5955         return (ENODEV);
5956 }
5957
5958 static void
5959 umidi_init(device_t dev)
5960 {
5961         struct uaudio_softc *sc = device_get_softc(dev);
5962         struct umidi_chan *chan = &sc->sc_midi_chan;
5963
5964         mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE);
5965 }
5966
5967 static struct usb_fifo_methods umidi_fifo_methods = {
5968         .f_start_read = &umidi_start_read,
5969         .f_start_write = &umidi_start_write,
5970         .f_stop_read = &umidi_stop_read,
5971         .f_stop_write = &umidi_stop_write,
5972         .f_open = &umidi_open,
5973         .f_close = &umidi_close,
5974         .f_ioctl = &umidi_ioctl,
5975         .basename[0] = "umidi",
5976 };
5977
5978 static int
5979 umidi_probe(device_t dev)
5980 {
5981         struct uaudio_softc *sc = device_get_softc(dev);
5982         struct usb_attach_arg *uaa = device_get_ivars(dev);
5983         struct umidi_chan *chan = &sc->sc_midi_chan;
5984         struct umidi_sub_chan *sub;
5985         int unit = device_get_unit(dev);
5986         int error;
5987         uint32_t n;
5988
5989         if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI))
5990                 chan->single_command = 1;
5991
5992         if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index,
5993             chan->iface_alt_index)) {
5994                 DPRINTF("setting of alternate index failed!\n");
5995                 goto detach;
5996         }
5997         usbd_set_parent_iface(sc->sc_udev, chan->iface_index,
5998             sc->sc_mixer_iface_index);
5999
6000         error = usbd_transfer_setup(uaa->device, &chan->iface_index,
6001             chan->xfer, umidi_config, UMIDI_N_TRANSFER,
6002             chan, &chan->mtx);
6003         if (error) {
6004                 DPRINTF("error=%s\n", usbd_errstr(error));
6005                 goto detach;
6006         }
6007         if (chan->xfer[UMIDI_TX_TRANSFER] == NULL &&
6008             chan->xfer[UMIDI_RX_TRANSFER] == NULL) {
6009                 DPRINTF("no BULK or INTERRUPT MIDI endpoint(s) found\n");
6010                 goto detach;
6011         }
6012
6013         /*
6014          * Some USB MIDI device makers couldn't resist using
6015          * wMaxPacketSize = 4 for RX and TX BULK endpoints, although
6016          * that size is an unsupported value for FULL speed BULK
6017          * endpoints. The same applies to some HIGH speed MIDI devices
6018          * which are using a wMaxPacketSize different from 512 bytes.
6019          *
6020          * Refer to section 5.8.3 in USB 2.0 PDF: Cite: "All Host
6021          * Controllers are required to have support for 8-, 16-, 32-,
6022          * and 64-byte maximum packet sizes for full-speed bulk
6023          * endpoints and 512 bytes for high-speed bulk endpoints."
6024          */
6025         if (chan->xfer[UMIDI_TX_TRANSFER] != NULL &&
6026             usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER]))
6027                 chan->single_command = 1;
6028
6029         if (chan->single_command != 0)
6030                 device_printf(dev, "Single command MIDI quirk enabled\n");
6031
6032         if ((chan->max_emb_jack == 0) ||
6033             (chan->max_emb_jack > UMIDI_EMB_JACK_MAX)) {
6034                 chan->max_emb_jack = UMIDI_EMB_JACK_MAX;
6035         }
6036
6037         for (n = 0; n < chan->max_emb_jack; n++) {
6038
6039                 sub = &chan->sub[n];
6040
6041                 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
6042                     &umidi_fifo_methods, &sub->fifo, unit, n,
6043                     chan->iface_index,
6044                     UID_ROOT, GID_OPERATOR, 0644);
6045                 if (error) {
6046                         goto detach;
6047                 }
6048         }
6049
6050         mtx_lock(&chan->mtx);
6051
6052         /*
6053          * NOTE: At least one device will not work properly unless the
6054          * BULK IN pipe is open all the time. This might have to do
6055          * about that the internal queues of the device overflow if we
6056          * don't read them regularly.
6057          */
6058         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
6059
6060         mtx_unlock(&chan->mtx);
6061
6062         return (0);                     /* success */
6063
6064 detach:
6065         return (ENXIO);                 /* failure */
6066 }
6067
6068 static int
6069 umidi_detach(device_t dev)
6070 {
6071         struct uaudio_softc *sc = device_get_softc(dev);
6072         struct umidi_chan *chan = &sc->sc_midi_chan;
6073         uint32_t n;
6074
6075         for (n = 0; n < UMIDI_EMB_JACK_MAX; n++)
6076                 usb_fifo_detach(&chan->sub[n].fifo);
6077
6078         mtx_lock(&chan->mtx);
6079
6080         usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]);
6081
6082         mtx_unlock(&chan->mtx);
6083
6084         usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
6085
6086         mtx_destroy(&chan->mtx);
6087
6088         return (0);
6089 }
6090
6091 static void
6092 uaudio_hid_rx_callback(struct usb_xfer *xfer, usb_error_t error)
6093 {
6094         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
6095         const uint8_t *buffer = usbd_xfer_get_frame_buffer(xfer, 0);
6096         struct snd_mixer *m;
6097         uint8_t id;
6098         int actlen;
6099
6100         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
6101
6102         switch (USB_GET_STATE(xfer)) {
6103         case USB_ST_TRANSFERRED:
6104                 DPRINTF("actlen=%d\n", actlen);
6105
6106                 if (actlen != 0 &&
6107                     (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) {
6108                         id = *buffer;
6109                         buffer++;
6110                         actlen--;
6111                 } else {
6112                         id = 0;
6113                 }
6114
6115                 m = sc->sc_child[0].mixer_dev;
6116
6117                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) &&
6118                     (sc->sc_hid.mute_id == id) &&
6119                     hid_get_data(buffer, actlen,
6120                     &sc->sc_hid.mute_loc)) {
6121
6122                         DPRINTF("Mute toggle\n");
6123
6124                         mixer_hwvol_mute_locked(m);
6125                 }
6126
6127                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) &&
6128                     (sc->sc_hid.volume_up_id == id) &&
6129                     hid_get_data(buffer, actlen,
6130                     &sc->sc_hid.volume_up_loc)) {
6131
6132                         DPRINTF("Volume Up\n");
6133
6134                         mixer_hwvol_step_locked(m, 1, 1);
6135                 }
6136
6137                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) &&
6138                     (sc->sc_hid.volume_down_id == id) &&
6139                     hid_get_data(buffer, actlen,
6140                     &sc->sc_hid.volume_down_loc)) {
6141
6142                         DPRINTF("Volume Down\n");
6143
6144                         mixer_hwvol_step_locked(m, -1, -1);
6145                 }
6146
6147         case USB_ST_SETUP:
6148 tr_setup:
6149                 /* check if we can put more data into the FIFO */
6150                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
6151                 usbd_transfer_submit(xfer);
6152                 break;
6153
6154         default:                        /* Error */
6155
6156                 DPRINTF("error=%s\n", usbd_errstr(error));
6157
6158                 if (error != USB_ERR_CANCELLED) {
6159                         /* try to clear stall first */
6160                         usbd_xfer_set_stall(xfer);
6161                         goto tr_setup;
6162                 }
6163                 break;
6164         }
6165 }
6166
6167 static int
6168 uaudio_hid_probe(struct uaudio_softc *sc,
6169     struct usb_attach_arg *uaa)
6170 {
6171         void *d_ptr;
6172         uint32_t flags;
6173         uint16_t d_len;
6174         uint8_t id;
6175         int error;
6176
6177         if (!(sc->sc_hid.flags & UAUDIO_HID_VALID))
6178                 return (-1);
6179
6180         if (sc->sc_child[0].mixer_lock == NULL)
6181                 return (-1);
6182
6183         /* Get HID descriptor */
6184         error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
6185             &d_len, M_TEMP, sc->sc_hid.iface_index);
6186
6187         if (error) {
6188                 DPRINTF("error reading report description\n");
6189                 return (-1);
6190         }
6191
6192         /* check if there is an ID byte */
6193         hid_report_size(d_ptr, d_len, hid_input, &id);
6194
6195         if (id != 0)
6196                 sc->sc_hid.flags |= UAUDIO_HID_HAS_ID;
6197
6198         if (hid_locate(d_ptr, d_len,
6199             HID_USAGE2(HUP_CONSUMER, 0xE9 /* Volume Increment */),
6200             hid_input, 0, &sc->sc_hid.volume_up_loc, &flags,
6201             &sc->sc_hid.volume_up_id)) {
6202                 if (flags & HIO_VARIABLE)
6203                         sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP;
6204                 DPRINTFN(1, "Found Volume Up key\n");
6205         }
6206
6207         if (hid_locate(d_ptr, d_len,
6208             HID_USAGE2(HUP_CONSUMER, 0xEA /* Volume Decrement */),
6209             hid_input, 0, &sc->sc_hid.volume_down_loc, &flags,
6210             &sc->sc_hid.volume_down_id)) {
6211                 if (flags & HIO_VARIABLE)
6212                         sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN;
6213                 DPRINTFN(1, "Found Volume Down key\n");
6214         }
6215
6216         if (hid_locate(d_ptr, d_len,
6217             HID_USAGE2(HUP_CONSUMER, 0xE2 /* Mute */),
6218             hid_input, 0, &sc->sc_hid.mute_loc, &flags,
6219             &sc->sc_hid.mute_id)) {
6220                 if (flags & HIO_VARIABLE)
6221                         sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE;
6222                 DPRINTFN(1, "Found Mute key\n");
6223         }
6224
6225         free(d_ptr, M_TEMP);
6226
6227         if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP |
6228             UAUDIO_HID_HAS_VOLUME_DOWN |
6229             UAUDIO_HID_HAS_MUTE))) {
6230                 DPRINTFN(1, "Did not find any volume related keys\n");
6231                 return (-1);
6232         }
6233
6234         /* prevent the uhid driver from attaching */
6235         usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index,
6236             sc->sc_mixer_iface_index);
6237
6238         /* allocate USB transfers */
6239         error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index,
6240             sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER,
6241             sc, sc->sc_child[0].mixer_lock);
6242         if (error) {
6243                 DPRINTF("error=%s\n", usbd_errstr(error));
6244                 return (-1);
6245         }
6246         return (0);
6247 }
6248
6249 static void
6250 uaudio_hid_detach(struct uaudio_softc *sc)
6251 {
6252         usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER);
6253 }
6254
6255 DRIVER_MODULE_ORDERED(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0, SI_ORDER_ANY);
6256 MODULE_DEPEND(uaudio, usb, 1, 1, 1);
6257 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
6258 MODULE_VERSION(uaudio, 1);
6259 USB_PNP_HOST_INFO(uaudio_devs);
6260 USB_PNP_HOST_INFO(uaudio_vendor_midi);