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