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