sys/dev/sound/usb/uaudio.c

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