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