sys/dev/sound/usb/uaudio.c

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