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                         ch->jitter_curr = temp - sample_rate;
2089
2090                 ch->feedback_rate = temp;
2091                 break;
2092
2093         case USB_ST_SETUP:
2094                 usbd_xfer_set_frames(xfer, 1);
2095                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_framelen(xfer));
2096                 usbd_transfer_submit(xfer);
2097                 break;
2098
2099         default:                        /* Error */
2100                 break;
2101         }
2102 }
2103
2104 static int
2105 uaudio_chan_is_async(struct uaudio_chan *ch, uint8_t alt)
2106 {
2107         uint8_t attr = ch->usb_alt[alt].p_ed1->bmAttributes;
2108         return (UE_GET_ISO_TYPE(attr) == UE_ISO_ASYNC);
2109 }
2110
2111 static void
2112 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error)
2113 {
2114         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2115         struct uaudio_chan *ch_rec;
2116         struct usb_page_cache *pc;
2117         uint32_t mfl;
2118         uint32_t total;
2119         uint32_t blockcount;
2120         uint32_t n;
2121         uint32_t offset;
2122         int sample_size;
2123         int actlen;
2124         int sumlen;
2125
2126         if (ch->running == 0 || ch->start == ch->end) {
2127                 DPRINTF("not running or no buffer!\n");
2128                 return;
2129         }
2130
2131         /* check if there is a record channel */
2132         if (ch->priv_sc->sc_rec_chan.num_alt > 0)
2133                 ch_rec = &ch->priv_sc->sc_rec_chan;
2134         else
2135                 ch_rec = NULL;
2136
2137         usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
2138
2139         switch (USB_GET_STATE(xfer)) {
2140         case USB_ST_SETUP:
2141 tr_setup:
2142                 if (ch_rec != NULL) {
2143                         /* reset receive jitter counters */
2144                         mtx_lock(ch_rec->pcm_mtx);
2145                         ch_rec->jitter_curr = 0;
2146                         ch_rec->jitter_rem = 0;
2147                         mtx_unlock(ch_rec->pcm_mtx);
2148                 }
2149
2150                 /* reset transmit jitter counters */
2151                 ch->jitter_curr = 0;
2152                 ch->jitter_rem = 0;
2153
2154                 /* FALLTHROUGH */
2155         case USB_ST_TRANSFERRED:
2156                 if (actlen < sumlen) {
2157                         DPRINTF("short transfer, "
2158                             "%d of %d bytes\n", actlen, sumlen);
2159                 }
2160                 chn_intr(ch->pcm_ch);
2161
2162                 /*
2163                  * Check for asynchronous playback endpoint and that
2164                  * the playback endpoint is properly configured:
2165                  */
2166                 if (ch_rec != NULL &&
2167                     uaudio_chan_is_async(ch, ch->cur_alt) != 0) {
2168                         mtx_lock(ch_rec->pcm_mtx);
2169                         if (ch_rec->cur_alt < ch_rec->num_alt) {
2170                                 int64_t tx_jitter;
2171                                 int64_t rx_rate;
2172
2173                                 /* translate receive jitter into transmit jitter */
2174                                 tx_jitter = ch->usb_alt[ch->cur_alt].sample_rate;
2175                                 tx_jitter = (tx_jitter * ch_rec->jitter_curr) +
2176                                     ch->jitter_rem;
2177
2178                                 /* reset receive jitter counters */
2179                                 ch_rec->jitter_curr = 0;
2180                                 ch_rec->jitter_rem = 0;
2181
2182                                 /* compute exact number of transmit jitter samples */
2183                                 rx_rate = ch_rec->usb_alt[ch_rec->cur_alt].sample_rate;
2184                                 ch->jitter_curr += tx_jitter / rx_rate;
2185                                 ch->jitter_rem = tx_jitter % rx_rate;
2186                         }
2187                         mtx_unlock(ch_rec->pcm_mtx);
2188                 }
2189
2190                 /* start the SYNC transfer one time per second, if any */
2191                 ch->intr_counter += ch->intr_frames;
2192                 if (ch->intr_counter >= ch->frames_per_second) {
2193                         ch->intr_counter -= ch->frames_per_second;
2194                         usbd_transfer_start(ch->xfer[UAUDIO_NCHANBUFS]);
2195                 }
2196
2197                 mfl = usbd_xfer_max_framelen(xfer);
2198
2199                 if (ch->bytes_per_frame[1] > mfl) {
2200                         DPRINTF("bytes per transfer, %d, "
2201                             "exceeds maximum, %d!\n",
2202                             ch->bytes_per_frame[1],
2203                             mfl);
2204                         break;
2205                 }
2206
2207                 blockcount = ch->intr_frames;
2208
2209                 /* setup number of frames */
2210                 usbd_xfer_set_frames(xfer, blockcount);
2211
2212                 /* get sample size */
2213                 sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2214
2215                 /* reset total length */
2216                 total = 0;
2217
2218                 /* setup frame lengths */
2219                 for (n = 0; n != blockcount; n++) {
2220                         uint32_t frame_len;
2221
2222                         ch->sample_curr += ch->sample_rem;
2223                         if (ch->sample_curr >= ch->frames_per_second) {
2224                                 ch->sample_curr -= ch->frames_per_second;
2225                                 frame_len = ch->bytes_per_frame[1];
2226                         } else {
2227                                 frame_len = ch->bytes_per_frame[0];
2228                         }
2229
2230                         /* handle free running clock case */
2231                         if (ch->jitter_curr > 0 &&
2232                             (frame_len + sample_size) <= mfl) {
2233                                 DPRINTFN(6, "sending one sample more\n");
2234                                 ch->jitter_curr--;
2235                                 frame_len += sample_size;
2236                         } else if (ch->jitter_curr < 0 &&
2237                             frame_len >= sample_size) {
2238                                 DPRINTFN(6, "sending one sample less\n");
2239                                 ch->jitter_curr++;
2240                                 frame_len -= sample_size;
2241                         }
2242                         usbd_xfer_set_frame_len(xfer, n, frame_len);
2243                         total += frame_len;
2244                 }
2245
2246                 DPRINTFN(6, "transferring %d bytes\n", total);
2247
2248                 offset = 0;
2249
2250                 pc = usbd_xfer_get_frame(xfer, 0);
2251                 while (total > 0) {
2252
2253                         n = (ch->end - ch->cur);
2254                         if (n > total)
2255                                 n = total;
2256
2257                         usbd_copy_in(pc, offset, ch->cur, n);
2258
2259                         total -= n;
2260                         ch->cur += n;
2261                         offset += n;
2262
2263                         if (ch->cur >= ch->end)
2264                                 ch->cur = ch->start;
2265                 }
2266                 usbd_transfer_submit(xfer);
2267                 break;
2268
2269         default:                        /* Error */
2270                 if (error != USB_ERR_CANCELLED)
2271                         goto tr_setup;
2272                 break;
2273         }
2274 }
2275
2276 static void
2277 uaudio_chan_record_sync_callback(struct usb_xfer *xfer, usb_error_t error)
2278 {
2279         /* TODO */
2280 }
2281
2282 static void
2283 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error)
2284 {
2285         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2286         struct usb_page_cache *pc;
2287         uint32_t offset0;
2288         uint32_t mfl;
2289         int m;
2290         int n;
2291         int len;
2292         int actlen;
2293         int nframes;
2294         int expected_bytes;
2295         int sample_size;
2296
2297         if (ch->start == ch->end) {
2298                 DPRINTF("no buffer!\n");
2299                 return;
2300         }
2301
2302         usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
2303         mfl = usbd_xfer_max_framelen(xfer);
2304
2305         switch (USB_GET_STATE(xfer)) {
2306         case USB_ST_TRANSFERRED:
2307
2308                 offset0 = 0;
2309                 pc = usbd_xfer_get_frame(xfer, 0);
2310
2311                 /* try to compute the number of expected bytes */
2312                 ch->sample_curr += (ch->sample_rem * ch->intr_frames);
2313
2314                 /* compute number of expected bytes */
2315                 expected_bytes = (ch->intr_frames * ch->bytes_per_frame[0]) +
2316                     ((ch->sample_curr / ch->frames_per_second) *
2317                     (ch->bytes_per_frame[1] - ch->bytes_per_frame[0]));
2318
2319                 /* keep remainder */
2320                 ch->sample_curr %= ch->frames_per_second;
2321
2322                 /* get current sample size */
2323                 sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2324
2325                 for (n = 0; n != nframes; n++) {
2326                         uint32_t offset1 = offset0;
2327
2328                         len = usbd_xfer_frame_len(xfer, n);
2329
2330                         /* make sure we only receive complete samples */
2331                         len = len - (len % sample_size);
2332
2333                         /* subtract bytes received from expected payload */
2334                         expected_bytes -= len;
2335
2336                         /* don't receive data when not ready */
2337                         if (ch->running == 0 || ch->cur_alt != ch->set_alt)
2338                                 continue;
2339
2340                         /* fill ring buffer with samples, if any */
2341                         while (len > 0) {
2342
2343                                 m = (ch->end - ch->cur);
2344
2345                                 if (m > len)
2346                                         m = len;
2347
2348                                 usbd_copy_out(pc, offset1, ch->cur, m);
2349
2350                                 len -= m;
2351                                 offset1 += m;
2352                                 ch->cur += m;
2353
2354                                 if (ch->cur >= ch->end)
2355                                         ch->cur = ch->start;
2356                         }
2357
2358                         offset0 += mfl;
2359                 }
2360
2361                 /* update current jitter */
2362                 ch->jitter_curr -= (expected_bytes / sample_size);
2363
2364                 /* don't allow a huge amount of jitter to accumulate */
2365                 nframes = 2 * ch->intr_frames;
2366
2367                 /* range check current jitter */
2368                 if (ch->jitter_curr < -nframes)
2369                         ch->jitter_curr = -nframes;
2370                 else if (ch->jitter_curr > nframes)
2371                         ch->jitter_curr = nframes;
2372
2373                 DPRINTFN(6, "transferred %d bytes, jitter %d samples\n",
2374                     actlen, ch->jitter_curr);
2375
2376                 if (ch->running != 0)
2377                         chn_intr(ch->pcm_ch);
2378
2379         case USB_ST_SETUP:
2380 tr_setup:
2381                 nframes = ch->intr_frames;
2382
2383                 usbd_xfer_set_frames(xfer, nframes);
2384                 for (n = 0; n != nframes; n++)
2385                         usbd_xfer_set_frame_len(xfer, n, mfl);
2386
2387                 usbd_transfer_submit(xfer);
2388                 break;
2389
2390         default:                        /* Error */
2391                 if (error != USB_ERR_CANCELLED)
2392                         goto tr_setup;
2393                 break;
2394         }
2395 }
2396
2397 void   *
2398 uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b,
2399     struct pcm_channel *c, int dir)
2400 {
2401         struct uaudio_chan *ch = ((dir == PCMDIR_PLAY) ?
2402             &sc->sc_play_chan : &sc->sc_rec_chan);
2403         uint32_t buf_size;
2404         uint8_t x;
2405
2406         /* store mutex and PCM channel */
2407
2408         ch->pcm_ch = c;
2409         ch->pcm_mtx = c->lock;
2410
2411         /* compute worst case buffer */
2412
2413         buf_size = 0;
2414         for (x = 0; x != ch->num_alt; x++) {
2415                 uint32_t temp = uaudio_get_buffer_size(ch, x);
2416                 if (temp > buf_size)
2417                         buf_size = temp;
2418         }
2419
2420         /* allow double buffering */
2421         buf_size *= 2;
2422
2423         DPRINTF("Worst case buffer is %d bytes\n", (int)buf_size);
2424
2425         ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO);
2426         if (ch->buf == NULL)
2427                 goto error;
2428         if (sndbuf_setup(b, ch->buf, buf_size) != 0)
2429                 goto error;
2430
2431         ch->start = ch->buf;
2432         ch->end = ch->buf + buf_size;
2433         ch->cur = ch->buf;
2434         ch->pcm_buf = b;
2435         ch->max_buf = buf_size;
2436
2437         if (ch->pcm_mtx == NULL) {
2438                 DPRINTF("ERROR: PCM channels does not have a mutex!\n");
2439                 goto error;
2440         }
2441         return (ch);
2442
2443 error:
2444         uaudio_chan_free(ch);
2445         return (NULL);
2446 }
2447
2448 int
2449 uaudio_chan_free(struct uaudio_chan *ch)
2450 {
2451         if (ch->buf != NULL) {
2452                 free(ch->buf, M_DEVBUF);
2453                 ch->buf = NULL;
2454         }
2455         usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS + 1);
2456
2457         ch->num_alt = 0;
2458
2459         return (0);
2460 }
2461
2462 int
2463 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize)
2464 {
2465         uint32_t temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2466         sndbuf_setup(ch->pcm_buf, ch->buf, temp);
2467         return (temp / 2);
2468 }
2469
2470 int
2471 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize,
2472     uint32_t blockcount)
2473 {
2474         return (1);
2475 }
2476
2477 int
2478 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed)
2479 {
2480         struct uaudio_softc *sc;
2481         uint8_t x;
2482
2483         sc = ch->priv_sc;
2484
2485         for (x = 0; x < ch->num_alt; x++) {
2486                 if (ch->usb_alt[x].sample_rate < speed) {
2487                         /* sample rate is too low */
2488                         break;
2489                 }
2490         }
2491
2492         if (x != 0)
2493                 x--;
2494
2495         usb_proc_explore_lock(sc->sc_udev);
2496         ch->set_alt = x;
2497         usb_proc_explore_unlock(sc->sc_udev);
2498
2499         DPRINTF("Selecting alt %d\n", (int)x);
2500
2501         return (ch->usb_alt[x].sample_rate);
2502 }
2503
2504 int
2505 uaudio_chan_getptr(struct uaudio_chan *ch)
2506 {
2507         return (ch->cur - ch->start);
2508 }
2509
2510 struct pcmchan_caps *
2511 uaudio_chan_getcaps(struct uaudio_chan *ch)
2512 {
2513         return (&ch->pcm_cap);
2514 }
2515
2516 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = {
2517         .id = SND_CHN_MATRIX_DRV,
2518         .channels = 2,
2519         .ext = 0,
2520         .map = {
2521                 /* Right */
2522                 [0] = {
2523                         .type = SND_CHN_T_FR,
2524                         .members =
2525                             SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC |
2526                             SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR |
2527                             SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR
2528                 },
2529                 /* Left */
2530                 [1] = {
2531                         .type = SND_CHN_T_FL,
2532                         .members =
2533                             SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC |
2534                             SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL |
2535                             SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL
2536                 },
2537                 [2] = {
2538                         .type = SND_CHN_T_MAX,
2539                         .members = 0
2540                 }
2541         },
2542         .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL,
2543         .offset = {  1,  0, -1, -1, -1, -1, -1, -1, -1,
2544                     -1, -1, -1, -1, -1, -1, -1, -1, -1  }
2545 };
2546
2547 struct pcmchan_matrix *
2548 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format)
2549 {
2550         struct uaudio_softc *sc;
2551
2552         sc = ch->priv_sc;
2553
2554         if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 &&
2555             AFMT_CHANNEL(format) == 2)
2556                 return (&uaudio_chan_matrix_swap_2_0);
2557
2558         return (feeder_matrix_format_map(format));
2559 }
2560
2561 int
2562 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format)
2563 {
2564         DPRINTF("Selecting format 0x%08x\n", (unsigned int)format);
2565         return (0);
2566 }
2567
2568 static void
2569 uaudio_chan_start_sub(struct uaudio_chan *ch)
2570 {
2571         struct uaudio_softc *sc = ch->priv_sc;
2572         int do_start = 0;
2573
2574         if (ch->operation != CHAN_OP_DRAIN) {
2575                 if (ch->cur_alt == ch->set_alt &&
2576                     ch->operation == CHAN_OP_NONE &&
2577                     mtx_owned(ch->pcm_mtx) != 0) {
2578                         /* save doing the explore task */
2579                         do_start = 1;
2580                 } else {
2581                         ch->operation = CHAN_OP_START;
2582                         (void)usb_proc_explore_msignal(sc->sc_udev,
2583                             &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2584                 }
2585         }
2586         if (do_start) {
2587                 usbd_transfer_start(ch->xfer[0]);
2588                 usbd_transfer_start(ch->xfer[1]);
2589         }
2590 }
2591
2592 static int
2593 uaudio_chan_need_both(struct uaudio_softc *sc)
2594 {
2595         return (sc->sc_play_chan.num_alt > 0 &&
2596             sc->sc_play_chan.running != 0 &&
2597             uaudio_chan_is_async(&sc->sc_play_chan,
2598             sc->sc_play_chan.set_alt) != 0 &&
2599             sc->sc_rec_chan.num_alt > 0 &&
2600             sc->sc_rec_chan.running == 0);
2601 }
2602
2603 static int
2604 uaudio_chan_need_none(struct uaudio_softc *sc)
2605 {
2606         return (sc->sc_play_chan.num_alt > 0 &&
2607             sc->sc_play_chan.running == 0 &&
2608             sc->sc_rec_chan.num_alt > 0 &&
2609             sc->sc_rec_chan.running == 0);
2610 }
2611
2612 void
2613 uaudio_chan_start(struct uaudio_chan *ch)
2614 {
2615         struct uaudio_softc *sc = ch->priv_sc;
2616
2617         /* make operation atomic */
2618         usb_proc_explore_lock(sc->sc_udev);
2619
2620         /* check if not running */
2621         if (ch->running == 0) {
2622                 uint32_t temp;
2623
2624                 /* get current buffer size */
2625                 temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2626
2627                 /* set running flag */
2628                 ch->running = 1;
2629
2630                 /* ensure the hardware buffer is reset */
2631                 ch->start = ch->buf;
2632                 ch->end = ch->buf + temp;
2633                 ch->cur = ch->buf;
2634
2635                 if (uaudio_chan_need_both(sc)) {
2636                         /*
2637                          * Start both endpoints because of need for
2638                          * jitter information:
2639                          */
2640                         uaudio_chan_start_sub(&sc->sc_rec_chan);
2641                         uaudio_chan_start_sub(&sc->sc_play_chan);
2642                 } else {
2643                         uaudio_chan_start_sub(ch);
2644                 }
2645         }
2646
2647         /* exit atomic operation */
2648         usb_proc_explore_unlock(sc->sc_udev);
2649 }
2650
2651 static void
2652 uaudio_chan_stop_sub(struct uaudio_chan *ch)
2653 {
2654         struct uaudio_softc *sc = ch->priv_sc;
2655         int do_stop = 0;
2656
2657         if (ch->operation != CHAN_OP_DRAIN) {
2658                 if (ch->cur_alt == ch->set_alt &&
2659                     ch->operation == CHAN_OP_NONE &&
2660                     mtx_owned(ch->pcm_mtx) != 0) {
2661                         /* save doing the explore task */
2662                         do_stop = 1;
2663                 } else {
2664                         ch->operation = CHAN_OP_STOP;
2665                         (void)usb_proc_explore_msignal(sc->sc_udev,
2666                             &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2667                 }
2668         }
2669         if (do_stop) {
2670                 usbd_transfer_stop(ch->xfer[0]);
2671                 usbd_transfer_stop(ch->xfer[1]);
2672         }
2673 }
2674
2675 void
2676 uaudio_chan_stop(struct uaudio_chan *ch)
2677 {
2678         struct uaudio_softc *sc = ch->priv_sc;
2679
2680         /* make operation atomic */
2681         usb_proc_explore_lock(sc->sc_udev);
2682
2683         /* check if running */
2684         if (ch->running != 0) {
2685                 /* clear running flag */
2686                 ch->running = 0;
2687
2688                 if (uaudio_chan_need_both(sc)) {
2689                         /*
2690                          * Leave the endpoints running because we need
2691                          * information about jitter!
2692                          */
2693                 } else if (uaudio_chan_need_none(sc)) {
2694                         /*
2695                          * Stop both endpoints in case the one was used for
2696                          * jitter information:
2697                          */
2698                         uaudio_chan_stop_sub(&sc->sc_rec_chan);
2699                         uaudio_chan_stop_sub(&sc->sc_play_chan);
2700                 } else {
2701                         uaudio_chan_stop_sub(ch);
2702                 }
2703         }
2704
2705         /* exit atomic operation */
2706         usb_proc_explore_unlock(sc->sc_udev);
2707 }
2708
2709 /*========================================================================*
2710  * AC - Audio Controller - routines
2711  *========================================================================*/
2712
2713 static int
2714 uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS)
2715 {
2716         struct uaudio_softc *sc;
2717         struct uaudio_mixer_node *pmc;
2718         int hint;
2719         int error;
2720         int temp = 0;
2721         int chan = 0;
2722
2723         sc = (struct uaudio_softc *)oidp->oid_arg1;
2724         hint = oidp->oid_arg2;
2725
2726         if (sc->sc_mixer_lock == NULL)
2727                 return (ENXIO);
2728
2729         /* lookup mixer node */
2730
2731         mtx_lock(sc->sc_mixer_lock);
2732         for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
2733                 for (chan = 0; chan != (int)pmc->nchan; chan++) {
2734                         if (pmc->wValue[chan] != -1 &&
2735                             pmc->wValue[chan] == hint) {
2736                                 temp = pmc->wData[chan];
2737                                 goto found;
2738                         }
2739                 }
2740         }
2741 found:
2742         mtx_unlock(sc->sc_mixer_lock);
2743
2744         error = sysctl_handle_int(oidp, &temp, 0, req);
2745         if (error != 0 || req->newptr == NULL)
2746                 return (error);
2747
2748         /* update mixer value */
2749
2750         mtx_lock(sc->sc_mixer_lock);
2751         if (pmc != NULL &&
2752             temp >= pmc->minval &&
2753             temp <= pmc->maxval) {
2754
2755                 pmc->wData[chan] = temp;
2756                 pmc->update[(chan / 8)] |= (1 << (chan % 8));
2757
2758                 /* start the transfer, if not already started */
2759                 usbd_transfer_start(sc->sc_mixer_xfer[0]);
2760         }
2761         mtx_unlock(sc->sc_mixer_lock);
2762
2763         return (0);
2764 }
2765
2766 static void
2767 uaudio_mixer_ctl_free(struct uaudio_softc *sc)
2768 {
2769         struct uaudio_mixer_node *p_mc;
2770
2771         while ((p_mc = sc->sc_mixer_root) != NULL) {
2772                 sc->sc_mixer_root = p_mc->next;
2773                 free(p_mc, M_USBDEV);
2774         }
2775 }
2776
2777 static void
2778 uaudio_mixer_register_sysctl(struct uaudio_softc *sc, device_t dev)
2779 {
2780         struct uaudio_mixer_node *pmc;
2781         struct sysctl_oid *mixer_tree;
2782         struct sysctl_oid *control_tree;
2783         char buf[32];
2784         int chan;
2785         int n;
2786
2787         mixer_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
2788             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "mixer",
2789             CTLFLAG_RD, NULL, "");
2790
2791         if (mixer_tree == NULL)
2792                 return;
2793
2794         for (n = 0, pmc = sc->sc_mixer_root; pmc != NULL;
2795             pmc = pmc->next, n++) {
2796
2797                 for (chan = 0; chan < pmc->nchan; chan++) {
2798
2799                         if (pmc->nchan > 1) {
2800                                 snprintf(buf, sizeof(buf), "%s_%d_%d",
2801                                     pmc->name, n, chan);
2802                         } else {
2803                                 snprintf(buf, sizeof(buf), "%s_%d",
2804                                     pmc->name, n);
2805                         }
2806
2807                         control_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
2808                             SYSCTL_CHILDREN(mixer_tree), OID_AUTO, buf,
2809                             CTLFLAG_RD, NULL, "Mixer control nodes");
2810
2811                         if (control_tree == NULL)
2812                                 continue;
2813
2814                         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
2815                             SYSCTL_CHILDREN(control_tree),
2816                             OID_AUTO, "val", CTLTYPE_INT | CTLFLAG_RW, sc,
2817                             pmc->wValue[chan],
2818                             uaudio_mixer_sysctl_handler, "I", "Current value");
2819
2820                         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
2821                             SYSCTL_CHILDREN(control_tree),
2822                             OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval,
2823                             "Minimum value");
2824
2825                         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
2826                             SYSCTL_CHILDREN(control_tree),
2827                             OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval,
2828                             "Maximum value");
2829
2830                         SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
2831                             SYSCTL_CHILDREN(control_tree),
2832                             OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0,
2833                             "Description");
2834                 }
2835         }
2836 }
2837
2838 /* M-Audio FastTrack Ultra Mixer Description */
2839 /* Origin: Linux USB Audio driver */
2840 static void
2841 uaudio_mixer_controls_create_ftu(struct uaudio_softc *sc)
2842 {
2843         int chx;
2844         int chy;
2845
2846         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2847         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2848         MIX(sc).wValue[0] = MAKE_WORD(8, 0);
2849         MIX(sc).class = UAC_OUTPUT;
2850         MIX(sc).type = MIX_UNSIGNED_16;
2851         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2852         MIX(sc).name = "effect";
2853         MIX(sc).minval = 0;
2854         MIX(sc).maxval = 7;
2855         MIX(sc).mul = 7;
2856         MIX(sc).nchan = 1;
2857         MIX(sc).update[0] = 1;
2858         strlcpy(MIX(sc).desc, "Room1,2,3,Hall1,2,Plate,Delay,Echo", sizeof(MIX(sc).desc));
2859         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2860
2861         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2862         MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
2863
2864         for (chx = 0; chx != 8; chx++) {
2865                 for (chy = 0; chy != 8; chy++) {
2866
2867                         MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1);
2868                         MIX(sc).type = MIX_SIGNED_16;
2869                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2870                         MIX(sc).name = "mix_rec";
2871                         MIX(sc).nchan = 1;
2872                         MIX(sc).update[0] = 1;
2873                         MIX(sc).val_default = 0;
2874                         snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2875                             "AIn%d - Out%d Record Volume", chy + 1, chx + 1);
2876
2877                         uaudio_mixer_add_ctl(sc, &MIX(sc));
2878
2879                         MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1 + 8);
2880                         MIX(sc).type = MIX_SIGNED_16;
2881                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2882                         MIX(sc).name = "mix_play";
2883                         MIX(sc).nchan = 1;
2884                         MIX(sc).update[0] = 1;
2885                         MIX(sc).val_default = (chx == chy) ? 2 : 0;
2886                         snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2887                             "DIn%d - Out%d Playback Volume", chy + 1, chx + 1);
2888
2889                         uaudio_mixer_add_ctl(sc, &MIX(sc));
2890                 }
2891         }
2892
2893         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2894         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2895         MIX(sc).wValue[0] = MAKE_WORD(2, 0);
2896         MIX(sc).class = UAC_OUTPUT;
2897         MIX(sc).type = MIX_SIGNED_8;
2898         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2899         MIX(sc).name = "effect_vol";
2900         MIX(sc).nchan = 1;
2901         MIX(sc).update[0] = 1;
2902         MIX(sc).minval = 0;
2903         MIX(sc).maxval = 0x7f;
2904         MIX(sc).mul = 0x7f;
2905         MIX(sc).nchan = 1;
2906         MIX(sc).update[0] = 1;
2907         strlcpy(MIX(sc).desc, "Effect Volume", sizeof(MIX(sc).desc));
2908         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2909
2910         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2911         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2912         MIX(sc).wValue[0] = MAKE_WORD(3, 0);
2913         MIX(sc).class = UAC_OUTPUT;
2914         MIX(sc).type = MIX_SIGNED_16;
2915         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2916         MIX(sc).name = "effect_dur";
2917         MIX(sc).nchan = 1;
2918         MIX(sc).update[0] = 1;
2919         MIX(sc).minval = 0;
2920         MIX(sc).maxval = 0x7f00;
2921         MIX(sc).mul = 0x7f00;
2922         MIX(sc).nchan = 1;
2923         MIX(sc).update[0] = 1;
2924         strlcpy(MIX(sc).desc, "Effect Duration", sizeof(MIX(sc).desc));
2925         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2926
2927         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2928         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2929         MIX(sc).wValue[0] = MAKE_WORD(4, 0);
2930         MIX(sc).class = UAC_OUTPUT;
2931         MIX(sc).type = MIX_SIGNED_8;
2932         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2933         MIX(sc).name = "effect_fb";
2934         MIX(sc).nchan = 1;
2935         MIX(sc).update[0] = 1;
2936         MIX(sc).minval = 0;
2937         MIX(sc).maxval = 0x7f;
2938         MIX(sc).mul = 0x7f;
2939         MIX(sc).nchan = 1;
2940         MIX(sc).update[0] = 1;
2941         strlcpy(MIX(sc).desc, "Effect Feedback Volume", sizeof(MIX(sc).desc));
2942         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2943
2944         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2945         MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no);
2946         for (chy = 0; chy != 4; chy++) {
2947
2948                 MIX(sc).wValue[0] = MAKE_WORD(7, chy + 1);
2949                 MIX(sc).type = MIX_SIGNED_16;
2950                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2951                 MIX(sc).name = "effect_ret";
2952                 MIX(sc).nchan = 1;
2953                 MIX(sc).update[0] = 1;
2954                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2955                     "Effect Return %d Volume", chy + 1);
2956
2957                 uaudio_mixer_add_ctl(sc, &MIX(sc));
2958         }
2959
2960         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2961         MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
2962
2963         for (chy = 0; chy != 8; chy++) {
2964                 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1);
2965                 MIX(sc).type = MIX_SIGNED_16;
2966                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2967                 MIX(sc).name = "effect_send";
2968                 MIX(sc).nchan = 1;
2969                 MIX(sc).update[0] = 1;
2970                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2971                     "Effect Send AIn%d Volume", chy + 1);
2972
2973                 uaudio_mixer_add_ctl(sc, &MIX(sc));
2974
2975                 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1 + 8);
2976                 MIX(sc).type = MIX_SIGNED_16;
2977                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2978                 MIX(sc).name = "effect_send";
2979                 MIX(sc).nchan = 1;
2980                 MIX(sc).update[0] = 1;
2981                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2982                     "Effect Send DIn%d Volume", chy + 1);
2983
2984                 uaudio_mixer_add_ctl(sc, &MIX(sc));
2985         }
2986 }
2987
2988 static void
2989 uaudio_mixer_reload_all(struct uaudio_softc *sc)
2990 {
2991         struct uaudio_mixer_node *pmc;
2992         int chan;
2993
2994         if (sc->sc_mixer_lock == NULL)
2995                 return;
2996
2997         mtx_lock(sc->sc_mixer_lock);
2998         for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
2999                 /* use reset defaults for non-oss controlled settings */
3000                 if (pmc->ctl == SOUND_MIXER_NRDEVICES)
3001                         continue;
3002                 for (chan = 0; chan < pmc->nchan; chan++)
3003                         pmc->update[chan / 8] |= (1 << (chan % 8));
3004         }
3005         usbd_transfer_start(sc->sc_mixer_xfer[0]);
3006
3007         /* start HID volume keys, if any */
3008         usbd_transfer_start(sc->sc_hid.xfer[0]);
3009         mtx_unlock(sc->sc_mixer_lock);
3010 }
3011
3012 static void
3013 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3014 {
3015         struct uaudio_mixer_node *p_mc_new =
3016             malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK);
3017         int ch;
3018
3019         if (p_mc_new != NULL) {
3020                 memcpy(p_mc_new, mc, sizeof(*p_mc_new));
3021                 p_mc_new->next = sc->sc_mixer_root;
3022                 sc->sc_mixer_root = p_mc_new;
3023                 sc->sc_mixer_count++;
3024
3025                 /* set default value for all channels */
3026                 for (ch = 0; ch < p_mc_new->nchan; ch++) {
3027                         switch (p_mc_new->val_default) {
3028                         case 1:
3029                                 /* 50% */
3030                                 p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2;
3031                                 break;
3032                         case 2:
3033                                 /* 100% */
3034                                 p_mc_new->wData[ch] = p_mc_new->maxval;
3035                                 break;
3036                         default:
3037                                 /* 0% */
3038                                 p_mc_new->wData[ch] = p_mc_new->minval;
3039                                 break;
3040                         }
3041                 }
3042         } else {
3043                 DPRINTF("out of memory\n");
3044         }
3045 }
3046
3047 static void
3048 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3049 {
3050         int32_t res;
3051
3052         if (mc->class < UAC_NCLASSES) {
3053                 DPRINTF("adding %s.%d\n",
3054                     uac_names[mc->class], mc->ctl);
3055         } else {
3056                 DPRINTF("adding %d\n", mc->ctl);
3057         }
3058
3059         if (mc->type == MIX_ON_OFF) {
3060                 mc->minval = 0;
3061                 mc->maxval = 1;
3062         } else if (mc->type == MIX_SELECTOR) {
3063         } else {
3064
3065                 /* determine min and max values */
3066
3067                 mc->minval = uaudio_mixer_get(sc->sc_udev,
3068                     sc->sc_audio_rev, GET_MIN, mc);
3069                 mc->maxval = uaudio_mixer_get(sc->sc_udev,
3070                     sc->sc_audio_rev, GET_MAX, mc);
3071
3072                 /* check if max and min was swapped */
3073
3074                 if (mc->maxval < mc->minval) {
3075                         res = mc->maxval;
3076                         mc->maxval = mc->minval;
3077                         mc->minval = res;
3078                 }
3079
3080                 /* compute value range */
3081                 mc->mul = mc->maxval - mc->minval;
3082                 if (mc->mul == 0)
3083                         mc->mul = 1;
3084
3085                 /* compute value alignment */
3086                 res = uaudio_mixer_get(sc->sc_udev,
3087                     sc->sc_audio_rev, GET_RES, mc);
3088
3089                 DPRINTF("Resolution = %d\n", (int)res);
3090         }
3091
3092         uaudio_mixer_add_ctl_sub(sc, mc);
3093
3094 #ifdef USB_DEBUG
3095         if (uaudio_debug > 2) {
3096                 uint8_t i;
3097
3098                 for (i = 0; i < mc->nchan; i++) {
3099                         DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]);
3100                 }
3101                 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' "
3102                     "min=%d max=%d\n",
3103                     mc->wIndex, mc->type, mc->ctl,
3104                     mc->minval, mc->maxval);
3105         }
3106 #endif
3107 }
3108
3109 static void
3110 uaudio_mixer_add_mixer(struct uaudio_softc *sc,
3111     const struct uaudio_terminal_node *iot, int id)
3112 {
3113         const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu_v1;
3114         const struct usb_audio_mixer_unit_1 *d1;
3115
3116         uint32_t bno;                   /* bit number */
3117         uint32_t p;                     /* bit number accumulator */
3118         uint32_t mo;                    /* matching outputs */
3119         uint32_t mc;                    /* matching channels */
3120         uint32_t ichs;                  /* input channels */
3121         uint32_t ochs;                  /* output channels */
3122         uint32_t c;
3123         uint32_t chs;                   /* channels */
3124         uint32_t i;
3125         uint32_t o;
3126
3127         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3128             d0->bUnitId, d0->bNrInPins);
3129
3130         /* compute the number of input channels */
3131
3132         ichs = 0;
3133         for (i = 0; i < d0->bNrInPins; i++) {
3134                 ichs += uaudio_mixer_get_cluster(
3135                     d0->baSourceId[i], iot).bNrChannels;
3136         }
3137
3138         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3139
3140         /* and the number of output channels */
3141
3142         ochs = d1->bNrChannels;
3143
3144         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3145
3146         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3147
3148         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3149         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3150         MIX(sc).type = MIX_SIGNED_16;
3151
3152         if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3153                 return;
3154
3155         for (p = i = 0; i < d0->bNrInPins; i++) {
3156                 chs = uaudio_mixer_get_cluster(
3157                     d0->baSourceId[i], iot).bNrChannels;
3158                 mc = 0;
3159                 for (c = 0; c < chs; c++) {
3160                         mo = 0;
3161                         for (o = 0; o < ochs; o++) {
3162                                 bno = ((p + c) * ochs) + o;
3163                                 if (BIT_TEST(d1->bmControls, bno))
3164                                         mo++;
3165                         }
3166                         if (mo == 1)
3167                                 mc++;
3168                 }
3169                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3170
3171                         /* repeat bit-scan */
3172
3173                         mc = 0;
3174                         for (c = 0; c < chs; c++) {
3175                                 for (o = 0; o < ochs; o++) {
3176                                         bno = ((p + c) * ochs) + o;
3177                                         if (BIT_TEST(d1->bmControls, bno))
3178                                                 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3179                                 }
3180                         }
3181                         MIX(sc).nchan = chs;
3182                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3183                 }
3184                 p += chs;
3185         }
3186 }
3187
3188 static void
3189 uaudio20_mixer_add_mixer(struct uaudio_softc *sc,
3190     const struct uaudio_terminal_node *iot, int id)
3191 {
3192         const struct usb_audio20_mixer_unit_0 *d0 = iot[id].u.mu_v2;
3193         const struct usb_audio20_mixer_unit_1 *d1;
3194
3195         uint32_t bno;                   /* bit number */
3196         uint32_t p;                     /* bit number accumulator */
3197         uint32_t mo;                    /* matching outputs */
3198         uint32_t mc;                    /* matching channels */
3199         uint32_t ichs;                  /* input channels */
3200         uint32_t ochs;                  /* output channels */
3201         uint32_t c;
3202         uint32_t chs;                   /* channels */
3203         uint32_t i;
3204         uint32_t o;
3205
3206         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3207             d0->bUnitId, d0->bNrInPins);
3208
3209         /* compute the number of input channels */
3210
3211         ichs = 0;
3212         for (i = 0; i < d0->bNrInPins; i++) {
3213                 ichs += uaudio20_mixer_get_cluster(
3214                     d0->baSourceId[i], iot).bNrChannels;
3215         }
3216
3217         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3218
3219         /* and the number of output channels */
3220
3221         ochs = d1->bNrChannels;
3222
3223         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3224
3225         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3226
3227         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3228         uaudio20_mixer_determine_class(&iot[id], &MIX(sc));
3229         MIX(sc).type = MIX_SIGNED_16;
3230
3231         if (uaudio20_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3232                 return;
3233
3234         for (p = i = 0; i < d0->bNrInPins; i++) {
3235                 chs = uaudio20_mixer_get_cluster(
3236                     d0->baSourceId[i], iot).bNrChannels;
3237                 mc = 0;
3238                 for (c = 0; c < chs; c++) {
3239                         mo = 0;
3240                         for (o = 0; o < ochs; o++) {
3241                                 bno = ((p + c) * ochs) + o;
3242                                 if (BIT_TEST(d1->bmControls, bno))
3243                                         mo++;
3244                         }
3245                         if (mo == 1)
3246                                 mc++;
3247                 }
3248                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3249
3250                         /* repeat bit-scan */
3251
3252                         mc = 0;
3253                         for (c = 0; c < chs; c++) {
3254                                 for (o = 0; o < ochs; o++) {
3255                                         bno = ((p + c) * ochs) + o;
3256                                         if (BIT_TEST(d1->bmControls, bno))
3257                                                 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3258                                 }
3259                         }
3260                         MIX(sc).nchan = chs;
3261                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3262                 }
3263                 p += chs;
3264         }
3265 }
3266
3267 static void
3268 uaudio_mixer_add_selector(struct uaudio_softc *sc,
3269     const struct uaudio_terminal_node *iot, int id)
3270 {
3271         const struct usb_audio_selector_unit *d = iot[id].u.su_v1;
3272         uint16_t i;
3273
3274         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3275             d->bUnitId, d->bNrInPins);
3276
3277         if (d->bNrInPins == 0)
3278                 return;
3279
3280         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3281
3282         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3283         MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3284         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3285         MIX(sc).nchan = 1;
3286         MIX(sc).type = MIX_SELECTOR;
3287         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3288         MIX(sc).minval = 1;
3289         MIX(sc).maxval = d->bNrInPins;
3290         MIX(sc).name = "selector";
3291
3292         i = d->baSourceId[d->bNrInPins];
3293         if (i == 0 ||
3294             usbd_req_get_string_any(sc->sc_udev, NULL,
3295             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3296                 MIX(sc).desc[0] = 0;
3297         }
3298
3299         if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN) {
3300                 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3301         }
3302         MIX(sc).mul = (MIX(sc).maxval - MIX(sc).minval);
3303         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) {
3304                 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3305         }
3306
3307         for (i = 0; i < MIX(sc).maxval; i++) {
3308                 MIX(sc).slctrtype[i] = uaudio_mixer_feature_name(
3309                     &iot[d->baSourceId[i]], &MIX(sc));
3310         }
3311
3312         MIX(sc).class = 0;                      /* not used */
3313
3314         uaudio_mixer_add_ctl(sc, &MIX(sc));
3315 }
3316
3317 static void
3318 uaudio20_mixer_add_selector(struct uaudio_softc *sc,
3319     const struct uaudio_terminal_node *iot, int id)
3320 {
3321         const struct usb_audio20_selector_unit *d = iot[id].u.su_v2;
3322         uint16_t i;
3323
3324         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3325             d->bUnitId, d->bNrInPins);
3326
3327         if (d->bNrInPins == 0)
3328                 return;
3329
3330         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3331
3332         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3333         MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3334         uaudio20_mixer_determine_class(&iot[id], &MIX(sc));
3335         MIX(sc).nchan = 1;
3336         MIX(sc).type = MIX_SELECTOR;
3337         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3338         MIX(sc).minval = 1;
3339         MIX(sc).maxval = d->bNrInPins;
3340         MIX(sc).name = "selector";
3341
3342         i = d->baSourceId[d->bNrInPins];
3343         if (i == 0 ||
3344             usbd_req_get_string_any(sc->sc_udev, NULL,
3345             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3346                 MIX(sc).desc[0] = 0;
3347         }
3348
3349         if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3350                 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3351
3352         MIX(sc).mul = (MIX(sc).maxval - MIX(sc).minval);
3353         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++)
3354                 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3355
3356         for (i = 0; i < MIX(sc).maxval; i++) {
3357                 MIX(sc).slctrtype[i] = uaudio20_mixer_feature_name(
3358                     &iot[d->baSourceId[i]], &MIX(sc));
3359         }
3360
3361         MIX(sc).class = 0;                      /* not used */
3362
3363         uaudio_mixer_add_ctl(sc, &MIX(sc));
3364 }
3365
3366 static uint32_t
3367 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d,
3368     uint8_t i)
3369 {
3370         uint32_t temp = 0;
3371         uint32_t offset = (i * d->bControlSize);
3372
3373         if (d->bControlSize > 0) {
3374                 temp |= d->bmaControls[offset];
3375                 if (d->bControlSize > 1) {
3376                         temp |= d->bmaControls[offset + 1] << 8;
3377                         if (d->bControlSize > 2) {
3378                                 temp |= d->bmaControls[offset + 2] << 16;
3379                                 if (d->bControlSize > 3) {
3380                                         temp |= d->bmaControls[offset + 3] << 24;
3381                                 }
3382                         }
3383                 }
3384         }
3385         return (temp);
3386 }
3387
3388 static void
3389 uaudio_mixer_add_feature(struct uaudio_softc *sc,
3390     const struct uaudio_terminal_node *iot, int id)
3391 {
3392         const struct usb_audio_feature_unit *d = iot[id].u.fu_v1;
3393         uint32_t fumask;
3394         uint32_t mmask;
3395         uint32_t cmask;
3396         uint16_t mixernumber;
3397         uint8_t nchan;
3398         uint8_t chan;
3399         uint8_t ctl;
3400         uint8_t i;
3401
3402         if (d->bControlSize == 0)
3403                 return;
3404
3405         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3406
3407         nchan = (d->bLength - 7) / d->bControlSize;
3408         mmask = uaudio_mixer_feature_get_bmaControls(d, 0);
3409         cmask = 0;
3410
3411         if (nchan == 0)
3412                 return;
3413
3414         /* figure out what we can control */
3415
3416         for (chan = 1; chan < nchan; chan++) {
3417                 DPRINTFN(10, "chan=%d mask=%x\n",
3418                     chan, uaudio_mixer_feature_get_bmaControls(d, chan));
3419
3420                 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan);
3421         }
3422
3423         if (nchan > MIX_MAX_CHAN) {
3424                 nchan = MIX_MAX_CHAN;
3425         }
3426         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3427
3428         i = d->bmaControls[d->bControlSize];
3429         if (i == 0 ||
3430             usbd_req_get_string_any(sc->sc_udev, NULL,
3431             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3432                 MIX(sc).desc[0] = 0;
3433         }
3434
3435         for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) {
3436
3437                 fumask = FU_MASK(ctl);
3438
3439                 DPRINTFN(5, "ctl=%d fumask=0x%04x\n",
3440                     ctl, fumask);
3441
3442                 if (mmask & fumask) {
3443                         MIX(sc).nchan = 1;
3444                         MIX(sc).wValue[0] = MAKE_WORD(ctl, 0);
3445                 } else if (cmask & fumask) {
3446                         MIX(sc).nchan = nchan - 1;
3447                         for (i = 1; i < nchan; i++) {
3448                                 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask)
3449                                         MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i);
3450                                 else
3451                                         MIX(sc).wValue[i - 1] = -1;
3452                         }
3453                 } else {
3454                         continue;
3455                 }
3456
3457                 mixernumber = uaudio_mixer_feature_name(&iot[id], &MIX(sc));
3458
3459                 switch (ctl) {
3460                 case MUTE_CONTROL:
3461                         MIX(sc).type = MIX_ON_OFF;
3462                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3463                         MIX(sc).name = "mute";
3464                         break;
3465
3466                 case VOLUME_CONTROL:
3467                         MIX(sc).type = MIX_SIGNED_16;
3468                         MIX(sc).ctl = mixernumber;
3469                         MIX(sc).name = "vol";
3470                         break;
3471
3472                 case BASS_CONTROL:
3473                         MIX(sc).type = MIX_SIGNED_8;
3474                         MIX(sc).ctl = SOUND_MIXER_BASS;
3475                         MIX(sc).name = "bass";
3476                         break;
3477
3478                 case MID_CONTROL:
3479                         MIX(sc).type = MIX_SIGNED_8;
3480                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3481                         MIX(sc).name = "mid";
3482                         break;
3483
3484                 case TREBLE_CONTROL:
3485                         MIX(sc).type = MIX_SIGNED_8;
3486                         MIX(sc).ctl = SOUND_MIXER_TREBLE;
3487                         MIX(sc).name = "treble";
3488                         break;
3489
3490                 case GRAPHIC_EQUALIZER_CONTROL:
3491                         continue;       /* XXX don't add anything */
3492
3493                 case AGC_CONTROL:
3494                         MIX(sc).type = MIX_ON_OFF;
3495                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3496                         MIX(sc).name = "agc";
3497                         break;
3498
3499                 case DELAY_CONTROL:
3500                         MIX(sc).type = MIX_UNSIGNED_16;
3501                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3502                         MIX(sc).name = "delay";
3503                         break;
3504
3505                 case BASS_BOOST_CONTROL:
3506                         MIX(sc).type = MIX_ON_OFF;
3507                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3508                         MIX(sc).name = "boost";
3509                         break;
3510
3511                 case LOUDNESS_CONTROL:
3512                         MIX(sc).type = MIX_ON_OFF;
3513                         MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3514                         MIX(sc).name = "loudness";
3515                         break;
3516
3517                 default:
3518                         MIX(sc).type = MIX_UNKNOWN;
3519                         break;
3520                 }
3521
3522                 if (MIX(sc).type != MIX_UNKNOWN)
3523                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3524         }
3525 }
3526
3527 static void
3528 uaudio20_mixer_add_feature(struct uaudio_softc *sc,
3529     const struct uaudio_terminal_node *iot, int id)
3530 {
3531         const struct usb_audio20_feature_unit *d = iot[id].u.fu_v2;
3532         uint32_t ctl;
3533         uint32_t mmask;
3534         uint32_t cmask;
3535         uint16_t mixernumber;
3536         uint8_t nchan;
3537         uint8_t chan;
3538         uint8_t i;
3539         uint8_t what;
3540
3541         if (UGETDW(d->bmaControls[0]) == 0)
3542                 return;
3543
3544         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3545
3546         nchan = (d->bLength - 6) / 4;
3547         mmask = UGETDW(d->bmaControls[0]);
3548         cmask = 0;
3549
3550         if (nchan == 0)
3551                 return;
3552
3553         /* figure out what we can control */
3554
3555         for (chan = 1; chan < nchan; chan++)
3556                 cmask |= UGETDW(d->bmaControls[chan]);
3557
3558         if (nchan > MIX_MAX_CHAN)
3559                 nchan = MIX_MAX_CHAN;
3560
3561         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3562
3563         i = d->bmaControls[nchan][0];
3564         if (i == 0 ||
3565             usbd_req_get_string_any(sc->sc_udev, NULL,
3566             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3567                 MIX(sc).desc[0] = 0;
3568         }
3569
3570         for (ctl = 3; ctl != 0; ctl <<= 2) {
3571
3572                 mixernumber = uaudio20_mixer_feature_name(&iot[id], &MIX(sc));
3573
3574                 switch (ctl) {
3575                 case (3 << 0):
3576                         MIX(sc).type = MIX_ON_OFF;
3577                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3578                         MIX(sc).name = "mute";
3579                         what = MUTE_CONTROL;
3580                         break;
3581                 case (3 << 2):
3582                         MIX(sc).type = MIX_SIGNED_16;
3583                         MIX(sc).ctl = mixernumber;
3584                         MIX(sc).name = "vol";
3585                         what = VOLUME_CONTROL;
3586                         break;
3587                 case (3 << 4):
3588                         MIX(sc).type = MIX_SIGNED_8;
3589                         MIX(sc).ctl = SOUND_MIXER_BASS;
3590                         MIX(sc).name = "bass";
3591                         what = BASS_CONTROL;
3592                         break;
3593                 case (3 << 6):
3594                         MIX(sc).type = MIX_SIGNED_8;
3595                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3596                         MIX(sc).name = "mid";
3597                         what = MID_CONTROL;
3598                         break;
3599                 case (3 << 8):
3600                         MIX(sc).type = MIX_SIGNED_8;
3601                         MIX(sc).ctl = SOUND_MIXER_TREBLE;
3602                         MIX(sc).name = "treble";
3603                         what = TREBLE_CONTROL;
3604                         break;
3605                 case (3 << 12):
3606                         MIX(sc).type = MIX_ON_OFF;
3607                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3608                         MIX(sc).name = "agc";
3609                         what = AGC_CONTROL;
3610                         break;
3611                 case (3 << 14):
3612                         MIX(sc).type = MIX_UNSIGNED_16;
3613                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3614                         MIX(sc).name = "delay";
3615                         what = DELAY_CONTROL;
3616                         break;
3617                 case (3 << 16):
3618                         MIX(sc).type = MIX_ON_OFF;
3619                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3620                         MIX(sc).name = "boost";
3621                         what = BASS_BOOST_CONTROL;
3622                         break;
3623                 case (3 << 18):
3624                         MIX(sc).type = MIX_ON_OFF;
3625                         MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3626                         MIX(sc).name = "loudness";
3627                         what = LOUDNESS_CONTROL;
3628                         break;
3629                 case (3 << 20):
3630                         MIX(sc).type = MIX_SIGNED_16;
3631                         MIX(sc).ctl = mixernumber;
3632                         MIX(sc).name = "igain";
3633                         what = INPUT_GAIN_CONTROL;
3634                         break;
3635                 case (3 << 22):
3636                         MIX(sc).type = MIX_SIGNED_16;
3637                         MIX(sc).ctl = mixernumber;
3638                         MIX(sc).name = "igainpad";
3639                         what = INPUT_GAIN_PAD_CONTROL;
3640                         break;
3641                 default:
3642                         continue;
3643                 }
3644
3645                 if ((mmask & ctl) == ctl) {
3646                         MIX(sc).nchan = 1;
3647                         MIX(sc).wValue[0] = MAKE_WORD(what, 0);
3648                 } else if ((cmask & ctl) == ctl) {
3649                         MIX(sc).nchan = nchan - 1;
3650                         for (i = 1; i < nchan; i++) {
3651                                 if ((UGETDW(d->bmaControls[i]) & ctl) == ctl)
3652                                         MIX(sc).wValue[i - 1] = MAKE_WORD(what, i);
3653                                 else
3654                                         MIX(sc).wValue[i - 1] = -1;
3655                         }
3656                 } else {
3657                         continue;
3658                 }
3659
3660                 if (MIX(sc).type != MIX_UNKNOWN)
3661                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3662         }
3663 }
3664
3665 static void
3666 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc,
3667     const struct uaudio_terminal_node *iot, int id)
3668 {
3669         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3670         const struct usb_audio_processing_unit_1 *d1 =
3671             (const void *)(d0->baSourceId + d0->bNrInPins);
3672         const struct usb_audio_processing_unit_updown *ud =
3673             (const void *)(d1->bmControls + d1->bControlSize);
3674         uint8_t i;
3675
3676         if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) {
3677                 return;
3678         }
3679         if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes))
3680             == NULL) {
3681                 return;
3682         }
3683         DPRINTFN(3, "bUnitId=%d bNrModes=%d\n",
3684             d0->bUnitId, ud->bNrModes);
3685
3686         if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
3687                 DPRINTF("no mode select\n");
3688                 return;
3689         }
3690         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3691
3692         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3693         MIX(sc).nchan = 1;
3694         MIX(sc).wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0);
3695         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3696         MIX(sc).type = MIX_ON_OFF;              /* XXX */
3697
3698         for (i = 0; i < ud->bNrModes; i++) {
3699                 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i]));
3700                 /* XXX */
3701         }
3702
3703         uaudio_mixer_add_ctl(sc, &MIX(sc));
3704 }
3705
3706 static void
3707 uaudio_mixer_add_processing(struct uaudio_softc *sc,
3708     const struct uaudio_terminal_node *iot, int id)
3709 {
3710         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3711         const struct usb_audio_processing_unit_1 *d1 =
3712             (const void *)(d0->baSourceId + d0->bNrInPins);
3713         uint16_t ptype;
3714
3715         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3716
3717         ptype = UGETW(d0->wProcessType);
3718
3719         DPRINTFN(3, "wProcessType=%d bUnitId=%d "
3720             "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins);
3721
3722         if (d1->bControlSize == 0) {
3723                 return;
3724         }
3725         if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
3726                 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3727                 MIX(sc).nchan = 1;
3728                 MIX(sc).wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0);
3729                 uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3730                 MIX(sc).type = MIX_ON_OFF;
3731                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3732         }
3733         switch (ptype) {
3734         case UPDOWNMIX_PROCESS:
3735                 uaudio_mixer_add_processing_updown(sc, iot, id);
3736                 break;
3737
3738         case DOLBY_PROLOGIC_PROCESS:
3739         case P3D_STEREO_EXTENDER_PROCESS:
3740         case REVERBATION_PROCESS:
3741         case CHORUS_PROCESS:
3742         case DYN_RANGE_COMP_PROCESS:
3743         default:
3744                 DPRINTF("unit %d, type=%d is not implemented\n",
3745                     d0->bUnitId, ptype);
3746                 break;
3747         }
3748 }
3749
3750 static void
3751 uaudio_mixer_add_extension(struct uaudio_softc *sc,
3752     const struct uaudio_terminal_node *iot, int id)
3753 {
3754         const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu_v1;
3755         const struct usb_audio_extension_unit_1 *d1 =
3756             (const void *)(d0->baSourceId + d0->bNrInPins);
3757
3758         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3759             d0->bUnitId, d0->bNrInPins);
3760
3761         if (sc->sc_uq_au_no_xu) {
3762                 return;
3763         }
3764         if (d1->bControlSize == 0) {
3765                 return;
3766         }
3767         if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
3768
3769                 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3770
3771                 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3772                 MIX(sc).nchan = 1;
3773                 MIX(sc).wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0);
3774                 uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3775                 MIX(sc).type = MIX_ON_OFF;
3776
3777                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3778         }
3779 }
3780
3781 static const void *
3782 uaudio_mixer_verify_desc(const void *arg, uint32_t len)
3783 {
3784         const struct usb_audio_mixer_unit_1 *d1;
3785         const struct usb_audio_extension_unit_1 *e1;
3786         const struct usb_audio_processing_unit_1 *u1;
3787
3788         union {
3789                 const struct usb_descriptor *desc;
3790                 const struct usb_audio_input_terminal *it;
3791                 const struct usb_audio_output_terminal *ot;
3792                 const struct usb_audio_mixer_unit_0 *mu;
3793                 const struct usb_audio_selector_unit *su;
3794                 const struct usb_audio_feature_unit *fu;
3795                 const struct usb_audio_processing_unit_0 *pu;
3796                 const struct usb_audio_extension_unit_0 *eu;
3797         }     u;
3798
3799         u.desc = arg;
3800
3801         if (u.desc == NULL) {
3802                 goto error;
3803         }
3804         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) {
3805                 goto error;
3806         }
3807         switch (u.desc->bDescriptorSubtype) {
3808         case UDESCSUB_AC_INPUT:
3809                 len += sizeof(*u.it);
3810                 break;
3811
3812         case UDESCSUB_AC_OUTPUT:
3813                 len += sizeof(*u.ot);
3814                 break;
3815
3816         case UDESCSUB_AC_MIXER:
3817                 len += sizeof(*u.mu);
3818
3819                 if (u.desc->bLength < len) {
3820                         goto error;
3821                 }
3822                 len += u.mu->bNrInPins;
3823
3824                 if (u.desc->bLength < len) {
3825                         goto error;
3826                 }
3827                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
3828
3829                 len += sizeof(*d1);
3830                 break;
3831
3832         case UDESCSUB_AC_SELECTOR:
3833                 len += sizeof(*u.su);
3834
3835                 if (u.desc->bLength < len) {
3836                         goto error;
3837                 }
3838                 len += u.su->bNrInPins + 1;
3839                 break;
3840
3841         case UDESCSUB_AC_FEATURE:
3842                 len += sizeof(*u.fu) + 1;
3843
3844                 if (u.desc->bLength < len)
3845                         goto error;
3846
3847                 len += u.fu->bControlSize;
3848                 break;
3849
3850         case UDESCSUB_AC_PROCESSING:
3851                 len += sizeof(*u.pu);
3852
3853                 if (u.desc->bLength < len) {
3854                         goto error;
3855                 }
3856                 len += u.pu->bNrInPins;
3857
3858                 if (u.desc->bLength < len) {
3859                         goto error;
3860                 }
3861                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
3862
3863                 len += sizeof(*u1);
3864
3865                 if (u.desc->bLength < len) {
3866                         goto error;
3867                 }
3868                 len += u1->bControlSize;
3869
3870                 break;
3871
3872         case UDESCSUB_AC_EXTENSION:
3873                 len += sizeof(*u.eu);
3874
3875                 if (u.desc->bLength < len) {
3876                         goto error;
3877                 }
3878                 len += u.eu->bNrInPins;
3879
3880                 if (u.desc->bLength < len) {
3881                         goto error;
3882                 }
3883                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
3884
3885                 len += sizeof(*e1);
3886
3887                 if (u.desc->bLength < len) {
3888                         goto error;
3889                 }
3890                 len += e1->bControlSize;
3891                 break;
3892
3893         default:
3894                 goto error;
3895         }
3896
3897         if (u.desc->bLength < len) {
3898                 goto error;
3899         }
3900         return (u.desc);
3901
3902 error:
3903         if (u.desc) {
3904                 DPRINTF("invalid descriptor, type=%d, "
3905                     "sub_type=%d, len=%d of %d bytes\n",
3906                     u.desc->bDescriptorType,
3907                     u.desc->bDescriptorSubtype,
3908                     u.desc->bLength, len);
3909         }
3910         return (NULL);
3911 }
3912
3913 static const void *
3914 uaudio20_mixer_verify_desc(const void *arg, uint32_t len)
3915 {
3916         const struct usb_audio20_mixer_unit_1 *d1;
3917         const struct usb_audio20_extension_unit_1 *e1;
3918         const struct usb_audio20_processing_unit_1 *u1;
3919         const struct usb_audio20_clock_selector_unit_1 *c1;
3920
3921         union {
3922                 const struct usb_descriptor *desc;
3923                 const struct usb_audio20_clock_source_unit *csrc;
3924                 const struct usb_audio20_clock_selector_unit_0 *csel;
3925                 const struct usb_audio20_clock_multiplier_unit *cmul;
3926                 const struct usb_audio20_input_terminal *it;
3927                 const struct usb_audio20_output_terminal *ot;
3928                 const struct usb_audio20_mixer_unit_0 *mu;
3929                 const struct usb_audio20_selector_unit *su;
3930                 const struct usb_audio20_feature_unit *fu;
3931                 const struct usb_audio20_sample_rate_unit *ru;
3932                 const struct usb_audio20_processing_unit_0 *pu;
3933                 const struct usb_audio20_extension_unit_0 *eu;
3934                 const struct usb_audio20_effect_unit *ef;
3935         }     u;
3936
3937         u.desc = arg;
3938
3939         if (u.desc == NULL)
3940                 goto error;
3941
3942         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE)
3943                 goto error;
3944
3945         switch (u.desc->bDescriptorSubtype) {
3946         case UDESCSUB_AC_INPUT:
3947                 len += sizeof(*u.it);
3948                 break;
3949
3950         case UDESCSUB_AC_OUTPUT:
3951                 len += sizeof(*u.ot);
3952                 break;
3953
3954         case UDESCSUB_AC_MIXER:
3955                 len += sizeof(*u.mu);
3956
3957                 if (u.desc->bLength < len)
3958                         goto error;
3959                 len += u.mu->bNrInPins;
3960
3961                 if (u.desc->bLength < len)
3962                         goto error;
3963
3964                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
3965
3966                 len += sizeof(*d1) + d1->bNrChannels;
3967                 break;
3968
3969         case UDESCSUB_AC_SELECTOR:
3970                 len += sizeof(*u.su);
3971
3972                 if (u.desc->bLength < len)
3973                         goto error;
3974
3975                 len += u.su->bNrInPins + 1;
3976                 break;
3977
3978         case UDESCSUB_AC_FEATURE:
3979                 len += sizeof(*u.fu) + 1;
3980                 break;
3981
3982         case UDESCSUB_AC_EFFECT:
3983                 len += sizeof(*u.ef) + 4;
3984                 break;
3985
3986         case UDESCSUB_AC_PROCESSING_V2:
3987                 len += sizeof(*u.pu);
3988
3989                 if (u.desc->bLength < len)
3990                         goto error;
3991
3992                 len += u.pu->bNrInPins;
3993
3994                 if (u.desc->bLength < len)
3995                         goto error;
3996
3997                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
3998
3999                 len += sizeof(*u1);
4000                 break;
4001
4002         case UDESCSUB_AC_EXTENSION_V2:
4003                 len += sizeof(*u.eu);
4004
4005                 if (u.desc->bLength < len)
4006                         goto error;
4007
4008                 len += u.eu->bNrInPins;
4009
4010                 if (u.desc->bLength < len)
4011                         goto error;
4012
4013                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4014
4015                 len += sizeof(*e1);
4016                 break;
4017
4018         case UDESCSUB_AC_CLOCK_SRC:
4019                 len += sizeof(*u.csrc);
4020                 break;
4021
4022         case UDESCSUB_AC_CLOCK_SEL:
4023                 len += sizeof(*u.csel);
4024
4025                 if (u.desc->bLength < len)
4026                         goto error;
4027
4028                 len += u.csel->bNrInPins;
4029
4030                 if (u.desc->bLength < len)
4031                         goto error;
4032
4033                 c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins);
4034
4035                 len += sizeof(*c1);
4036                 break;
4037
4038         case UDESCSUB_AC_CLOCK_MUL:
4039                 len += sizeof(*u.cmul);
4040                 break;
4041
4042         case UDESCSUB_AC_SAMPLE_RT:
4043                 len += sizeof(*u.ru);
4044                 break;
4045
4046         default:
4047                 goto error;
4048         }
4049
4050         if (u.desc->bLength < len)
4051                 goto error;
4052
4053         return (u.desc);
4054
4055 error:
4056         if (u.desc) {
4057                 DPRINTF("invalid descriptor, type=%d, "
4058                     "sub_type=%d, len=%d of %d bytes\n",
4059                     u.desc->bDescriptorType,
4060                     u.desc->bDescriptorSubtype,
4061                     u.desc->bLength, len);
4062         }
4063         return (NULL);
4064 }
4065
4066 static struct usb_audio_cluster
4067 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4068 {
4069         struct usb_audio_cluster r;
4070         const struct usb_descriptor *dp;
4071         uint8_t i;
4072
4073         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
4074                 dp = iot[id].u.desc;
4075                 if (dp == NULL) {
4076                         goto error;
4077                 }
4078                 switch (dp->bDescriptorSubtype) {
4079                 case UDESCSUB_AC_INPUT:
4080                         r.bNrChannels = iot[id].u.it_v1->bNrChannels;
4081                         r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0];
4082                         r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1];
4083                         r.iChannelNames = iot[id].u.it_v1->iChannelNames;
4084                         goto done;
4085
4086                 case UDESCSUB_AC_OUTPUT:
4087                         id = iot[id].u.ot_v1->bSourceId;
4088                         break;
4089
4090                 case UDESCSUB_AC_MIXER:
4091                         r = *(const struct usb_audio_cluster *)
4092                             &iot[id].u.mu_v1->baSourceId[
4093                             iot[id].u.mu_v1->bNrInPins];
4094                         goto done;
4095
4096                 case UDESCSUB_AC_SELECTOR:
4097                         if (iot[id].u.su_v1->bNrInPins > 0) {
4098                                 /* XXX This is not really right */
4099                                 id = iot[id].u.su_v1->baSourceId[0];
4100                         }
4101                         break;
4102
4103                 case UDESCSUB_AC_FEATURE:
4104                         id = iot[id].u.fu_v1->bSourceId;
4105                         break;
4106
4107                 case UDESCSUB_AC_PROCESSING:
4108                         r = *((const struct usb_audio_cluster *)
4109                             &iot[id].u.pu_v1->baSourceId[
4110                             iot[id].u.pu_v1->bNrInPins]);
4111                         goto done;
4112
4113                 case UDESCSUB_AC_EXTENSION:
4114                         r = *((const struct usb_audio_cluster *)
4115                             &iot[id].u.eu_v1->baSourceId[
4116                             iot[id].u.eu_v1->bNrInPins]);
4117                         goto done;
4118
4119                 default:
4120                         goto error;
4121                 }
4122         }
4123 error:
4124         DPRINTF("bad data\n");
4125         memset(&r, 0, sizeof(r));
4126 done:
4127         return (r);
4128 }
4129
4130 static struct usb_audio20_cluster
4131 uaudio20_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4132 {
4133         struct usb_audio20_cluster r;
4134         const struct usb_descriptor *dp;
4135         uint8_t i;
4136
4137         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
4138                 dp = iot[id].u.desc;
4139                 if (dp == NULL)
4140                         goto error;
4141
4142                 switch (dp->bDescriptorSubtype) {
4143                 case UDESCSUB_AC_INPUT:
4144                         r.bNrChannels = iot[id].u.it_v2->bNrChannels;
4145                         r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0];
4146                         r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1];
4147                         r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2];
4148                         r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3];
4149                         r.iChannelNames = iot[id].u.it_v2->iTerminal;
4150                         goto done;
4151
4152                 case UDESCSUB_AC_OUTPUT:
4153                         id = iot[id].u.ot_v2->bSourceId;
4154                         break;
4155
4156                 case UDESCSUB_AC_MIXER:
4157                         r = *(const struct usb_audio20_cluster *)
4158                             &iot[id].u.mu_v2->baSourceId[
4159                             iot[id].u.mu_v2->bNrInPins];
4160                         goto done;
4161
4162                 case UDESCSUB_AC_SELECTOR:
4163                         if (iot[id].u.su_v2->bNrInPins > 0) {
4164                                 /* XXX This is not really right */
4165                                 id = iot[id].u.su_v2->baSourceId[0];
4166                         }
4167                         break;
4168
4169                 case UDESCSUB_AC_SAMPLE_RT:
4170                         id = iot[id].u.ru_v2->bSourceId;
4171                         break;
4172
4173                 case UDESCSUB_AC_EFFECT:
4174                         id = iot[id].u.ef_v2->bSourceId;
4175                         break;
4176
4177                 case UDESCSUB_AC_FEATURE:
4178                         id = iot[id].u.fu_v2->bSourceId;
4179                         break;
4180
4181                 case UDESCSUB_AC_PROCESSING_V2:
4182                         r = *((const struct usb_audio20_cluster *)
4183                             &iot[id].u.pu_v2->baSourceId[
4184                             iot[id].u.pu_v2->bNrInPins]);
4185                         goto done;
4186
4187                 case UDESCSUB_AC_EXTENSION_V2:
4188                         r = *((const struct usb_audio20_cluster *)
4189                             &iot[id].u.eu_v2->baSourceId[
4190                             iot[id].u.eu_v2->bNrInPins]);
4191                         goto done;
4192
4193                 default:
4194                         goto error;
4195                 }
4196         }
4197 error:
4198         DPRINTF("Bad data!\n");
4199         memset(&r, 0, sizeof(r));
4200 done:
4201         return (r);
4202 }
4203
4204 static uint16_t
4205 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot,
4206     struct uaudio_mixer_node *mix)
4207 {
4208         uint16_t terminal_type = 0x0000;
4209         const struct uaudio_terminal_node *input[2];
4210         const struct uaudio_terminal_node *output[2];
4211
4212         input[0] = uaudio_mixer_get_input(iot, 0);
4213         input[1] = uaudio_mixer_get_input(iot, 1);
4214
4215         output[0] = uaudio_mixer_get_output(iot, 0);
4216         output[1] = uaudio_mixer_get_output(iot, 1);
4217
4218         /*
4219          * check if there is only
4220          * one output terminal:
4221          */
4222         if (output[0] && (!output[1])) {
4223                 terminal_type =
4224                     UGETW(output[0]->u.ot_v1->wTerminalType);
4225         }
4226         /*
4227          * If the only output terminal is USB,
4228          * the class is UAC_RECORD.
4229          */
4230         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
4231
4232                 mix->class = UAC_RECORD;
4233                 if (input[0] && (!input[1])) {
4234                         terminal_type =
4235                             UGETW(input[0]->u.it_v1->wTerminalType);
4236                 } else {
4237                         terminal_type = 0;
4238                 }
4239                 goto done;
4240         }
4241         /*
4242          * if the unit is connected to just
4243          * one input terminal, the
4244          * class is UAC_INPUT:
4245          */
4246         if (input[0] && (!input[1])) {
4247                 mix->class = UAC_INPUT;
4248                 terminal_type =
4249                     UGETW(input[0]->u.it_v1->wTerminalType);
4250                 goto done;
4251         }
4252         /*
4253          * Otherwise, the class is UAC_OUTPUT.
4254          */
4255         mix->class = UAC_OUTPUT;
4256 done:
4257         return (terminal_type);
4258 }
4259
4260 static uint16_t
4261 uaudio20_mixer_determine_class(const struct uaudio_terminal_node *iot,
4262     struct uaudio_mixer_node *mix)
4263 {
4264         uint16_t terminal_type = 0x0000;
4265         const struct uaudio_terminal_node *input[2];
4266         const struct uaudio_terminal_node *output[2];
4267
4268         input[0] = uaudio_mixer_get_input(iot, 0);
4269         input[1] = uaudio_mixer_get_input(iot, 1);
4270
4271         output[0] = uaudio_mixer_get_output(iot, 0);
4272         output[1] = uaudio_mixer_get_output(iot, 1);
4273
4274         /*
4275          * check if there is only
4276          * one output terminal:
4277          */
4278         if (output[0] && (!output[1]))
4279                 terminal_type = UGETW(output[0]->u.ot_v2->wTerminalType);
4280         /*
4281          * If the only output terminal is USB,
4282          * the class is UAC_RECORD.
4283          */
4284         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
4285
4286                 mix->class = UAC_RECORD;
4287                 if (input[0] && (!input[1])) {
4288                         terminal_type =
4289                             UGETW(input[0]->u.it_v2->wTerminalType);
4290                 } else {
4291                         terminal_type = 0;
4292                 }
4293                 goto done;
4294         }
4295         /*
4296          * if the unit is connected to just
4297          * one input terminal, the
4298          * class is UAC_INPUT:
4299          */
4300         if (input[0] && (!input[1])) {
4301                 mix->class = UAC_INPUT;
4302                 terminal_type =
4303                     UGETW(input[0]->u.it_v2->wTerminalType);
4304                 goto done;
4305         }
4306         /*
4307          * Otherwise, the class is UAC_OUTPUT.
4308          */
4309         mix->class = UAC_OUTPUT;
4310 done:
4311         return (terminal_type);
4312 }
4313
4314 struct uaudio_tt_to_feature {
4315         uint16_t terminal_type;
4316         uint16_t feature;
4317 };
4318
4319 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = {
4320
4321         {UAT_STREAM, SOUND_MIXER_PCM},
4322
4323         {UATI_MICROPHONE, SOUND_MIXER_MIC},
4324         {UATI_DESKMICROPHONE, SOUND_MIXER_MIC},
4325         {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC},
4326         {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC},
4327         {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC},
4328         {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC},
4329
4330         {UATO_SPEAKER, SOUND_MIXER_SPEAKER},
4331         {UATO_DESKTOPSPEAKER, SOUND_MIXER_SPEAKER},
4332         {UATO_ROOMSPEAKER, SOUND_MIXER_SPEAKER},
4333         {UATO_COMMSPEAKER, SOUND_MIXER_SPEAKER},
4334
4335         {UATE_ANALOGCONN, SOUND_MIXER_LINE},
4336         {UATE_LINECONN, SOUND_MIXER_LINE},
4337         {UATE_LEGACYCONN, SOUND_MIXER_LINE},
4338
4339         {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM},
4340         {UATE_SPDIF, SOUND_MIXER_ALTPCM},
4341         {UATE_1394DA, SOUND_MIXER_ALTPCM},
4342         {UATE_1394DV, SOUND_MIXER_ALTPCM},
4343
4344         {UATF_CDPLAYER, SOUND_MIXER_CD},
4345
4346         {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH},
4347
4348         {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO},
4349         {UATF_DVDAUDIO, SOUND_MIXER_VIDEO},
4350         {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO},
4351
4352         /* telephony terminal types */
4353         {UATT_UNDEFINED, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4354         {UATT_PHONELINE, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4355         {UATT_TELEPHONE, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4356         {UATT_DOWNLINEPHONE, SOUND_MIXER_PHONEIN},      /* SOUND_MIXER_PHONEOUT */
4357
4358         {UATF_RADIORECV, SOUND_MIXER_RADIO},
4359         {UATF_RADIOXMIT, SOUND_MIXER_RADIO},
4360
4361         {UAT_UNDEFINED, SOUND_MIXER_VOLUME},
4362         {UAT_VENDOR, SOUND_MIXER_VOLUME},
4363         {UATI_UNDEFINED, SOUND_MIXER_VOLUME},
4364
4365         /* output terminal types */
4366         {UATO_UNDEFINED, SOUND_MIXER_VOLUME},
4367         {UATO_DISPLAYAUDIO, SOUND_MIXER_VOLUME},
4368         {UATO_SUBWOOFER, SOUND_MIXER_VOLUME},
4369         {UATO_HEADPHONES, SOUND_MIXER_VOLUME},
4370
4371         /* bidir terminal types */
4372         {UATB_UNDEFINED, SOUND_MIXER_VOLUME},
4373         {UATB_HANDSET, SOUND_MIXER_VOLUME},
4374         {UATB_HEADSET, SOUND_MIXER_VOLUME},
4375         {UATB_SPEAKERPHONE, SOUND_MIXER_VOLUME},
4376         {UATB_SPEAKERPHONEESUP, SOUND_MIXER_VOLUME},
4377         {UATB_SPEAKERPHONEECANC, SOUND_MIXER_VOLUME},
4378
4379         /* external terminal types */
4380         {UATE_UNDEFINED, SOUND_MIXER_VOLUME},
4381
4382         /* embedded function terminal types */
4383         {UATF_UNDEFINED, SOUND_MIXER_VOLUME},
4384         {UATF_CALIBNOISE, SOUND_MIXER_VOLUME},
4385         {UATF_EQUNOISE, SOUND_MIXER_VOLUME},
4386         {UATF_DAT, SOUND_MIXER_VOLUME},
4387         {UATF_DCC, SOUND_MIXER_VOLUME},
4388         {UATF_MINIDISK, SOUND_MIXER_VOLUME},
4389         {UATF_ANALOGTAPE, SOUND_MIXER_VOLUME},
4390         {UATF_PHONOGRAPH, SOUND_MIXER_VOLUME},
4391         {UATF_VCRAUDIO, SOUND_MIXER_VOLUME},
4392         {UATF_SATELLITE, SOUND_MIXER_VOLUME},
4393         {UATF_CABLETUNER, SOUND_MIXER_VOLUME},
4394         {UATF_DSS, SOUND_MIXER_VOLUME},
4395         {UATF_MULTITRACK, SOUND_MIXER_VOLUME},
4396         {0xffff, SOUND_MIXER_VOLUME},
4397
4398         /* default */
4399         {0x0000, SOUND_MIXER_VOLUME},
4400 };
4401
4402 static uint16_t
4403 uaudio_mixer_feature_name(const struct uaudio_terminal_node *iot,
4404     struct uaudio_mixer_node *mix)
4405 {
4406         const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature;
4407         uint16_t terminal_type = uaudio_mixer_determine_class(iot, mix);
4408
4409         if ((mix->class == UAC_RECORD) && (terminal_type == 0)) {
4410                 return (SOUND_MIXER_IMIX);
4411         }
4412         while (uat->terminal_type) {
4413                 if (uat->terminal_type == terminal_type) {
4414                         break;
4415                 }
4416                 uat++;
4417         }
4418
4419         DPRINTF("terminal_type=0x%04x -> %d\n",
4420             terminal_type, uat->feature);
4421
4422         return (uat->feature);
4423 }
4424
4425 static uint16_t
4426 uaudio20_mixer_feature_name(const struct uaudio_terminal_node *iot,
4427     struct uaudio_mixer_node *mix)
4428 {
4429         const struct uaudio_tt_to_feature *uat;
4430         uint16_t terminal_type = uaudio20_mixer_determine_class(iot, mix);
4431
4432         if ((mix->class == UAC_RECORD) && (terminal_type == 0))
4433                 return (SOUND_MIXER_IMIX);
4434
4435         for (uat = uaudio_tt_to_feature; uat->terminal_type != 0; uat++) {
4436                 if (uat->terminal_type == terminal_type)
4437                         break;
4438         }
4439
4440         DPRINTF("terminal_type=0x%04x -> %d\n",
4441             terminal_type, uat->feature);
4442
4443         return (uat->feature);
4444 }
4445
4446 static const struct uaudio_terminal_node *
4447 uaudio_mixer_get_input(const struct uaudio_terminal_node *iot, uint8_t i)
4448 {
4449         struct uaudio_terminal_node *root = iot->root;
4450         uint8_t n;
4451
4452         n = iot->usr.id_max;
4453         do {
4454                 if (iot->usr.bit_input[n / 8] & (1 << (n % 8))) {
4455                         if (!i--)
4456                                 return (root + n);
4457                 }
4458         } while (n--);
4459
4460         return (NULL);
4461 }
4462
4463 static const struct uaudio_terminal_node *
4464 uaudio_mixer_get_output(const struct uaudio_terminal_node *iot, uint8_t i)
4465 {
4466         struct uaudio_terminal_node *root = iot->root;
4467         uint8_t n;
4468
4469         n = iot->usr.id_max;
4470         do {
4471                 if (iot->usr.bit_output[n / 8] & (1 << (n % 8))) {
4472                         if (!i--)
4473                                 return (root + n);
4474                 }
4475         } while (n--);
4476
4477         return (NULL);
4478 }
4479
4480 static void
4481 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4482     const uint8_t *p_id, uint8_t n_id,
4483     struct uaudio_search_result *info)
4484 {
4485         struct uaudio_terminal_node *iot;
4486         uint8_t n;
4487         uint8_t i;
4488         uint8_t is_last;
4489
4490 top:
4491         for (n = 0; n < n_id; n++) {
4492
4493                 i = p_id[n];
4494
4495                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4496                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4497                         return;
4498                 }
4499
4500                 info->recurse_level++;
4501
4502                 iot = (root + i);
4503
4504                 if (iot->u.desc == NULL)
4505                         continue;
4506
4507                 is_last = ((n + 1) == n_id);
4508
4509                 switch (iot->u.desc->bDescriptorSubtype) {
4510                 case UDESCSUB_AC_INPUT:
4511                         info->bit_input[i / 8] |= (1 << (i % 8));
4512                         break;
4513
4514                 case UDESCSUB_AC_FEATURE:
4515                         if (is_last) {
4516                                 p_id = &iot->u.fu_v1->bSourceId;
4517                                 n_id = 1;
4518                                 goto top;
4519                         }
4520                         uaudio_mixer_find_inputs_sub(
4521                             root, &iot->u.fu_v1->bSourceId, 1, info);
4522                         break;
4523
4524                 case UDESCSUB_AC_OUTPUT:
4525                         if (is_last) {
4526                                 p_id = &iot->u.ot_v1->bSourceId;
4527                                 n_id = 1;
4528                                 goto top;
4529                         }
4530                         uaudio_mixer_find_inputs_sub(
4531                             root, &iot->u.ot_v1->bSourceId, 1, info);
4532                         break;
4533
4534                 case UDESCSUB_AC_MIXER:
4535                         if (is_last) {
4536                                 p_id = iot->u.mu_v1->baSourceId;
4537                                 n_id = iot->u.mu_v1->bNrInPins;
4538                                 goto top;
4539                         }
4540                         uaudio_mixer_find_inputs_sub(
4541                             root, iot->u.mu_v1->baSourceId,
4542                             iot->u.mu_v1->bNrInPins, info);
4543                         break;
4544
4545                 case UDESCSUB_AC_SELECTOR:
4546                         if (is_last) {
4547                                 p_id = iot->u.su_v1->baSourceId;
4548                                 n_id = iot->u.su_v1->bNrInPins;
4549                                 goto top;
4550                         }
4551                         uaudio_mixer_find_inputs_sub(
4552                             root, iot->u.su_v1->baSourceId,
4553                             iot->u.su_v1->bNrInPins, info);
4554                         break;
4555
4556                 case UDESCSUB_AC_PROCESSING:
4557                         if (is_last) {
4558                                 p_id = iot->u.pu_v1->baSourceId;
4559                                 n_id = iot->u.pu_v1->bNrInPins;
4560                                 goto top;
4561                         }
4562                         uaudio_mixer_find_inputs_sub(
4563                             root, iot->u.pu_v1->baSourceId,
4564                             iot->u.pu_v1->bNrInPins, info);
4565                         break;
4566
4567                 case UDESCSUB_AC_EXTENSION:
4568                         if (is_last) {
4569                                 p_id = iot->u.eu_v1->baSourceId;
4570                                 n_id = iot->u.eu_v1->bNrInPins;
4571                                 goto top;
4572                         }
4573                         uaudio_mixer_find_inputs_sub(
4574                             root, iot->u.eu_v1->baSourceId,
4575                             iot->u.eu_v1->bNrInPins, info);
4576                         break;
4577
4578                 default:
4579                         break;
4580                 }
4581         }
4582 }
4583
4584 static void
4585 uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4586     const uint8_t *p_id, uint8_t n_id,
4587     struct uaudio_search_result *info)
4588 {
4589         struct uaudio_terminal_node *iot;
4590         uint8_t n;
4591         uint8_t i;
4592         uint8_t is_last;
4593
4594 top:
4595         for (n = 0; n < n_id; n++) {
4596
4597                 i = p_id[n];
4598
4599                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4600                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4601                         return;
4602                 }
4603
4604                 info->recurse_level++;
4605
4606                 iot = (root + i);
4607
4608                 if (iot->u.desc == NULL)
4609                         continue;
4610
4611                 is_last = ((n + 1) == n_id);
4612
4613                 switch (iot->u.desc->bDescriptorSubtype) {
4614                 case UDESCSUB_AC_INPUT:
4615                         info->bit_input[i / 8] |= (1 << (i % 8));
4616                         break;
4617
4618                 case UDESCSUB_AC_OUTPUT:
4619                         if (is_last) {
4620                                 p_id = &iot->u.ot_v2->bSourceId;
4621                                 n_id = 1;
4622                                 goto top;
4623                         }
4624                         uaudio20_mixer_find_inputs_sub(
4625                             root, &iot->u.ot_v2->bSourceId, 1, info);
4626                         break;
4627
4628                 case UDESCSUB_AC_MIXER:
4629                         if (is_last) {
4630                                 p_id = iot->u.mu_v2->baSourceId;
4631                                 n_id = iot->u.mu_v2->bNrInPins;
4632                                 goto top;
4633                         }
4634                         uaudio20_mixer_find_inputs_sub(
4635                             root, iot->u.mu_v2->baSourceId,
4636                             iot->u.mu_v2->bNrInPins, info);
4637                         break;
4638
4639                 case UDESCSUB_AC_SELECTOR:
4640                         if (is_last) {
4641                                 p_id = iot->u.su_v2->baSourceId;
4642                                 n_id = iot->u.su_v2->bNrInPins;
4643                                 goto top;
4644                         }
4645                         uaudio20_mixer_find_inputs_sub(
4646                             root, iot->u.su_v2->baSourceId,
4647                             iot->u.su_v2->bNrInPins, info);
4648                         break;
4649
4650                 case UDESCSUB_AC_SAMPLE_RT:
4651                         if (is_last) {
4652                                 p_id = &iot->u.ru_v2->bSourceId;
4653                                 n_id = 1;
4654                                 goto top;
4655                         }
4656                         uaudio20_mixer_find_inputs_sub(
4657                             root, &iot->u.ru_v2->bSourceId,
4658                             1, info);
4659                         break;
4660
4661                 case UDESCSUB_AC_EFFECT:
4662                         if (is_last) {
4663                                 p_id = &iot->u.ef_v2->bSourceId;
4664                                 n_id = 1;
4665                                 goto top;
4666                         }
4667                         uaudio20_mixer_find_inputs_sub(
4668                             root, &iot->u.ef_v2->bSourceId,
4669                             1, info);
4670                         break;
4671
4672                 case UDESCSUB_AC_FEATURE:
4673                         if (is_last) {
4674                                 p_id = &iot->u.fu_v2->bSourceId;
4675                                 n_id = 1;
4676                                 goto top;
4677                         }
4678                         uaudio20_mixer_find_inputs_sub(
4679                             root, &iot->u.fu_v2->bSourceId, 1, info);
4680                         break;
4681
4682                 case UDESCSUB_AC_PROCESSING_V2:
4683                         if (is_last) {
4684                                 p_id = iot->u.pu_v2->baSourceId;
4685                                 n_id = iot->u.pu_v2->bNrInPins;
4686                                 goto top;
4687                         }
4688                         uaudio20_mixer_find_inputs_sub(
4689                             root, iot->u.pu_v2->baSourceId,
4690                             iot->u.pu_v2->bNrInPins, info);
4691                         break;
4692
4693                 case UDESCSUB_AC_EXTENSION_V2:
4694                         if (is_last) {
4695                                 p_id = iot->u.eu_v2->baSourceId;
4696                                 n_id = iot->u.eu_v2->bNrInPins;
4697                                 goto top;
4698                         }
4699                         uaudio20_mixer_find_inputs_sub(
4700                             root, iot->u.eu_v2->baSourceId,
4701                             iot->u.eu_v2->bNrInPins, info);
4702                         break;
4703                 default:
4704                         break;
4705                 }
4706         }
4707 }
4708
4709 static void
4710 uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root,
4711     const uint8_t *p_id, uint8_t n_id,
4712     struct uaudio_search_result *info)
4713 {
4714         struct uaudio_terminal_node *iot;
4715         uint8_t n;
4716         uint8_t i;
4717         uint8_t is_last;
4718         uint8_t id;
4719
4720 top:
4721         for (n = 0; n < n_id; n++) {
4722
4723                 i = p_id[n];
4724
4725                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4726                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4727                         return;
4728                 }
4729
4730                 info->recurse_level++;
4731
4732                 iot = (root + i);
4733
4734                 if (iot->u.desc == NULL)
4735                         continue;
4736
4737                 is_last = ((n + 1) == n_id);
4738
4739                 switch (iot->u.desc->bDescriptorSubtype) {
4740                 case UDESCSUB_AC_INPUT:
4741                         info->is_input = 1;
4742                         if (is_last) {
4743                                 p_id = &iot->u.it_v2->bCSourceId;
4744                                 n_id = 1;
4745                                 goto top;
4746                         }
4747                         uaudio20_mixer_find_clocks_sub(root,
4748                             &iot->u.it_v2->bCSourceId, 1, info);
4749                         break;
4750
4751                 case UDESCSUB_AC_OUTPUT:
4752                         info->is_input = 0;
4753                         if (is_last) {
4754                                 p_id = &iot->u.ot_v2->bCSourceId;
4755                                 n_id = 1;
4756                                 goto top;
4757                         }
4758                         uaudio20_mixer_find_clocks_sub(root,
4759                             &iot->u.ot_v2->bCSourceId, 1, info);
4760                         break;
4761
4762                 case UDESCSUB_AC_CLOCK_SEL:
4763                         if (is_last) {
4764                                 p_id = iot->u.csel_v2->baCSourceId;
4765                                 n_id = iot->u.csel_v2->bNrInPins;
4766                                 goto top;
4767                         }
4768                         uaudio20_mixer_find_clocks_sub(root,
4769                             iot->u.csel_v2->baCSourceId,
4770                             iot->u.csel_v2->bNrInPins, info);
4771                         break;
4772
4773                 case UDESCSUB_AC_CLOCK_MUL:
4774                         if (is_last) {
4775                                 p_id = &iot->u.cmul_v2->bCSourceId;
4776                                 n_id = 1;
4777                                 goto top;
4778                         }
4779                         uaudio20_mixer_find_clocks_sub(root,
4780                             &iot->u.cmul_v2->bCSourceId,
4781                             1, info);
4782                         break;
4783
4784                 case UDESCSUB_AC_CLOCK_SRC:
4785
4786                         id = iot->u.csrc_v2->bClockId;
4787
4788                         switch (info->is_input) {
4789                         case 0:
4790                                 info->bit_output[id / 8] |= (1 << (id % 8));
4791                                 break;
4792                         case 1:
4793                                 info->bit_input[id / 8] |= (1 << (id % 8));
4794                                 break;
4795                         default:
4796                                 break;
4797                         }
4798                         break;
4799
4800                 default:
4801                         break;
4802                 }
4803         }
4804 }
4805
4806 static void
4807 uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *root, uint8_t id,
4808     uint8_t n_id, struct uaudio_search_result *info)
4809 {
4810         struct uaudio_terminal_node *iot = (root + id);
4811         uint8_t j;
4812
4813         j = n_id;
4814         do {
4815                 if ((j != id) && ((root + j)->u.desc) &&
4816                     ((root + j)->u.desc->bDescriptorSubtype == UDESCSUB_AC_OUTPUT)) {
4817
4818                         /*
4819                          * "j" (output) <--- virtual wire <--- "id" (input)
4820                          *
4821                          * if "j" has "id" on the input, then "id" have "j" on
4822                          * the output, because they are connected:
4823                          */
4824                         if ((root + j)->usr.bit_input[id / 8] & (1 << (id % 8))) {
4825                                 iot->usr.bit_output[j / 8] |= (1 << (j % 8));
4826                         }
4827                 }
4828         } while (j--);
4829 }
4830
4831 static void
4832 uaudio_mixer_fill_info(struct uaudio_softc *sc,
4833     struct usb_device *udev, void *desc)
4834 {
4835         const struct usb_audio_control_descriptor *acdp;
4836         struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
4837         const struct usb_descriptor *dp;
4838         const struct usb_audio_unit *au;
4839         struct uaudio_terminal_node *iot = NULL;
4840         uint16_t wTotalLen;
4841         uint8_t ID_max = 0;             /* inclusive */
4842         uint8_t i;
4843
4844         desc = usb_desc_foreach(cd, desc);
4845
4846         if (desc == NULL) {
4847                 DPRINTF("no Audio Control header\n");
4848                 goto done;
4849         }
4850         acdp = desc;
4851
4852         if ((acdp->bLength < sizeof(*acdp)) ||
4853             (acdp->bDescriptorType != UDESC_CS_INTERFACE) ||
4854             (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) {
4855                 DPRINTF("invalid Audio Control header\n");
4856                 goto done;
4857         }
4858         /* "wTotalLen" is allowed to be corrupt */
4859         wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength;
4860
4861         /* get USB audio revision */
4862         sc->sc_audio_rev = UGETW(acdp->bcdADC);
4863
4864         DPRINTFN(3, "found AC header, vers=%03x, len=%d\n",
4865             sc->sc_audio_rev, wTotalLen);
4866
4867         iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP,
4868             M_WAITOK | M_ZERO);
4869
4870         if (iot == NULL) {
4871                 DPRINTF("no memory!\n");
4872                 goto done;
4873         }
4874         while ((desc = usb_desc_foreach(cd, desc))) {
4875
4876                 dp = desc;
4877
4878                 if (dp->bLength > wTotalLen) {
4879                         break;
4880                 } else {
4881                         wTotalLen -= dp->bLength;
4882                 }
4883
4884                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30)
4885                         au = NULL;
4886                 else if (sc->sc_audio_rev >= UAUDIO_VERSION_20)
4887                         au = uaudio20_mixer_verify_desc(dp, 0);
4888                 else
4889                         au = uaudio_mixer_verify_desc(dp, 0);
4890
4891                 if (au) {
4892                         iot[au->bUnitId].u.desc = (const void *)au;
4893                         if (au->bUnitId > ID_max)
4894                                 ID_max = au->bUnitId;
4895                 }
4896         }
4897
4898         DPRINTF("Maximum ID=%d\n", ID_max);
4899
4900         /*
4901          * determine sourcing inputs for
4902          * all nodes in the tree:
4903          */
4904         i = ID_max;
4905         do {
4906                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
4907                         /* FALLTHROUGH */
4908                 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
4909                         uaudio20_mixer_find_inputs_sub(iot,
4910                             &i, 1, &((iot + i)->usr));
4911
4912                         sc->sc_mixer_clocks.is_input = 255;
4913                         sc->sc_mixer_clocks.recurse_level = 0;
4914
4915                         uaudio20_mixer_find_clocks_sub(iot,
4916                             &i, 1, &sc->sc_mixer_clocks);
4917                 } else {
4918                         uaudio_mixer_find_inputs_sub(iot,
4919                             &i, 1, &((iot + i)->usr));
4920                 }
4921         } while (i--);
4922
4923         /*
4924          * determine outputs for
4925          * all nodes in the tree:
4926          */
4927         i = ID_max;
4928         do {
4929                 uaudio_mixer_find_outputs_sub(iot,
4930                     i, ID_max, &((iot + i)->usr));
4931         } while (i--);
4932
4933         /* set "id_max" and "root" */
4934
4935         i = ID_max;
4936         do {
4937                 (iot + i)->usr.id_max = ID_max;
4938                 (iot + i)->root = iot;
4939         } while (i--);
4940
4941         /*
4942          * Scan the config to create a linked list of "mixer" nodes:
4943          */
4944
4945         i = ID_max;
4946         do {
4947                 dp = iot[i].u.desc;
4948
4949                 if (dp == NULL)
4950                         continue;
4951
4952                 DPRINTFN(11, "id=%d subtype=%d\n",
4953                     i, dp->bDescriptorSubtype);
4954
4955                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
4956                         continue;
4957                 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
4958
4959                         switch (dp->bDescriptorSubtype) {
4960                         case UDESCSUB_AC_HEADER:
4961                                 DPRINTF("unexpected AC header\n");
4962                                 break;
4963
4964                         case UDESCSUB_AC_INPUT:
4965                         case UDESCSUB_AC_OUTPUT:
4966                         case UDESCSUB_AC_PROCESSING_V2:
4967                         case UDESCSUB_AC_EXTENSION_V2:
4968                         case UDESCSUB_AC_EFFECT:
4969                         case UDESCSUB_AC_CLOCK_SRC:
4970                         case UDESCSUB_AC_CLOCK_SEL:
4971                         case UDESCSUB_AC_CLOCK_MUL:
4972                         case UDESCSUB_AC_SAMPLE_RT:
4973                                 break;
4974
4975                         case UDESCSUB_AC_MIXER:
4976                                 uaudio20_mixer_add_mixer(sc, iot, i);
4977                                 break;
4978
4979                         case UDESCSUB_AC_SELECTOR:
4980                                 uaudio20_mixer_add_selector(sc, iot, i);
4981                                 break;
4982
4983                         case UDESCSUB_AC_FEATURE:
4984                                 uaudio20_mixer_add_feature(sc, iot, i);
4985                                 break;
4986
4987                         default:
4988                                 DPRINTF("bad AC desc subtype=0x%02x\n",
4989                                     dp->bDescriptorSubtype);
4990                                 break;
4991                         }
4992                         continue;
4993                 }
4994
4995                 switch (dp->bDescriptorSubtype) {
4996                 case UDESCSUB_AC_HEADER:
4997                         DPRINTF("unexpected AC header\n");
4998                         break;
4999
5000                 case UDESCSUB_AC_INPUT:
5001                 case UDESCSUB_AC_OUTPUT:
5002                         break;
5003
5004                 case UDESCSUB_AC_MIXER:
5005                         uaudio_mixer_add_mixer(sc, iot, i);
5006                         break;
5007
5008                 case UDESCSUB_AC_SELECTOR:
5009                         uaudio_mixer_add_selector(sc, iot, i);
5010                         break;
5011
5012                 case UDESCSUB_AC_FEATURE:
5013                         uaudio_mixer_add_feature(sc, iot, i);
5014                         break;
5015
5016                 case UDESCSUB_AC_PROCESSING:
5017                         uaudio_mixer_add_processing(sc, iot, i);
5018                         break;
5019
5020                 case UDESCSUB_AC_EXTENSION:
5021                         uaudio_mixer_add_extension(sc, iot, i);
5022                         break;
5023
5024                 default:
5025                         DPRINTF("bad AC desc subtype=0x%02x\n",
5026                             dp->bDescriptorSubtype);
5027                         break;
5028                 }
5029
5030         } while (i--);
5031
5032 done:
5033         free(iot, M_TEMP);
5034 }
5035
5036 static int
5037 uaudio_mixer_get(struct usb_device *udev, uint16_t audio_rev,
5038     uint8_t what, struct uaudio_mixer_node *mc)
5039 {
5040         struct usb_device_request req;
5041         int val;
5042         uint8_t data[2 + (2 * 3)];
5043         usb_error_t err;
5044
5045         if (mc->wValue[0] == -1)
5046                 return (0);
5047
5048         if (audio_rev >= UAUDIO_VERSION_30)
5049                 return (0);
5050         else if (audio_rev >= UAUDIO_VERSION_20) {
5051                 if (what == GET_CUR) {
5052                         req.bRequest = UA20_CS_CUR;
5053                         USETW(req.wLength, 2);
5054                 } else {
5055                         req.bRequest = UA20_CS_RANGE;
5056                         USETW(req.wLength, 8);
5057                 }
5058         } else {
5059                 uint16_t len = MIX_SIZE(mc->type);
5060
5061                 req.bRequest = what;
5062                 USETW(req.wLength, len);
5063         }
5064
5065         req.bmRequestType = UT_READ_CLASS_INTERFACE;
5066         USETW(req.wValue, mc->wValue[0]);
5067         USETW(req.wIndex, mc->wIndex);
5068
5069         memset(data, 0, sizeof(data));
5070
5071         err = usbd_do_request(udev, NULL, &req, data);
5072         if (err) {
5073                 DPRINTF("err=%s\n", usbd_errstr(err));
5074                 return (0);
5075         }
5076
5077         if (audio_rev >= UAUDIO_VERSION_30) {
5078                 val = 0;
5079         } else if (audio_rev >= UAUDIO_VERSION_20) {
5080                 switch (what) {
5081                 case GET_CUR:
5082                         val = (data[0] | (data[1] << 8));
5083                         break;
5084                 case GET_MIN:
5085                         val = (data[2] | (data[3] << 8));
5086                         break;
5087                 case GET_MAX:
5088                         val = (data[4] | (data[5] << 8));
5089                         break;
5090                 case GET_RES:
5091                         val = (data[6] | (data[7] << 8));
5092                         break;
5093                 default:
5094                         val = 0;
5095                         break;
5096                 }
5097         } else {
5098                 val = (data[0] | (data[1] << 8));
5099         }
5100
5101         if (what == GET_CUR || what == GET_MIN || what == GET_MAX)
5102                 val = uaudio_mixer_signext(mc->type, val);
5103
5104         DPRINTFN(3, "val=%d\n", val);
5105
5106         return (val);
5107 }
5108
5109 static void
5110 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error)
5111 {
5112         struct usb_device_request req;
5113         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
5114         struct uaudio_mixer_node *mc = sc->sc_mixer_curr;
5115         struct usb_page_cache *pc;
5116         uint16_t len;
5117         uint8_t repeat = 1;
5118         uint8_t update;
5119         uint8_t chan;
5120         uint8_t buf[2];
5121
5122         DPRINTF("\n");
5123
5124         switch (USB_GET_STATE(xfer)) {
5125         case USB_ST_TRANSFERRED:
5126 tr_transferred:
5127         case USB_ST_SETUP:
5128 tr_setup:
5129
5130                 if (mc == NULL) {
5131                         mc = sc->sc_mixer_root;
5132                         sc->sc_mixer_curr = mc;
5133                         sc->sc_mixer_chan = 0;
5134                         repeat = 0;
5135                 }
5136                 while (mc) {
5137                         while (sc->sc_mixer_chan < mc->nchan) {
5138
5139                                 chan = sc->sc_mixer_chan;
5140
5141                                 sc->sc_mixer_chan++;
5142
5143                                 update = ((mc->update[chan / 8] & (1 << (chan % 8))) &&
5144                                     (mc->wValue[chan] != -1));
5145
5146                                 mc->update[chan / 8] &= ~(1 << (chan % 8));
5147
5148                                 if (update) {
5149
5150                                         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5151                                         USETW(req.wValue, mc->wValue[chan]);
5152                                         USETW(req.wIndex, mc->wIndex);
5153
5154                                         if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5155                                                 return;
5156                                         } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5157                                                 len = 2;
5158                                                 req.bRequest = UA20_CS_CUR;
5159                                                 USETW(req.wLength, len);
5160                                         } else {
5161                                                 len = MIX_SIZE(mc->type);
5162                                                 req.bRequest = SET_CUR;
5163                                                 USETW(req.wLength, len);
5164                                         }
5165
5166                                         buf[0] = (mc->wData[chan] & 0xFF);
5167                                         buf[1] = (mc->wData[chan] >> 8) & 0xFF;
5168
5169                                         pc = usbd_xfer_get_frame(xfer, 0);
5170                                         usbd_copy_in(pc, 0, &req, sizeof(req));
5171                                         pc = usbd_xfer_get_frame(xfer, 1);
5172                                         usbd_copy_in(pc, 0, buf, len);
5173
5174                                         usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
5175                                         usbd_xfer_set_frame_len(xfer, 1, len);
5176                                         usbd_xfer_set_frames(xfer, len ? 2 : 1);
5177                                         usbd_transfer_submit(xfer);
5178                                         return;
5179                                 }
5180                         }
5181
5182                         mc = mc->next;
5183                         sc->sc_mixer_curr = mc;
5184                         sc->sc_mixer_chan = 0;
5185                 }
5186
5187                 if (repeat) {
5188                         goto tr_setup;
5189                 }
5190                 break;
5191
5192         default:                        /* Error */
5193                 DPRINTF("error=%s\n", usbd_errstr(error));
5194                 if (error == USB_ERR_CANCELLED) {
5195                         /* do nothing - we are detaching */
5196                         break;
5197                 }
5198                 goto tr_transferred;
5199         }
5200 }
5201
5202 static usb_error_t
5203 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)
5204 {
5205         struct usb_device_request req;
5206         uint8_t data[3];
5207
5208         DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed);
5209
5210         req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
5211         req.bRequest = SET_CUR;
5212         USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
5213         USETW(req.wIndex, endpt);
5214         USETW(req.wLength, 3);
5215         data[0] = speed;
5216         data[1] = speed >> 8;
5217         data[2] = speed >> 16;
5218
5219         return (usbd_do_request(udev, NULL, &req, data));
5220 }
5221
5222 static usb_error_t
5223 uaudio20_set_speed(struct usb_device *udev, uint8_t iface_no,
5224     uint8_t clockid, uint32_t speed)
5225 {
5226         struct usb_device_request req;
5227         uint8_t data[4];
5228
5229         DPRINTFN(6, "ifaceno=%d clockid=%d speed=%u\n",
5230             iface_no, clockid, speed);
5231
5232         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5233         req.bRequest = UA20_CS_CUR;
5234         USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
5235         USETW2(req.wIndex, clockid, iface_no);
5236         USETW(req.wLength, 4);
5237         data[0] = speed;
5238         data[1] = speed >> 8;
5239         data[2] = speed >> 16;
5240         data[3] = speed >> 24;
5241
5242         return (usbd_do_request(udev, NULL, &req, data));
5243 }
5244
5245 static int
5246 uaudio_mixer_signext(uint8_t type, int val)
5247 {
5248         if (!MIX_UNSIGNED(type)) {
5249                 if (MIX_SIZE(type) == 2) {
5250                         val = (int16_t)val;
5251                 } else {
5252                         val = (int8_t)val;
5253                 }
5254         }
5255         return (val);
5256 }
5257
5258 static int
5259 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int32_t val)
5260 {
5261         if (mc->type == MIX_ON_OFF) {
5262                 val = (val != 0);
5263         } else if (mc->type == MIX_SELECTOR) {
5264                 if ((val < mc->minval) ||
5265                     (val > mc->maxval)) {
5266                         val = mc->minval;
5267                 }
5268         } else {
5269
5270                 /* compute actual volume */
5271                 val = (val * mc->mul) / 255;
5272
5273                 /* add lower offset */
5274                 val = val + mc->minval;
5275
5276                 /* make sure we don't write a value out of range */
5277                 if (val > mc->maxval)
5278                         val = mc->maxval;
5279                 else if (val < mc->minval)
5280                         val = mc->minval;
5281         }
5282
5283         DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n",
5284             mc->type, val, mc->minval, mc->maxval, val);
5285         return (val);
5286 }
5287
5288 static void
5289 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc,
5290     uint8_t chan, int32_t val)
5291 {
5292         val = uaudio_mixer_bsd2value(mc, val);
5293
5294         mc->update[chan / 8] |= (1 << (chan % 8));
5295         mc->wData[chan] = val;
5296
5297         /* start the transfer, if not already started */
5298
5299         usbd_transfer_start(sc->sc_mixer_xfer[0]);
5300 }
5301
5302 static void
5303 uaudio_mixer_init(struct uaudio_softc *sc)
5304 {
5305         struct uaudio_mixer_node *mc;
5306         int32_t i;
5307
5308         for (mc = sc->sc_mixer_root; mc;
5309             mc = mc->next) {
5310
5311                 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
5312                         /*
5313                          * Set device mask bits. See
5314                          * /usr/include/machine/soundcard.h
5315                          */
5316                         sc->sc_mix_info |= (1 << mc->ctl);
5317                 }
5318                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5319                     (mc->type == MIX_SELECTOR)) {
5320
5321                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5322                                 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES) {
5323                                         continue;
5324                                 }
5325                                 sc->sc_recsrc_info |= 1 << mc->slctrtype[i - 1];
5326                         }
5327                 }
5328         }
5329 }
5330
5331 int
5332 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5333 {
5334         DPRINTF("\n");
5335
5336         sc->sc_mixer_lock = mixer_get_lock(m);
5337         sc->sc_mixer_dev = m;
5338
5339         if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
5340             sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
5341             sc->sc_mixer_lock)) {
5342                 DPRINTFN(0, "could not allocate USB "
5343                     "transfer for audio mixer!\n");
5344                 return (ENOMEM);
5345         }
5346         if (!(sc->sc_mix_info & SOUND_MASK_VOLUME)) {
5347                 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM);
5348                 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE);
5349         }
5350         mix_setdevs(m, sc->sc_mix_info);
5351         mix_setrecdevs(m, sc->sc_recsrc_info);
5352         return (0);
5353 }
5354
5355 int
5356 uaudio_mixer_uninit_sub(struct uaudio_softc *sc)
5357 {
5358         DPRINTF("\n");
5359
5360         usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
5361
5362         sc->sc_mixer_lock = NULL;
5363
5364         return (0);
5365 }
5366
5367 void
5368 uaudio_mixer_set(struct uaudio_softc *sc, unsigned type,
5369     unsigned left, unsigned right)
5370 {
5371         struct uaudio_mixer_node *mc;
5372         int chan;
5373
5374         for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) {
5375
5376                 if (mc->ctl == type) {
5377                         for (chan = 0; chan < mc->nchan; chan++) {
5378                                 uaudio_mixer_ctl_set(sc, mc, chan,
5379                                     (int)((chan == 0 ? left : right) *
5380                                     255) / 100);
5381                         }
5382                 }
5383         }
5384 }
5385
5386 uint32_t
5387 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, uint32_t src)
5388 {
5389         struct uaudio_mixer_node *mc;
5390         uint32_t mask;
5391         uint32_t temp;
5392         int32_t i;
5393
5394         for (mc = sc->sc_mixer_root; mc;
5395             mc = mc->next) {
5396
5397                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5398                     (mc->type == MIX_SELECTOR)) {
5399
5400                         /* compute selector mask */
5401
5402                         mask = 0;
5403                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5404                                 mask |= (1 << mc->slctrtype[i - 1]);
5405                         }
5406
5407                         temp = mask & src;
5408                         if (temp == 0) {
5409                                 continue;
5410                         }
5411                         /* find the first set bit */
5412                         temp = (-temp) & temp;
5413
5414                         /* update "src" */
5415                         src &= ~mask;
5416                         src |= temp;
5417
5418                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5419                                 if (temp != (1 << mc->slctrtype[i - 1])) {
5420                                         continue;
5421                                 }
5422                                 uaudio_mixer_ctl_set(sc, mc, 0, i);
5423                                 break;
5424                         }
5425                 }
5426         }
5427         return (src);
5428 }
5429
5430 /*========================================================================*
5431  * MIDI support routines
5432  *========================================================================*/
5433
5434 static void
5435 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
5436 {
5437         struct umidi_chan *chan = usbd_xfer_softc(xfer);
5438         struct umidi_sub_chan *sub;
5439         struct usb_page_cache *pc;
5440         uint8_t buf[4];
5441         uint8_t cmd_len;
5442         uint8_t cn;
5443         uint16_t pos;
5444         int actlen;
5445
5446         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
5447
5448         switch (USB_GET_STATE(xfer)) {
5449         case USB_ST_TRANSFERRED:
5450
5451                 DPRINTF("actlen=%d bytes\n", actlen);
5452
5453                 pos = 0;
5454                 pc = usbd_xfer_get_frame(xfer, 0);
5455
5456                 while (actlen >= 4) {
5457
5458                         /* copy out the MIDI data */
5459                         usbd_copy_out(pc, pos, buf, 4);
5460                         /* command length */
5461                         cmd_len = umidi_cmd_to_len[buf[0] & 0xF];
5462                         /* cable number */
5463                         cn = buf[0] >> 4;
5464                         /*
5465                          * Lookup sub-channel. The index is range
5466                          * checked below.
5467                          */
5468                         sub = &chan->sub[cn];
5469
5470                         if ((cmd_len != 0) && (cn < chan->max_emb_jack) &&
5471                             (sub->read_open != 0)) {
5472
5473                                 /* Send data to the application */
5474                                 usb_fifo_put_data_linear(
5475                                     sub->fifo.fp[USB_FIFO_RX],
5476                                     buf + 1, cmd_len, 1);
5477                         }
5478                         actlen -= 4;
5479                         pos += 4;
5480                 }
5481
5482         case USB_ST_SETUP:
5483                 DPRINTF("start\n");
5484 tr_setup:
5485                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
5486                 usbd_transfer_submit(xfer);
5487                 break;
5488
5489         default:
5490                 DPRINTF("error=%s\n", usbd_errstr(error));
5491
5492                 if (error != USB_ERR_CANCELLED) {
5493                         /* try to clear stall first */
5494                         usbd_xfer_set_stall(xfer);
5495                         goto tr_setup;
5496                 }
5497                 break;
5498         }
5499 }
5500
5501 /*
5502  * The following statemachine, that converts MIDI commands to
5503  * USB MIDI packets, derives from Linux's usbmidi.c, which
5504  * was written by "Clemens Ladisch":
5505  *
5506  * Returns:
5507  *    0: No command
5508  * Else: Command is complete
5509  */
5510 static uint8_t
5511 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b)
5512 {
5513         uint8_t p0 = (cn << 4);
5514
5515         if (b >= 0xf8) {
5516                 sub->temp_0[0] = p0 | 0x0f;
5517                 sub->temp_0[1] = b;
5518                 sub->temp_0[2] = 0;
5519                 sub->temp_0[3] = 0;
5520                 sub->temp_cmd = sub->temp_0;
5521                 return (1);
5522
5523         } else if (b >= 0xf0) {
5524                 switch (b) {
5525                 case 0xf0:              /* system exclusive begin */
5526                         sub->temp_1[1] = b;
5527                         sub->state = UMIDI_ST_SYSEX_1;
5528                         break;
5529                 case 0xf1:              /* MIDI time code */
5530                 case 0xf3:              /* song select */
5531                         sub->temp_1[1] = b;
5532                         sub->state = UMIDI_ST_1PARAM;
5533                         break;
5534                 case 0xf2:              /* song position pointer */
5535                         sub->temp_1[1] = b;
5536                         sub->state = UMIDI_ST_2PARAM_1;
5537                         break;
5538                 case 0xf4:              /* unknown */
5539                 case 0xf5:              /* unknown */
5540                         sub->state = UMIDI_ST_UNKNOWN;
5541                         break;
5542                 case 0xf6:              /* tune request */
5543                         sub->temp_1[0] = p0 | 0x05;
5544                         sub->temp_1[1] = 0xf6;
5545                         sub->temp_1[2] = 0;
5546                         sub->temp_1[3] = 0;
5547                         sub->temp_cmd = sub->temp_1;
5548                         sub->state = UMIDI_ST_UNKNOWN;
5549                         return (1);
5550
5551                 case 0xf7:              /* system exclusive end */
5552                         switch (sub->state) {
5553                         case UMIDI_ST_SYSEX_0:
5554                                 sub->temp_1[0] = p0 | 0x05;
5555                                 sub->temp_1[1] = 0xf7;
5556                                 sub->temp_1[2] = 0;
5557                                 sub->temp_1[3] = 0;
5558                                 sub->temp_cmd = sub->temp_1;
5559                                 sub->state = UMIDI_ST_UNKNOWN;
5560                                 return (1);
5561                         case UMIDI_ST_SYSEX_1:
5562                                 sub->temp_1[0] = p0 | 0x06;
5563                                 sub->temp_1[2] = 0xf7;
5564                                 sub->temp_1[3] = 0;
5565                                 sub->temp_cmd = sub->temp_1;
5566                                 sub->state = UMIDI_ST_UNKNOWN;
5567                                 return (1);
5568                         case UMIDI_ST_SYSEX_2:
5569                                 sub->temp_1[0] = p0 | 0x07;
5570                                 sub->temp_1[3] = 0xf7;
5571                                 sub->temp_cmd = sub->temp_1;
5572                                 sub->state = UMIDI_ST_UNKNOWN;
5573                                 return (1);
5574                         }
5575                         sub->state = UMIDI_ST_UNKNOWN;
5576                         break;
5577                 }
5578         } else if (b >= 0x80) {
5579                 sub->temp_1[1] = b;
5580                 if ((b >= 0xc0) && (b <= 0xdf)) {
5581                         sub->state = UMIDI_ST_1PARAM;
5582                 } else {
5583                         sub->state = UMIDI_ST_2PARAM_1;
5584                 }
5585         } else {                        /* b < 0x80 */
5586                 switch (sub->state) {
5587                 case UMIDI_ST_1PARAM:
5588                         if (sub->temp_1[1] < 0xf0) {
5589                                 p0 |= sub->temp_1[1] >> 4;
5590                         } else {
5591                                 p0 |= 0x02;
5592                                 sub->state = UMIDI_ST_UNKNOWN;
5593                         }
5594                         sub->temp_1[0] = p0;
5595                         sub->temp_1[2] = b;
5596                         sub->temp_1[3] = 0;
5597                         sub->temp_cmd = sub->temp_1;
5598                         return (1);
5599                 case UMIDI_ST_2PARAM_1:
5600                         sub->temp_1[2] = b;
5601                         sub->state = UMIDI_ST_2PARAM_2;
5602                         break;
5603                 case UMIDI_ST_2PARAM_2:
5604                         if (sub->temp_1[1] < 0xf0) {
5605                                 p0 |= sub->temp_1[1] >> 4;
5606                                 sub->state = UMIDI_ST_2PARAM_1;
5607                         } else {
5608                                 p0 |= 0x03;
5609                                 sub->state = UMIDI_ST_UNKNOWN;
5610                         }
5611                         sub->temp_1[0] = p0;
5612                         sub->temp_1[3] = b;
5613                         sub->temp_cmd = sub->temp_1;
5614                         return (1);
5615                 case UMIDI_ST_SYSEX_0:
5616                         sub->temp_1[1] = b;
5617                         sub->state = UMIDI_ST_SYSEX_1;
5618                         break;
5619                 case UMIDI_ST_SYSEX_1:
5620                         sub->temp_1[2] = b;
5621                         sub->state = UMIDI_ST_SYSEX_2;
5622                         break;
5623                 case UMIDI_ST_SYSEX_2:
5624                         sub->temp_1[0] = p0 | 0x04;
5625                         sub->temp_1[3] = b;
5626                         sub->temp_cmd = sub->temp_1;
5627                         sub->state = UMIDI_ST_SYSEX_0;
5628                         return (1);
5629                 default:
5630                         break;
5631                 }
5632         }
5633         return (0);
5634 }
5635
5636 static void
5637 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
5638 {
5639         struct umidi_chan *chan = usbd_xfer_softc(xfer);
5640         struct umidi_sub_chan *sub;
5641         struct usb_page_cache *pc;
5642         uint32_t actlen;
5643         uint16_t nframes;
5644         uint8_t buf;
5645         uint8_t start_cable;
5646         uint8_t tr_any;
5647         int len;
5648
5649         usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
5650
5651         /*
5652          * NOTE: Some MIDI devices only accept 4 bytes of data per
5653          * short terminated USB transfer.
5654          */
5655         switch (USB_GET_STATE(xfer)) {
5656         case USB_ST_TRANSFERRED:
5657                 DPRINTF("actlen=%d bytes\n", len);
5658
5659         case USB_ST_SETUP:
5660 tr_setup:
5661                 DPRINTF("start\n");
5662
5663                 nframes = 0;    /* reset */
5664                 start_cable = chan->curr_cable;
5665                 tr_any = 0;
5666                 pc = usbd_xfer_get_frame(xfer, 0);
5667
5668                 while (1) {
5669
5670                         /* round robin de-queueing */
5671
5672                         sub = &chan->sub[chan->curr_cable];
5673
5674                         if (sub->write_open) {
5675                                 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX],
5676                                     &buf, 1, &actlen, 0);
5677                         } else {
5678                                 actlen = 0;
5679                         }
5680
5681                         if (actlen) {
5682
5683                                 tr_any = 1;
5684
5685                                 DPRINTF("byte=0x%02x from FIFO %u\n", buf,
5686                                     (unsigned int)chan->curr_cable);
5687
5688                                 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) {
5689
5690                                         DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n",
5691                                             sub->temp_cmd[0], sub->temp_cmd[1],
5692                                             sub->temp_cmd[2], sub->temp_cmd[3]);
5693
5694                                         usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4);
5695
5696                                         nframes++;
5697
5698                                         if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0))
5699                                                 break;
5700                                 } else {
5701                                         continue;
5702                                 }
5703                         }
5704
5705                         chan->curr_cable++;
5706                         if (chan->curr_cable >= chan->max_emb_jack)
5707                                 chan->curr_cable = 0;
5708
5709                         if (chan->curr_cable == start_cable) {
5710                                 if (tr_any == 0)
5711                                         break;
5712                                 tr_any = 0;
5713                         }
5714                 }
5715
5716                 if (nframes != 0) {
5717                         DPRINTF("Transferring %d frames\n", (int)nframes);
5718                         usbd_xfer_set_frame_len(xfer, 0, 4 * nframes);
5719                         usbd_transfer_submit(xfer);
5720                 }
5721                 break;
5722
5723         default:                        /* Error */
5724
5725                 DPRINTF("error=%s\n", usbd_errstr(error));
5726
5727                 if (error != USB_ERR_CANCELLED) {
5728                         /* try to clear stall first */
5729                         usbd_xfer_set_stall(xfer);
5730                         goto tr_setup;
5731                 }
5732                 break;
5733         }
5734 }
5735
5736 static struct umidi_sub_chan *
5737 umidi_sub_by_fifo(struct usb_fifo *fifo)
5738 {
5739         struct umidi_chan *chan = usb_fifo_softc(fifo);
5740         struct umidi_sub_chan *sub;
5741         uint32_t n;
5742
5743         for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) {
5744                 sub = &chan->sub[n];
5745                 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) ||
5746                     (sub->fifo.fp[USB_FIFO_TX] == fifo)) {
5747                         return (sub);
5748                 }
5749         }
5750
5751         panic("%s:%d cannot find usb_fifo!\n",
5752             __FILE__, __LINE__);
5753
5754         return (NULL);
5755 }
5756
5757 static void
5758 umidi_start_read(struct usb_fifo *fifo)
5759 {
5760         struct umidi_chan *chan = usb_fifo_softc(fifo);
5761
5762         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
5763 }
5764
5765 static void
5766 umidi_stop_read(struct usb_fifo *fifo)
5767 {
5768         struct umidi_chan *chan = usb_fifo_softc(fifo);
5769         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5770
5771         DPRINTF("\n");
5772
5773         sub->read_open = 0;
5774
5775         if (--(chan->read_open_refcount) == 0) {
5776                 /*
5777                  * XXX don't stop the read transfer here, hence that causes
5778                  * problems with some MIDI adapters
5779                  */
5780                 DPRINTF("(stopping read transfer)\n");
5781         }
5782 }
5783
5784 static void
5785 umidi_start_write(struct usb_fifo *fifo)
5786 {
5787         struct umidi_chan *chan = usb_fifo_softc(fifo);
5788
5789         if (chan->xfer[UMIDI_TX_TRANSFER] == NULL) {
5790                 uint8_t buf[1];
5791                 int actlen;
5792                 do {
5793                         /* dump data */
5794                         usb_fifo_get_data_linear(fifo, buf, 1, &actlen, 0);
5795                 } while (actlen > 0);
5796         } else {
5797                 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]);
5798         }
5799 }
5800
5801 static void
5802 umidi_stop_write(struct usb_fifo *fifo)
5803 {
5804         struct umidi_chan *chan = usb_fifo_softc(fifo);
5805         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5806
5807         DPRINTF("\n");
5808
5809         sub->write_open = 0;
5810
5811         if (--(chan->write_open_refcount) == 0) {
5812                 DPRINTF("(stopping write transfer)\n");
5813                 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]);
5814         }
5815 }
5816
5817 static int
5818 umidi_open(struct usb_fifo *fifo, int fflags)
5819 {
5820         struct umidi_chan *chan = usb_fifo_softc(fifo);
5821         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5822
5823         if (fflags & FREAD) {
5824                 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
5825                         return (ENOMEM);
5826                 }
5827                 mtx_lock(&chan->mtx);
5828                 chan->read_open_refcount++;
5829                 sub->read_open = 1;
5830                 mtx_unlock(&chan->mtx);
5831         }
5832         if (fflags & FWRITE) {
5833                 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
5834                         return (ENOMEM);
5835                 }
5836                 /* clear stall first */
5837                 mtx_lock(&chan->mtx);
5838                 chan->write_open_refcount++;
5839                 sub->write_open = 1;
5840
5841                 /* reset */
5842                 sub->state = UMIDI_ST_UNKNOWN;
5843                 mtx_unlock(&chan->mtx);
5844         }
5845         return (0);                     /* success */
5846 }
5847
5848 static void
5849 umidi_close(struct usb_fifo *fifo, int fflags)
5850 {
5851         if (fflags & FREAD) {
5852                 usb_fifo_free_buffer(fifo);
5853         }
5854         if (fflags & FWRITE) {
5855                 usb_fifo_free_buffer(fifo);
5856         }
5857 }
5858
5859
5860 static int
5861 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data,
5862     int fflags)
5863 {
5864         return (ENODEV);
5865 }
5866
5867 static void
5868 umidi_init(device_t dev)
5869 {
5870         struct uaudio_softc *sc = device_get_softc(dev);
5871         struct umidi_chan *chan = &sc->sc_midi_chan;
5872
5873         mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE);
5874 }
5875
5876 static struct usb_fifo_methods umidi_fifo_methods = {
5877         .f_start_read = &umidi_start_read,
5878         .f_start_write = &umidi_start_write,
5879         .f_stop_read = &umidi_stop_read,
5880         .f_stop_write = &umidi_stop_write,
5881         .f_open = &umidi_open,
5882         .f_close = &umidi_close,
5883         .f_ioctl = &umidi_ioctl,
5884         .basename[0] = "umidi",
5885 };
5886
5887 static int
5888 umidi_probe(device_t dev)
5889 {
5890         struct uaudio_softc *sc = device_get_softc(dev);
5891         struct usb_attach_arg *uaa = device_get_ivars(dev);
5892         struct umidi_chan *chan = &sc->sc_midi_chan;
5893         struct umidi_sub_chan *sub;
5894         int unit = device_get_unit(dev);
5895         int error;
5896         uint32_t n;
5897
5898         if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI))
5899                 chan->single_command = 1;
5900
5901         if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index,
5902             chan->iface_alt_index)) {
5903                 DPRINTF("setting of alternate index failed!\n");
5904                 goto detach;
5905         }
5906         usbd_set_parent_iface(sc->sc_udev, chan->iface_index,
5907             sc->sc_mixer_iface_index);
5908
5909         error = usbd_transfer_setup(uaa->device, &chan->iface_index,
5910             chan->xfer, umidi_config, UMIDI_N_TRANSFER,
5911             chan, &chan->mtx);
5912         if (error) {
5913                 DPRINTF("error=%s\n", usbd_errstr(error));
5914                 goto detach;
5915         }
5916         if (chan->xfer[UMIDI_TX_TRANSFER] == NULL &&
5917             chan->xfer[UMIDI_RX_TRANSFER] == NULL) {
5918                 DPRINTF("no BULK or INTERRUPT MIDI endpoint(s) found\n");
5919                 goto detach;
5920         }
5921
5922         /*
5923          * Some USB MIDI device makers couldn't resist using
5924          * wMaxPacketSize = 4 for RX and TX BULK endpoints, although
5925          * that size is an unsupported value for FULL speed BULK
5926          * endpoints. The same applies to some HIGH speed MIDI devices
5927          * which are using a wMaxPacketSize different from 512 bytes.
5928          *
5929          * Refer to section 5.8.3 in USB 2.0 PDF: Cite: "All Host
5930          * Controllers are required to have support for 8-, 16-, 32-,
5931          * and 64-byte maximum packet sizes for full-speed bulk
5932          * endpoints and 512 bytes for high-speed bulk endpoints."
5933          */
5934         if (chan->xfer[UMIDI_TX_TRANSFER] != NULL &&
5935             usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER]))
5936                 chan->single_command = 1;
5937
5938         if (chan->single_command != 0)
5939                 device_printf(dev, "Single command MIDI quirk enabled\n");
5940
5941         if ((chan->max_emb_jack == 0) ||
5942             (chan->max_emb_jack > UMIDI_EMB_JACK_MAX)) {
5943                 chan->max_emb_jack = UMIDI_EMB_JACK_MAX;
5944         }
5945
5946         for (n = 0; n < chan->max_emb_jack; n++) {
5947
5948                 sub = &chan->sub[n];
5949
5950                 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
5951                     &umidi_fifo_methods, &sub->fifo, unit, n,
5952                     chan->iface_index,
5953                     UID_ROOT, GID_OPERATOR, 0644);
5954                 if (error) {
5955                         goto detach;
5956                 }
5957         }
5958
5959         mtx_lock(&chan->mtx);
5960
5961         /*
5962          * NOTE: At least one device will not work properly unless the
5963          * BULK IN pipe is open all the time. This might have to do
5964          * about that the internal queues of the device overflow if we
5965          * don't read them regularly.
5966          */
5967         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
5968
5969         mtx_unlock(&chan->mtx);
5970
5971         return (0);                     /* success */
5972
5973 detach:
5974         return (ENXIO);                 /* failure */
5975 }
5976
5977 static int
5978 umidi_detach(device_t dev)
5979 {
5980         struct uaudio_softc *sc = device_get_softc(dev);
5981         struct umidi_chan *chan = &sc->sc_midi_chan;
5982         uint32_t n;
5983
5984         for (n = 0; n < UMIDI_EMB_JACK_MAX; n++)
5985                 usb_fifo_detach(&chan->sub[n].fifo);
5986
5987         mtx_lock(&chan->mtx);
5988
5989         usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]);
5990
5991         mtx_unlock(&chan->mtx);
5992
5993         usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
5994
5995         mtx_destroy(&chan->mtx);
5996
5997         return (0);
5998 }
5999
6000 static void
6001 uaudio_hid_rx_callback(struct usb_xfer *xfer, usb_error_t error)
6002 {
6003         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
6004         const uint8_t *buffer = usbd_xfer_get_frame_buffer(xfer, 0);
6005         struct snd_mixer *m;
6006         uint8_t id;
6007         int actlen;
6008
6009         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
6010
6011         switch (USB_GET_STATE(xfer)) {
6012         case USB_ST_TRANSFERRED:
6013                 DPRINTF("actlen=%d\n", actlen);
6014
6015                 if (actlen != 0 &&
6016                     (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) {
6017                         id = *buffer;
6018                         buffer++;
6019                         actlen--;
6020                 } else {
6021                         id = 0;
6022                 }
6023
6024                 m = sc->sc_mixer_dev;
6025
6026                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) &&
6027                     (sc->sc_hid.mute_id == id) &&
6028                     hid_get_data(buffer, actlen,
6029                     &sc->sc_hid.mute_loc)) {
6030
6031                         DPRINTF("Mute toggle\n");
6032
6033                         mixer_hwvol_mute_locked(m);
6034                 }
6035
6036                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) &&
6037                     (sc->sc_hid.volume_up_id == id) &&
6038                     hid_get_data(buffer, actlen,
6039                     &sc->sc_hid.volume_up_loc)) {
6040
6041                         DPRINTF("Volume Up\n");
6042
6043                         mixer_hwvol_step_locked(m, 1, 1);
6044                 }
6045
6046                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) &&
6047                     (sc->sc_hid.volume_down_id == id) &&
6048                     hid_get_data(buffer, actlen,
6049                     &sc->sc_hid.volume_down_loc)) {
6050
6051                         DPRINTF("Volume Down\n");
6052
6053                         mixer_hwvol_step_locked(m, -1, -1);
6054                 }
6055
6056         case USB_ST_SETUP:
6057 tr_setup:
6058                 /* check if we can put more data into the FIFO */
6059                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
6060                 usbd_transfer_submit(xfer);
6061                 break;
6062
6063         default:                        /* Error */
6064
6065                 DPRINTF("error=%s\n", usbd_errstr(error));
6066
6067                 if (error != USB_ERR_CANCELLED) {
6068                         /* try to clear stall first */
6069                         usbd_xfer_set_stall(xfer);
6070                         goto tr_setup;
6071                 }
6072                 break;
6073         }
6074 }
6075
6076 static int
6077 uaudio_hid_probe(struct uaudio_softc *sc,
6078     struct usb_attach_arg *uaa)
6079 {
6080         void *d_ptr;
6081         uint32_t flags;
6082         uint16_t d_len;
6083         uint8_t id;
6084         int error;
6085
6086         if (!(sc->sc_hid.flags & UAUDIO_HID_VALID))
6087                 return (-1);
6088
6089         if (sc->sc_mixer_lock == NULL)
6090                 return (-1);
6091
6092         /* Get HID descriptor */
6093         error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
6094             &d_len, M_TEMP, sc->sc_hid.iface_index);
6095
6096         if (error) {
6097                 DPRINTF("error reading report description\n");
6098                 return (-1);
6099         }
6100
6101         /* check if there is an ID byte */
6102         hid_report_size(d_ptr, d_len, hid_input, &id);
6103
6104         if (id != 0)
6105                 sc->sc_hid.flags |= UAUDIO_HID_HAS_ID;
6106
6107         if (hid_locate(d_ptr, d_len,
6108             HID_USAGE2(HUP_CONSUMER, 0xE9 /* Volume Increment */),
6109             hid_input, 0, &sc->sc_hid.volume_up_loc, &flags,
6110             &sc->sc_hid.volume_up_id)) {
6111                 if (flags & HIO_VARIABLE)
6112                         sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP;
6113                 DPRINTFN(1, "Found Volume Up key\n");
6114         }
6115
6116         if (hid_locate(d_ptr, d_len,
6117             HID_USAGE2(HUP_CONSUMER, 0xEA /* Volume Decrement */),
6118             hid_input, 0, &sc->sc_hid.volume_down_loc, &flags,
6119             &sc->sc_hid.volume_down_id)) {
6120                 if (flags & HIO_VARIABLE)
6121                         sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN;
6122                 DPRINTFN(1, "Found Volume Down key\n");
6123         }
6124
6125         if (hid_locate(d_ptr, d_len,
6126             HID_USAGE2(HUP_CONSUMER, 0xE2 /* Mute */),
6127             hid_input, 0, &sc->sc_hid.mute_loc, &flags,
6128             &sc->sc_hid.mute_id)) {
6129                 if (flags & HIO_VARIABLE)
6130                         sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE;
6131                 DPRINTFN(1, "Found Mute key\n");
6132         }
6133
6134         free(d_ptr, M_TEMP);
6135
6136         if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP |
6137             UAUDIO_HID_HAS_VOLUME_DOWN |
6138             UAUDIO_HID_HAS_MUTE))) {
6139                 DPRINTFN(1, "Did not find any volume related keys\n");
6140                 return (-1);
6141         }
6142
6143         /* prevent the uhid driver from attaching */
6144         usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index,
6145             sc->sc_mixer_iface_index);
6146
6147         /* allocate USB transfers */
6148         error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index,
6149             sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER,
6150             sc, sc->sc_mixer_lock);
6151         if (error) {
6152                 DPRINTF("error=%s\n", usbd_errstr(error));
6153                 return (-1);
6154         }
6155         return (0);
6156 }
6157
6158 static void
6159 uaudio_hid_detach(struct uaudio_softc *sc)
6160 {
6161         usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER);
6162 }
6163
6164 DRIVER_MODULE_ORDERED(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0, SI_ORDER_ANY);
6165 MODULE_DEPEND(uaudio, usb, 1, 1, 1);
6166 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
6167 MODULE_VERSION(uaudio, 1);