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