sys/dev/sound/usb/uaudio.c

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