sys/dev/sound/usb/uaudio.c

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