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 24
 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
1669                         dwFormat = UGETDW(asid.v2->bmFormats);
1670                         bChannels = asid.v2->bNrChannels;
1671                         bBitResolution = asf1d.v2->bSubslotSize * 8;
1672
1673                         if ((bChannels != channels) ||
1674                             (bBitResolution != bit_resolution)) {
1675                                 DPRINTF("Wrong number of channels\n");
1676                                 goto next_ep;
1677                         }
1678
1679                         for (p_fmt = uaudio20_formats;
1680                             p_fmt->wFormat != 0; p_fmt++) {
1681                                 if ((p_fmt->wFormat & dwFormat) &&
1682                                     (p_fmt->bPrecision == bBitResolution))
1683                                         break;
1684                         }
1685
1686                         if (p_fmt->wFormat == 0) {
1687                                 DPRINTF("Unsupported audio format\n");
1688                                 goto next_ep;
1689                         }
1690
1691                         for (x = 0; x != 256; x++) {
1692                                 if (ep_dir == UE_DIR_OUT) {
1693                                         if (!(sc->sc_mixer_clocks.bit_output[x / 8] &
1694                                             (1 << (x % 8)))) {
1695                                                 continue;
1696                                         }
1697                                 } else {
1698                                         if (!(sc->sc_mixer_clocks.bit_input[x / 8] &
1699                                             (1 << (x % 8)))) {
1700                                                 continue;
1701                                         }
1702                                 }
1703
1704                                 DPRINTF("Checking clock ID=%d\n", x);
1705
1706                                 if (uaudio20_check_rate(udev,
1707                                     sc->sc_mixer_iface_no, x, rate)) {
1708                                         DPRINTF("Unsupported sampling "
1709                                             "rate, id=%d\n", x);
1710                                         goto next_ep;
1711                                 }
1712                         }
1713                 } else {
1714                         uint16_t wFormat;
1715
1716                         wFormat = UGETW(asid.v1->wFormatTag);
1717                         bChannels = UAUDIO_MAX_CHAN(asf1d.v1->bNrChannels);
1718                         bBitResolution = asf1d.v1->bSubFrameSize * 8;
1719
1720                         if (asf1d.v1->bSamFreqType == 0) {
1721                                 DPRINTFN(16, "Sample rate: %d-%dHz\n",
1722                                     UA_SAMP_LO(asf1d.v1),
1723                                     UA_SAMP_HI(asf1d.v1));
1724
1725                                 if ((rate >= UA_SAMP_LO(asf1d.v1)) &&
1726                                     (rate <= UA_SAMP_HI(asf1d.v1)))
1727                                         goto found_rate;
1728                         } else {
1729
1730                                 for (x = 0; x < asf1d.v1->bSamFreqType; x++) {
1731                                         DPRINTFN(16, "Sample rate = %dHz\n",
1732                                             UA_GETSAMP(asf1d.v1, x));
1733
1734                                         if (rate == UA_GETSAMP(asf1d.v1, x))
1735                                                 goto found_rate;
1736                                 }
1737                         }
1738                         goto next_ep;
1739
1740         found_rate:
1741                         for (p_fmt = uaudio10_formats;
1742                             p_fmt->wFormat != 0; p_fmt++) {
1743                                 if ((p_fmt->wFormat == wFormat) &&
1744                                     (p_fmt->bPrecision == bBitResolution))
1745                                         break;
1746                         }
1747                         if (p_fmt->wFormat == 0) {
1748                                 DPRINTF("Unsupported audio format\n");
1749                                 goto next_ep;
1750                         }
1751
1752                         if ((bChannels != channels) ||
1753                             (bBitResolution != bit_resolution)) {
1754                                 DPRINTF("Wrong number of channels\n");
1755                                 goto next_ep;
1756                         }
1757                 }
1758
1759                 chan = (ep_dir == UE_DIR_IN) ?
1760                     &sc->sc_rec_chan : &sc->sc_play_chan;
1761
1762                 if (usbd_get_iface(udev, curidx) == NULL) {
1763                         DPRINTF("Interface is not valid\n");
1764                         goto next_ep;
1765                 }
1766                 if (chan->num_alt == CHAN_MAX_ALT) {
1767                         DPRINTF("Too many alternate settings\n");
1768                         goto next_ep;
1769                 }
1770                 chan->set_alt = 0;
1771                 chan->cur_alt = CHAN_MAX_ALT;
1772
1773                 chan_alt = &chan->usb_alt[chan->num_alt++];
1774
1775 #ifdef USB_DEBUG
1776                 uaudio_chan_dump_ep_desc(ed1);
1777 #endif
1778                 DPRINTF("Sample rate = %dHz, channels = %d, "
1779                     "bits = %d, format = %s\n", rate, channels,
1780                     bit_resolution, p_fmt->description);
1781
1782                 chan_alt->sample_rate = rate;
1783                 chan_alt->p_asf1d = asf1d;
1784                 chan_alt->p_ed1 = ed1;
1785                 chan_alt->p_fmt = p_fmt;
1786                 chan_alt->p_sed = sed;
1787                 chan_alt->iface_index = curidx;
1788                 chan_alt->iface_alt_index = alt_index;
1789
1790                 usbd_set_parent_iface(sc->sc_udev, curidx,
1791                     sc->sc_mixer_iface_index);
1792
1793                 if (ep_dir == UE_DIR_IN)
1794                         chan_alt->usb_cfg = uaudio_cfg_record;
1795                 else
1796                         chan_alt->usb_cfg = uaudio_cfg_play;
1797
1798                 chan_alt->sample_size = (UAUDIO_MAX_CHAN(channels) *
1799                     p_fmt->bPrecision) / 8;
1800                 chan_alt->channels = channels;
1801
1802                 if (ep_dir == UE_DIR_IN &&
1803                     usbd_get_speed(udev) == USB_SPEED_FULL) {
1804                         uaudio_record_fix_fs(ed1,
1805                             chan_alt->sample_size * (rate / 1000),
1806                             chan_alt->sample_size * (rate / 4000));
1807                 }
1808
1809                 /* setup play/record format */
1810
1811                 format = chan_alt->p_fmt->freebsd_fmt;
1812
1813                 switch (chan_alt->channels) {
1814                 case 2:
1815                         /* stereo */
1816                         format = SND_FORMAT(format, 2, 0);
1817                         break;
1818                 case 1:
1819                         /* mono */
1820                         format = SND_FORMAT(format, 1, 0);
1821                         break;
1822                 default:
1823                         /* surround and more */
1824                         format = feeder_matrix_default_format(
1825                             SND_FORMAT(format, chan_alt->channels, 0));
1826                         break;
1827                 }
1828
1829                 /* check if format is not supported */
1830                 if (format == 0) {
1831                         DPRINTF("The selected audio format is not supported\n");
1832                         chan->num_alt--;
1833                         goto next_ep;
1834                 }
1835                 if (chan->num_alt > 1) {
1836                         /* we only accumulate one format at different sample rates */
1837                         if (chan->pcm_format[0] != format) {
1838                                 DPRINTF("Multiple formats is not supported\n");
1839                                 chan->num_alt--;
1840                                 goto next_ep;
1841                         }
1842                         /* ignore if duplicate sample rate entry */
1843                         if (rate == chan->usb_alt[chan->num_alt - 2].sample_rate) {
1844                                 DPRINTF("Duplicate sample rate detected\n");
1845                                 chan->num_alt--;
1846                                 goto next_ep;
1847                         }
1848                 }
1849                 chan->pcm_cap.fmtlist = chan->pcm_format;
1850                 chan->pcm_cap.fmtlist[0] = format;
1851
1852                 if (rate < chan->pcm_cap.minspeed || chan->pcm_cap.minspeed == 0)
1853                         chan->pcm_cap.minspeed = rate;
1854                 if (rate > chan->pcm_cap.maxspeed || chan->pcm_cap.maxspeed == 0)
1855                         chan->pcm_cap.maxspeed = rate;
1856
1857                 if (sc->sc_sndstat_valid != 0) {
1858                         sbuf_printf(&sc->sc_sndstat, "\n\t"
1859                             "mode %d.%d:(%s) %dch, %dbit, %s, %dHz",
1860                             curidx, alt_index,
1861                             (ep_dir == UE_DIR_IN) ? "input" : "output",
1862                                     channels, p_fmt->bPrecision,
1863                                     p_fmt->description, rate);
1864                 }
1865
1866         next_ep:
1867                 sed.v1 = NULL;
1868                 ed1 = NULL;
1869         }
1870 }
1871
1872 /* This structure defines all the supported rates. */
1873
1874 static const uint32_t uaudio_rate_list[CHAN_MAX_ALT] = {
1875         384000,
1876         352800,
1877         192000,
1878         176400,
1879         96000,
1880         88200,
1881         88000,
1882         80000,
1883         72000,
1884         64000,
1885         56000,
1886         48000,
1887         44100,
1888         40000,
1889         32000,
1890         24000,
1891         22050,
1892         16000,
1893         11025,
1894         8000,
1895         0
1896 };
1897
1898 static void
1899 uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev)
1900 {
1901         uint32_t rate = uaudio_default_rate;
1902         uint8_t z;
1903         uint8_t bits = uaudio_default_bits;
1904         uint8_t y;
1905         uint8_t channels = uaudio_default_channels;
1906         uint8_t x;
1907
1908         bits -= (bits % 8);
1909         if ((bits == 0) || (bits > 32)) {
1910                 /* set a valid value */
1911                 bits = 32;
1912         }
1913         if (channels == 0) {
1914                 switch (usbd_get_speed(udev)) {
1915                 case USB_SPEED_LOW:
1916                 case USB_SPEED_FULL:
1917                         /*
1918                          * Due to high bandwidth usage and problems
1919                          * with HIGH-speed split transactions we
1920                          * disable surround setups on FULL-speed USB
1921                          * by default
1922                          */
1923                         channels = 4;
1924                         break;
1925                 default:
1926                         channels = 16;
1927                         break;
1928                 }
1929         } else if (channels > 16) {
1930                 channels = 16;
1931         }
1932         if (sbuf_new(&sc->sc_sndstat, NULL, 4096, SBUF_AUTOEXTEND)) {
1933                 sc->sc_sndstat_valid = 1;
1934         }
1935         /* try to search for a valid config */
1936
1937         for (x = channels; x; x--) {
1938                 for (y = bits; y; y -= 8) {
1939
1940                         /* try user defined rate, if any */
1941                         if (rate != 0)
1942                                 uaudio_chan_fill_info_sub(sc, udev, rate, x, y);
1943
1944                         /* try find a matching rate, if any */
1945                         for (z = 0; uaudio_rate_list[z]; z++)
1946                                 uaudio_chan_fill_info_sub(sc, udev, uaudio_rate_list[z], x, y);
1947                 }
1948         }
1949         if (sc->sc_sndstat_valid)
1950                 sbuf_finish(&sc->sc_sndstat);
1951 }
1952
1953 static void
1954 uaudio_chan_play_sync_callback(struct usb_xfer *xfer, usb_error_t error)
1955 {
1956         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
1957         struct usb_page_cache *pc;
1958         uint64_t sample_rate = ch->usb_alt[ch->cur_alt].sample_rate;
1959         uint8_t buf[4];
1960         uint64_t temp;
1961         int len;
1962         int actlen;
1963         int nframes;
1964
1965         usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
1966
1967         switch (USB_GET_STATE(xfer)) {
1968         case USB_ST_TRANSFERRED:
1969
1970                 DPRINTFN(6, "transferred %d bytes\n", actlen);
1971
1972                 if (nframes == 0)
1973                         break;
1974                 len = usbd_xfer_frame_len(xfer, 0);
1975                 if (len == 0)
1976                         break;
1977                 if (len > sizeof(buf))
1978                         len = sizeof(buf);
1979
1980                 memset(buf, 0, sizeof(buf));
1981
1982                 pc = usbd_xfer_get_frame(xfer, 0);
1983                 usbd_copy_out(pc, 0, buf, len);
1984
1985                 temp = UGETDW(buf);
1986
1987                 DPRINTF("Value = 0x%08x\n", (int)temp);
1988
1989                 /* auto-detect SYNC format */
1990
1991                 if (len == 4)
1992                         temp &= 0x0fffffff;
1993
1994                 /* check for no data */
1995
1996                 if (temp == 0)
1997                         break;
1998
1999                 /* correctly scale value */
2000
2001                 temp = (temp * 125ULL) - 64;
2002
2003                 /* auto adjust */
2004
2005                 while (temp < (sample_rate - (sample_rate / 4)))
2006                         temp *= 2;
2007
2008                 while (temp > (sample_rate + (sample_rate / 2)))
2009                         temp /= 2;
2010
2011                 /* compare */
2012
2013                 DPRINTF("Comparing %d < %d\n",
2014                     (int)temp, (int)sample_rate);
2015
2016                 if (temp == sample_rate)
2017                         ch->last_sync_state = UAUDIO_SYNC_NONE;
2018                 else if (temp > sample_rate)
2019                         ch->last_sync_state = UAUDIO_SYNC_MORE;
2020                 else
2021                         ch->last_sync_state = UAUDIO_SYNC_LESS;
2022                 break;
2023
2024         case USB_ST_SETUP:
2025                 usbd_xfer_set_frames(xfer, 1);
2026                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_framelen(xfer));
2027                 usbd_transfer_submit(xfer);
2028                 break;
2029
2030         default:                        /* Error */
2031                 break;
2032         }
2033 }
2034
2035 static void
2036 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error)
2037 {
2038         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2039         struct usb_page_cache *pc;
2040         uint32_t sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2041         uint32_t mfl;
2042         uint32_t total;
2043         uint32_t blockcount;
2044         uint32_t n;
2045         uint32_t offset;
2046         int actlen;
2047         int sumlen;
2048
2049         usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
2050
2051         if (ch->end == ch->start) {
2052                 DPRINTF("no buffer!\n");
2053                 return;
2054         }
2055
2056         switch (USB_GET_STATE(xfer)) {
2057         case USB_ST_TRANSFERRED:
2058 tr_transferred:
2059                 if (actlen < sumlen) {
2060                         DPRINTF("short transfer, "
2061                             "%d of %d bytes\n", actlen, sumlen);
2062                 }
2063                 chn_intr(ch->pcm_ch);
2064
2065                 /* start SYNC transfer, if any */
2066                 if ((ch->last_sync_time++ & 7) == 0)
2067                         usbd_transfer_start(ch->xfer[UAUDIO_NCHANBUFS]);
2068
2069         case USB_ST_SETUP:
2070                 mfl = usbd_xfer_max_framelen(xfer);
2071
2072                 if (ch->bytes_per_frame[1] > mfl) {
2073                         DPRINTF("bytes per transfer, %d, "
2074                             "exceeds maximum, %d!\n",
2075                             ch->bytes_per_frame[1],
2076                             mfl);
2077                         break;
2078                 }
2079
2080                 blockcount = ch->intr_frames;
2081
2082                 /* setup number of frames */
2083                 usbd_xfer_set_frames(xfer, blockcount);
2084
2085                 /* reset total length */
2086                 total = 0;
2087
2088                 /* setup frame lengths */
2089                 for (n = 0; n != blockcount; n++) {
2090                         uint32_t frame_len;
2091
2092                         ch->sample_curr += ch->sample_rem;
2093                         if (ch->sample_curr >= ch->frames_per_second) {
2094                                 ch->sample_curr -= ch->frames_per_second;
2095                                 frame_len = ch->bytes_per_frame[1];
2096                         } else {
2097                                 frame_len = ch->bytes_per_frame[0];
2098                         }
2099
2100                         if (n == (blockcount - 1)) {
2101                                 switch (ch->last_sync_state) {
2102                                 case UAUDIO_SYNC_MORE:
2103                                         DPRINTFN(6, "sending one sample more\n");
2104                                         if ((frame_len + sample_size) <= mfl)
2105                                                 frame_len += sample_size;
2106                                         ch->last_sync_state = UAUDIO_SYNC_NONE;
2107                                         break;
2108                                 case UAUDIO_SYNC_LESS:
2109                                         DPRINTFN(6, "sending one sample less\n");
2110                                         if (frame_len >= sample_size)
2111                                                 frame_len -= sample_size;
2112                                         ch->last_sync_state = UAUDIO_SYNC_NONE;
2113                                         break;
2114                                 default:
2115                                         break;
2116                                 }
2117                         }
2118
2119                         usbd_xfer_set_frame_len(xfer, n, frame_len);
2120                         total += frame_len;
2121                 }
2122
2123                 DPRINTFN(6, "transfer %d bytes\n", total);
2124
2125                 offset = 0;
2126
2127                 pc = usbd_xfer_get_frame(xfer, 0);
2128                 while (total > 0) {
2129
2130                         n = (ch->end - ch->cur);
2131                         if (n > total) {
2132                                 n = total;
2133                         }
2134                         usbd_copy_in(pc, offset, ch->cur, n);
2135
2136                         total -= n;
2137                         ch->cur += n;
2138                         offset += n;
2139
2140                         if (ch->cur >= ch->end) {
2141                                 ch->cur = ch->start;
2142                         }
2143                 }
2144
2145                 usbd_transfer_submit(xfer);
2146                 break;
2147
2148         default:                        /* Error */
2149                 if (error == USB_ERR_CANCELLED) {
2150                         break;
2151                 }
2152                 goto tr_transferred;
2153         }
2154 }
2155
2156 static void
2157 uaudio_chan_record_sync_callback(struct usb_xfer *xfer, usb_error_t error)
2158 {
2159         /* TODO */
2160 }
2161
2162 static void
2163 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error)
2164 {
2165         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2166         struct usb_page_cache *pc;
2167         uint32_t offset0;
2168         uint32_t offset1;
2169         uint32_t mfl;
2170         int m;
2171         int n;
2172         int len;
2173         int actlen;
2174         int nframes;
2175         int blockcount;
2176
2177         usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
2178         mfl = usbd_xfer_max_framelen(xfer);
2179
2180         if (ch->end == ch->start) {
2181                 DPRINTF("no buffer!\n");
2182                 return;
2183         }
2184
2185         switch (USB_GET_STATE(xfer)) {
2186         case USB_ST_TRANSFERRED:
2187
2188                 DPRINTFN(6, "transferred %d bytes\n", actlen);
2189
2190                 offset0 = 0;
2191                 pc = usbd_xfer_get_frame(xfer, 0);
2192
2193                 for (n = 0; n != nframes; n++) {
2194
2195                         offset1 = offset0;
2196                         len = usbd_xfer_frame_len(xfer, n);
2197
2198                         while (len > 0) {
2199
2200                                 m = (ch->end - ch->cur);
2201
2202                                 if (m > len)
2203                                         m = len;
2204
2205                                 usbd_copy_out(pc, offset1, ch->cur, m);
2206
2207                                 len -= m;
2208                                 offset1 += m;
2209                                 ch->cur += m;
2210
2211                                 if (ch->cur >= ch->end) {
2212                                         ch->cur = ch->start;
2213                                 }
2214                         }
2215
2216                         offset0 += mfl;
2217                 }
2218
2219                 chn_intr(ch->pcm_ch);
2220
2221         case USB_ST_SETUP:
2222 tr_setup:
2223                 blockcount = ch->intr_frames;
2224
2225                 usbd_xfer_set_frames(xfer, blockcount);
2226                 for (n = 0; n < blockcount; n++) {
2227                         usbd_xfer_set_frame_len(xfer, n, mfl);
2228                 }
2229
2230                 usbd_transfer_submit(xfer);
2231                 break;
2232
2233         default:                        /* Error */
2234                 if (error == USB_ERR_CANCELLED) {
2235                         break;
2236                 }
2237                 goto tr_setup;
2238         }
2239 }
2240
2241 void   *
2242 uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b,
2243     struct pcm_channel *c, int dir)
2244 {
2245         struct uaudio_chan *ch = ((dir == PCMDIR_PLAY) ?
2246             &sc->sc_play_chan : &sc->sc_rec_chan);
2247         uint32_t buf_size;
2248         uint8_t x;
2249
2250         /* store mutex and PCM channel */
2251
2252         ch->pcm_ch = c;
2253         ch->pcm_mtx = c->lock;
2254
2255         /* compute worst case buffer */
2256
2257         buf_size = 0;
2258         for (x = 0; x != ch->num_alt; x++) {
2259                 uint32_t temp = uaudio_get_buffer_size(ch, x);
2260                 if (temp > buf_size)
2261                         buf_size = temp;
2262         }
2263
2264         /* allow double buffering */
2265         buf_size *= 2;
2266
2267         DPRINTF("Worst case buffer is %d bytes\n", (int)buf_size);
2268
2269         ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO);
2270         if (ch->buf == NULL)
2271                 goto error;
2272         if (sndbuf_setup(b, ch->buf, buf_size) != 0)
2273                 goto error;
2274
2275         ch->start = ch->buf;
2276         ch->end = ch->buf + buf_size;
2277         ch->cur = ch->buf;
2278         ch->pcm_buf = b;
2279         ch->max_buf = buf_size;
2280
2281         if (ch->pcm_mtx == NULL) {
2282                 DPRINTF("ERROR: PCM channels does not have a mutex!\n");
2283                 goto error;
2284         }
2285         return (ch);
2286
2287 error:
2288         uaudio_chan_free(ch);
2289         return (NULL);
2290 }
2291
2292 int
2293 uaudio_chan_free(struct uaudio_chan *ch)
2294 {
2295         if (ch->buf != NULL) {
2296                 free(ch->buf, M_DEVBUF);
2297                 ch->buf = NULL;
2298         }
2299         usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS + 1);
2300
2301         ch->num_alt = 0;
2302
2303         return (0);
2304 }
2305
2306 int
2307 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize)
2308 {
2309         uint32_t temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2310
2311         sndbuf_setup(ch->pcm_buf, ch->buf, temp);
2312
2313         ch->start = ch->buf;
2314         ch->end = ch->buf + temp;
2315         ch->cur = ch->buf;
2316
2317         return (temp / 2);
2318 }
2319
2320 int
2321 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize,
2322     uint32_t blockcount)
2323 {
2324         return (1);
2325 }
2326
2327 int
2328 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed)
2329 {
2330         uint8_t x;
2331
2332         for (x = 0; x < ch->num_alt; x++) {
2333                 if (ch->usb_alt[x].sample_rate < speed) {
2334                         /* sample rate is too low */
2335                         break;
2336                 }
2337         }
2338
2339         if (x != 0)
2340                 x--;
2341
2342         ch->set_alt = x;
2343
2344         DPRINTF("Selecting alt %d\n", (int)x);
2345
2346         return (ch->usb_alt[x].sample_rate);
2347 }
2348
2349 int
2350 uaudio_chan_getptr(struct uaudio_chan *ch)
2351 {
2352         return (ch->cur - ch->start);
2353 }
2354
2355 struct pcmchan_caps *
2356 uaudio_chan_getcaps(struct uaudio_chan *ch)
2357 {
2358         return (&ch->pcm_cap);
2359 }
2360
2361 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = {
2362         .id = SND_CHN_MATRIX_DRV,
2363         .channels = 2,
2364         .ext = 0,
2365         .map = {
2366                 /* Right */
2367                 [0] = {
2368                         .type = SND_CHN_T_FR,
2369                         .members =
2370                             SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC |
2371                             SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR |
2372                             SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR
2373                 },
2374                 /* Left */
2375                 [1] = {
2376                         .type = SND_CHN_T_FL,
2377                         .members =
2378                             SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC |
2379                             SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL |
2380                             SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL
2381                 },
2382                 [2] = {
2383                         .type = SND_CHN_T_MAX,
2384                         .members = 0
2385                 }
2386         },
2387         .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL,
2388         .offset = {  1,  0, -1, -1, -1, -1, -1, -1, -1,
2389                     -1, -1, -1, -1, -1, -1, -1, -1, -1  }
2390 };
2391
2392 struct pcmchan_matrix *
2393 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format)
2394 {
2395         struct uaudio_softc *sc;
2396
2397         sc = ch->priv_sc;
2398
2399         if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 &&
2400             AFMT_CHANNEL(format) == 2)
2401                 return (&uaudio_chan_matrix_swap_2_0);
2402
2403         return (feeder_matrix_format_map(format));
2404 }
2405
2406 int
2407 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format)
2408 {
2409         DPRINTF("Selecting format 0x%08x\n", (unsigned int)format);
2410         return (0);
2411 }
2412
2413 int
2414 uaudio_chan_start(struct uaudio_chan *ch)
2415 {
2416         struct uaudio_softc *sc = ch->priv_sc;
2417         int do_start = 0;
2418
2419         usb_proc_explore_lock(sc->sc_udev);
2420         if (ch->operation != CHAN_OP_DRAIN) {
2421                 if (ch->cur_alt == ch->set_alt &&
2422                     ch->operation == CHAN_OP_NONE) {
2423                         /* save doing the explore task */
2424                         do_start = 1;
2425                 } else {
2426                         ch->operation = CHAN_OP_START;
2427                         (void)usb_proc_explore_msignal(sc->sc_udev,
2428                             &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2429                 }
2430         }
2431         usb_proc_explore_unlock(sc->sc_udev);
2432
2433         if (do_start) {
2434                 usbd_transfer_start(ch->xfer[0]);
2435                 usbd_transfer_start(ch->xfer[1]);
2436         }
2437         return (0);
2438 }
2439
2440 int
2441 uaudio_chan_stop(struct uaudio_chan *ch)
2442 {
2443         struct uaudio_softc *sc = ch->priv_sc;
2444         int do_stop = 0;
2445
2446         usb_proc_explore_lock(sc->sc_udev);
2447         if (ch->operation != CHAN_OP_DRAIN) {
2448                 if (ch->cur_alt == ch->set_alt &&
2449                     ch->operation == CHAN_OP_NONE) {
2450                         /* save doing the explore task */
2451                         do_stop = 1;
2452                 } else {
2453                         ch->operation = CHAN_OP_STOP;
2454                         (void)usb_proc_explore_msignal(sc->sc_udev,
2455                             &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2456                 }
2457         }
2458         usb_proc_explore_unlock(sc->sc_udev);
2459
2460         if (do_stop) {
2461                 usbd_transfer_stop(ch->xfer[0]);
2462                 usbd_transfer_stop(ch->xfer[1]);
2463         }
2464         return (0);
2465 }
2466
2467 /*========================================================================*
2468  * AC - Audio Controller - routines
2469  *========================================================================*/
2470
2471 static int
2472 uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS)
2473 {
2474         struct uaudio_softc *sc;
2475         struct uaudio_mixer_node *pmc;
2476         int hint;
2477         int error;
2478         int temp = 0;
2479         int chan = 0;
2480
2481         sc = (struct uaudio_softc *)oidp->oid_arg1;
2482         hint = oidp->oid_arg2;
2483
2484         if (sc->sc_mixer_lock == NULL)
2485                 return (ENXIO);
2486
2487         /* lookup mixer node */
2488
2489         mtx_lock(sc->sc_mixer_lock);
2490         for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
2491                 for (chan = 0; chan != (int)pmc->nchan; chan++) {
2492                         if (pmc->wValue[chan] != -1 &&
2493                             pmc->wValue[chan] == hint) {
2494                                 temp = pmc->wData[chan];
2495                                 goto found;
2496                         }
2497                 }
2498         }
2499 found:
2500         mtx_unlock(sc->sc_mixer_lock);
2501
2502         error = sysctl_handle_int(oidp, &temp, 0, req);
2503         if (error != 0 || req->newptr == NULL)
2504                 return (error);
2505
2506         /* update mixer value */
2507
2508         mtx_lock(sc->sc_mixer_lock);
2509         if (pmc != NULL &&
2510             temp >= pmc->minval &&
2511             temp <= pmc->maxval) {
2512
2513                 pmc->wData[chan] = temp;
2514                 pmc->update[(chan / 8)] |= (1 << (chan % 8));
2515
2516                 /* start the transfer, if not already started */
2517                 usbd_transfer_start(sc->sc_mixer_xfer[0]);
2518         }
2519         mtx_unlock(sc->sc_mixer_lock);
2520
2521         return (0);
2522 }
2523
2524 static void
2525 uaudio_mixer_ctl_free(struct uaudio_softc *sc)
2526 {
2527         struct uaudio_mixer_node *p_mc;
2528
2529         while ((p_mc = sc->sc_mixer_root) != NULL) {
2530                 sc->sc_mixer_root = p_mc->next;
2531                 free(p_mc, M_USBDEV);
2532         }
2533 }
2534
2535 static void
2536 uaudio_mixer_register_sysctl(struct uaudio_softc *sc, device_t dev)
2537 {
2538         struct uaudio_mixer_node *pmc;
2539         struct sysctl_oid *mixer_tree;
2540         struct sysctl_oid *control_tree;
2541         char buf[32];
2542         int chan;
2543         int n;
2544
2545         mixer_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
2546             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "mixer",
2547             CTLFLAG_RD, NULL, "");
2548
2549         if (mixer_tree == NULL)
2550                 return;
2551
2552         for (n = 0, pmc = sc->sc_mixer_root; pmc != NULL;
2553             pmc = pmc->next, n++) {
2554
2555                 for (chan = 0; chan < pmc->nchan; chan++) {
2556
2557                         if (pmc->nchan > 1) {
2558                                 snprintf(buf, sizeof(buf), "%s_%d_%d",
2559                                     pmc->name, n, chan);
2560                         } else {
2561                                 snprintf(buf, sizeof(buf), "%s_%d",
2562                                     pmc->name, n);
2563                         }
2564
2565                         control_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
2566                             SYSCTL_CHILDREN(mixer_tree), OID_AUTO, buf,
2567                             CTLFLAG_RD, NULL, "Mixer control nodes");
2568
2569                         if (control_tree == NULL)
2570                                 continue;
2571
2572                         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
2573                             SYSCTL_CHILDREN(control_tree),
2574                             OID_AUTO, "val", CTLTYPE_INT | CTLFLAG_RW, sc,
2575                             pmc->wValue[chan],
2576                             uaudio_mixer_sysctl_handler, "I", "Current value");
2577
2578                         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
2579                             SYSCTL_CHILDREN(control_tree),
2580                             OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval,
2581                             "Minimum value");
2582
2583                         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
2584                             SYSCTL_CHILDREN(control_tree),
2585                             OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval,
2586                             "Maximum value");
2587
2588                         SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
2589                             SYSCTL_CHILDREN(control_tree),
2590                             OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0,
2591                             "Description");
2592                 }
2593         }
2594 }
2595
2596 /* M-Audio FastTrack Ultra Mixer Description */
2597 /* Origin: Linux USB Audio driver */
2598 static void
2599 uaudio_mixer_controls_create_ftu(struct uaudio_softc *sc)
2600 {
2601         int chx;
2602         int chy;
2603
2604         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2605         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2606         MIX(sc).wValue[0] = MAKE_WORD(8, 0);
2607         MIX(sc).class = UAC_OUTPUT;
2608         MIX(sc).type = MIX_UNSIGNED_16;
2609         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2610         MIX(sc).name = "effect";
2611         MIX(sc).minval = 0;
2612         MIX(sc).maxval = 7;
2613         MIX(sc).mul = 7;
2614         MIX(sc).nchan = 1;
2615         MIX(sc).update[0] = 1;
2616         strlcpy(MIX(sc).desc, "Room1,2,3,Hall1,2,Plate,Delay,Echo", sizeof(MIX(sc).desc));
2617         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2618
2619         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2620         MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
2621
2622         for (chx = 0; chx != 8; chx++) {
2623                 for (chy = 0; chy != 8; chy++) {
2624
2625                         MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1);
2626                         MIX(sc).type = MIX_SIGNED_16;
2627                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2628                         MIX(sc).name = "mix_rec";
2629                         MIX(sc).nchan = 1;
2630                         MIX(sc).update[0] = 1;
2631                         MIX(sc).val_default = 0;
2632                         snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2633                             "AIn%d - Out%d Record Volume", chy + 1, chx + 1);
2634
2635                         uaudio_mixer_add_ctl(sc, &MIX(sc));
2636
2637                         MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1 + 8);
2638                         MIX(sc).type = MIX_SIGNED_16;
2639                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2640                         MIX(sc).name = "mix_play";
2641                         MIX(sc).nchan = 1;
2642                         MIX(sc).update[0] = 1;
2643                         MIX(sc).val_default = (chx == chy) ? 2 : 0;
2644                         snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2645                             "DIn%d - Out%d Playback Volume", chy + 1, chx + 1);
2646
2647                         uaudio_mixer_add_ctl(sc, &MIX(sc));
2648                 }
2649         }
2650
2651         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2652         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2653         MIX(sc).wValue[0] = MAKE_WORD(2, 0);
2654         MIX(sc).class = UAC_OUTPUT;
2655         MIX(sc).type = MIX_SIGNED_8;
2656         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2657         MIX(sc).name = "effect_vol";
2658         MIX(sc).nchan = 1;
2659         MIX(sc).update[0] = 1;
2660         MIX(sc).minval = 0;
2661         MIX(sc).maxval = 0x7f;
2662         MIX(sc).mul = 0x7f;
2663         MIX(sc).nchan = 1;
2664         MIX(sc).update[0] = 1;
2665         strlcpy(MIX(sc).desc, "Effect Volume", sizeof(MIX(sc).desc));
2666         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2667
2668         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2669         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2670         MIX(sc).wValue[0] = MAKE_WORD(3, 0);
2671         MIX(sc).class = UAC_OUTPUT;
2672         MIX(sc).type = MIX_SIGNED_16;
2673         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2674         MIX(sc).name = "effect_dur";
2675         MIX(sc).nchan = 1;
2676         MIX(sc).update[0] = 1;
2677         MIX(sc).minval = 0;
2678         MIX(sc).maxval = 0x7f00;
2679         MIX(sc).mul = 0x7f00;
2680         MIX(sc).nchan = 1;
2681         MIX(sc).update[0] = 1;
2682         strlcpy(MIX(sc).desc, "Effect Duration", sizeof(MIX(sc).desc));
2683         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2684
2685         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2686         MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
2687         MIX(sc).wValue[0] = MAKE_WORD(4, 0);
2688         MIX(sc).class = UAC_OUTPUT;
2689         MIX(sc).type = MIX_SIGNED_8;
2690         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2691         MIX(sc).name = "effect_fb";
2692         MIX(sc).nchan = 1;
2693         MIX(sc).update[0] = 1;
2694         MIX(sc).minval = 0;
2695         MIX(sc).maxval = 0x7f;
2696         MIX(sc).mul = 0x7f;
2697         MIX(sc).nchan = 1;
2698         MIX(sc).update[0] = 1;
2699         strlcpy(MIX(sc).desc, "Effect Feedback Volume", sizeof(MIX(sc).desc));
2700         uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
2701
2702         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2703         MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no);
2704         for (chy = 0; chy != 4; chy++) {
2705
2706                 MIX(sc).wValue[0] = MAKE_WORD(7, chy + 1);
2707                 MIX(sc).type = MIX_SIGNED_16;
2708                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2709                 MIX(sc).name = "effect_ret";
2710                 MIX(sc).nchan = 1;
2711                 MIX(sc).update[0] = 1;
2712                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2713                     "Effect Return %d Volume", chy + 1);
2714
2715                 uaudio_mixer_add_ctl(sc, &MIX(sc));
2716         }
2717
2718         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2719         MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
2720
2721         for (chy = 0; chy != 8; chy++) {
2722                 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1);
2723                 MIX(sc).type = MIX_SIGNED_16;
2724                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2725                 MIX(sc).name = "effect_send";
2726                 MIX(sc).nchan = 1;
2727                 MIX(sc).update[0] = 1;
2728                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2729                     "Effect Send AIn%d Volume", chy + 1);
2730
2731                 uaudio_mixer_add_ctl(sc, &MIX(sc));
2732
2733                 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1 + 8);
2734                 MIX(sc).type = MIX_SIGNED_16;
2735                 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
2736                 MIX(sc).name = "effect_send";
2737                 MIX(sc).nchan = 1;
2738                 MIX(sc).update[0] = 1;
2739                 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
2740                     "Effect Send DIn%d Volume", chy + 1);
2741
2742                 uaudio_mixer_add_ctl(sc, &MIX(sc));
2743         }
2744 }
2745
2746 static void
2747 uaudio_mixer_reload_all(struct uaudio_softc *sc)
2748 {
2749         struct uaudio_mixer_node *pmc;
2750         int chan;
2751
2752         if (sc->sc_mixer_lock == NULL)
2753                 return;
2754
2755         mtx_lock(sc->sc_mixer_lock);
2756         for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
2757                 /* use reset defaults for non-oss controlled settings */
2758                 if (pmc->ctl == SOUND_MIXER_NRDEVICES)
2759                         continue;
2760                 for (chan = 0; chan < pmc->nchan; chan++)
2761                         pmc->update[chan / 8] |= (1 << (chan % 8));
2762         }
2763         usbd_transfer_start(sc->sc_mixer_xfer[0]);
2764
2765         /* start HID volume keys, if any */
2766         usbd_transfer_start(sc->sc_hid.xfer[0]);
2767         mtx_unlock(sc->sc_mixer_lock);
2768 }
2769
2770 static void
2771 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
2772 {
2773         struct uaudio_mixer_node *p_mc_new =
2774             malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK);
2775         int ch;
2776
2777         if (p_mc_new != NULL) {
2778                 memcpy(p_mc_new, mc, sizeof(*p_mc_new));
2779                 p_mc_new->next = sc->sc_mixer_root;
2780                 sc->sc_mixer_root = p_mc_new;
2781                 sc->sc_mixer_count++;
2782
2783                 /* set default value for all channels */
2784                 for (ch = 0; ch < p_mc_new->nchan; ch++) {
2785                         switch (p_mc_new->val_default) {
2786                         case 1:
2787                                 /* 50% */
2788                                 p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2;
2789                                 break;
2790                         case 2:
2791                                 /* 100% */
2792                                 p_mc_new->wData[ch] = p_mc_new->maxval;
2793                                 break;
2794                         default:
2795                                 /* 0% */
2796                                 p_mc_new->wData[ch] = p_mc_new->minval;
2797                                 break;
2798                         }
2799                 }
2800         } else {
2801                 DPRINTF("out of memory\n");
2802         }
2803 }
2804
2805 static void
2806 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
2807 {
2808         int32_t res;
2809
2810         if (mc->class < UAC_NCLASSES) {
2811                 DPRINTF("adding %s.%d\n",
2812                     uac_names[mc->class], mc->ctl);
2813         } else {
2814                 DPRINTF("adding %d\n", mc->ctl);
2815         }
2816
2817         if (mc->type == MIX_ON_OFF) {
2818                 mc->minval = 0;
2819                 mc->maxval = 1;
2820         } else if (mc->type == MIX_SELECTOR) {
2821         } else {
2822
2823                 /* determine min and max values */
2824
2825                 mc->minval = uaudio_mixer_get(sc->sc_udev,
2826                     sc->sc_audio_rev, GET_MIN, mc);
2827                 mc->maxval = uaudio_mixer_get(sc->sc_udev,
2828                     sc->sc_audio_rev, GET_MAX, mc);
2829
2830                 /* check if max and min was swapped */
2831
2832                 if (mc->maxval < mc->minval) {
2833                         res = mc->maxval;
2834                         mc->maxval = mc->minval;
2835                         mc->minval = res;
2836                 }
2837
2838                 /* compute value range */
2839                 mc->mul = mc->maxval - mc->minval;
2840                 if (mc->mul == 0)
2841                         mc->mul = 1;
2842
2843                 /* compute value alignment */
2844                 res = uaudio_mixer_get(sc->sc_udev,
2845                     sc->sc_audio_rev, GET_RES, mc);
2846
2847                 DPRINTF("Resolution = %d\n", (int)res);
2848         }
2849
2850         uaudio_mixer_add_ctl_sub(sc, mc);
2851
2852 #ifdef USB_DEBUG
2853         if (uaudio_debug > 2) {
2854                 uint8_t i;
2855
2856                 for (i = 0; i < mc->nchan; i++) {
2857                         DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]);
2858                 }
2859                 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' "
2860                     "min=%d max=%d\n",
2861                     mc->wIndex, mc->type, mc->ctl,
2862                     mc->minval, mc->maxval);
2863         }
2864 #endif
2865 }
2866
2867 static void
2868 uaudio_mixer_add_mixer(struct uaudio_softc *sc,
2869     const struct uaudio_terminal_node *iot, int id)
2870 {
2871         const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu_v1;
2872         const struct usb_audio_mixer_unit_1 *d1;
2873
2874         uint32_t bno;                   /* bit number */
2875         uint32_t p;                     /* bit number accumulator */
2876         uint32_t mo;                    /* matching outputs */
2877         uint32_t mc;                    /* matching channels */
2878         uint32_t ichs;                  /* input channels */
2879         uint32_t ochs;                  /* output channels */
2880         uint32_t c;
2881         uint32_t chs;                   /* channels */
2882         uint32_t i;
2883         uint32_t o;
2884
2885         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
2886             d0->bUnitId, d0->bNrInPins);
2887
2888         /* compute the number of input channels */
2889
2890         ichs = 0;
2891         for (i = 0; i < d0->bNrInPins; i++) {
2892                 ichs += uaudio_mixer_get_cluster(
2893                     d0->baSourceId[i], iot).bNrChannels;
2894         }
2895
2896         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
2897
2898         /* and the number of output channels */
2899
2900         ochs = d1->bNrChannels;
2901
2902         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
2903
2904         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2905
2906         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
2907         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
2908         MIX(sc).type = MIX_SIGNED_16;
2909
2910         if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
2911                 return;
2912
2913         for (p = i = 0; i < d0->bNrInPins; i++) {
2914                 chs = uaudio_mixer_get_cluster(
2915                     d0->baSourceId[i], iot).bNrChannels;
2916                 mc = 0;
2917                 for (c = 0; c < chs; c++) {
2918                         mo = 0;
2919                         for (o = 0; o < ochs; o++) {
2920                                 bno = ((p + c) * ochs) + o;
2921                                 if (BIT_TEST(d1->bmControls, bno))
2922                                         mo++;
2923                         }
2924                         if (mo == 1)
2925                                 mc++;
2926                 }
2927                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
2928
2929                         /* repeat bit-scan */
2930
2931                         mc = 0;
2932                         for (c = 0; c < chs; c++) {
2933                                 for (o = 0; o < ochs; o++) {
2934                                         bno = ((p + c) * ochs) + o;
2935                                         if (BIT_TEST(d1->bmControls, bno))
2936                                                 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
2937                                 }
2938                         }
2939                         MIX(sc).nchan = chs;
2940                         uaudio_mixer_add_ctl(sc, &MIX(sc));
2941                 }
2942                 p += chs;
2943         }
2944 }
2945
2946 static void
2947 uaudio20_mixer_add_mixer(struct uaudio_softc *sc,
2948     const struct uaudio_terminal_node *iot, int id)
2949 {
2950         const struct usb_audio20_mixer_unit_0 *d0 = iot[id].u.mu_v2;
2951         const struct usb_audio20_mixer_unit_1 *d1;
2952
2953         uint32_t bno;                   /* bit number */
2954         uint32_t p;                     /* bit number accumulator */
2955         uint32_t mo;                    /* matching outputs */
2956         uint32_t mc;                    /* matching channels */
2957         uint32_t ichs;                  /* input channels */
2958         uint32_t ochs;                  /* output channels */
2959         uint32_t c;
2960         uint32_t chs;                   /* channels */
2961         uint32_t i;
2962         uint32_t o;
2963
2964         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
2965             d0->bUnitId, d0->bNrInPins);
2966
2967         /* compute the number of input channels */
2968
2969         ichs = 0;
2970         for (i = 0; i < d0->bNrInPins; i++) {
2971                 ichs += uaudio20_mixer_get_cluster(
2972                     d0->baSourceId[i], iot).bNrChannels;
2973         }
2974
2975         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
2976
2977         /* and the number of output channels */
2978
2979         ochs = d1->bNrChannels;
2980
2981         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
2982
2983         memset(&MIX(sc), 0, sizeof(MIX(sc)));
2984
2985         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
2986         uaudio20_mixer_determine_class(&iot[id], &MIX(sc));
2987         MIX(sc).type = MIX_SIGNED_16;
2988
2989         if (uaudio20_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
2990                 return;
2991
2992         for (p = i = 0; i < d0->bNrInPins; i++) {
2993                 chs = uaudio20_mixer_get_cluster(
2994                     d0->baSourceId[i], iot).bNrChannels;
2995                 mc = 0;
2996                 for (c = 0; c < chs; c++) {
2997                         mo = 0;
2998                         for (o = 0; o < ochs; o++) {
2999                                 bno = ((p + c) * ochs) + o;
3000                                 if (BIT_TEST(d1->bmControls, bno))
3001                                         mo++;
3002                         }
3003                         if (mo == 1)
3004                                 mc++;
3005                 }
3006                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3007
3008                         /* repeat bit-scan */
3009
3010                         mc = 0;
3011                         for (c = 0; c < chs; c++) {
3012                                 for (o = 0; o < ochs; o++) {
3013                                         bno = ((p + c) * ochs) + o;
3014                                         if (BIT_TEST(d1->bmControls, bno))
3015                                                 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3016                                 }
3017                         }
3018                         MIX(sc).nchan = chs;
3019                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3020                 }
3021                 p += chs;
3022         }
3023 }
3024
3025 static void
3026 uaudio_mixer_add_selector(struct uaudio_softc *sc,
3027     const struct uaudio_terminal_node *iot, int id)
3028 {
3029         const struct usb_audio_selector_unit *d = iot[id].u.su_v1;
3030         uint16_t i;
3031
3032         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3033             d->bUnitId, d->bNrInPins);
3034
3035         if (d->bNrInPins == 0)
3036                 return;
3037
3038         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3039
3040         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3041         MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3042         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3043         MIX(sc).nchan = 1;
3044         MIX(sc).type = MIX_SELECTOR;
3045         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3046         MIX(sc).minval = 1;
3047         MIX(sc).maxval = d->bNrInPins;
3048         MIX(sc).name = "selector";
3049
3050         i = d->baSourceId[d->bNrInPins];
3051         if (i == 0 ||
3052             usbd_req_get_string_any(sc->sc_udev, NULL,
3053             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3054                 MIX(sc).desc[0] = 0;
3055         }
3056
3057         if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN) {
3058                 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3059         }
3060         MIX(sc).mul = (MIX(sc).maxval - MIX(sc).minval);
3061         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) {
3062                 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3063         }
3064
3065         for (i = 0; i < MIX(sc).maxval; i++) {
3066                 MIX(sc).slctrtype[i] = uaudio_mixer_feature_name(
3067                     &iot[d->baSourceId[i]], &MIX(sc));
3068         }
3069
3070         MIX(sc).class = 0;                      /* not used */
3071
3072         uaudio_mixer_add_ctl(sc, &MIX(sc));
3073 }
3074
3075 static void
3076 uaudio20_mixer_add_selector(struct uaudio_softc *sc,
3077     const struct uaudio_terminal_node *iot, int id)
3078 {
3079         const struct usb_audio20_selector_unit *d = iot[id].u.su_v2;
3080         uint16_t i;
3081
3082         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3083             d->bUnitId, d->bNrInPins);
3084
3085         if (d->bNrInPins == 0)
3086                 return;
3087
3088         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3089
3090         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3091         MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3092         uaudio20_mixer_determine_class(&iot[id], &MIX(sc));
3093         MIX(sc).nchan = 1;
3094         MIX(sc).type = MIX_SELECTOR;
3095         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3096         MIX(sc).minval = 1;
3097         MIX(sc).maxval = d->bNrInPins;
3098         MIX(sc).name = "selector";
3099
3100         i = d->baSourceId[d->bNrInPins];
3101         if (i == 0 ||
3102             usbd_req_get_string_any(sc->sc_udev, NULL,
3103             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3104                 MIX(sc).desc[0] = 0;
3105         }
3106
3107         if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3108                 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3109
3110         MIX(sc).mul = (MIX(sc).maxval - MIX(sc).minval);
3111         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++)
3112                 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3113
3114         for (i = 0; i < MIX(sc).maxval; i++) {
3115                 MIX(sc).slctrtype[i] = uaudio20_mixer_feature_name(
3116                     &iot[d->baSourceId[i]], &MIX(sc));
3117         }
3118
3119         MIX(sc).class = 0;                      /* not used */
3120
3121         uaudio_mixer_add_ctl(sc, &MIX(sc));
3122 }
3123
3124 static uint32_t
3125 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d,
3126     uint8_t i)
3127 {
3128         uint32_t temp = 0;
3129         uint32_t offset = (i * d->bControlSize);
3130
3131         if (d->bControlSize > 0) {
3132                 temp |= d->bmaControls[offset];
3133                 if (d->bControlSize > 1) {
3134                         temp |= d->bmaControls[offset + 1] << 8;
3135                         if (d->bControlSize > 2) {
3136                                 temp |= d->bmaControls[offset + 2] << 16;
3137                                 if (d->bControlSize > 3) {
3138                                         temp |= d->bmaControls[offset + 3] << 24;
3139                                 }
3140                         }
3141                 }
3142         }
3143         return (temp);
3144 }
3145
3146 static void
3147 uaudio_mixer_add_feature(struct uaudio_softc *sc,
3148     const struct uaudio_terminal_node *iot, int id)
3149 {
3150         const struct usb_audio_feature_unit *d = iot[id].u.fu_v1;
3151         uint32_t fumask;
3152         uint32_t mmask;
3153         uint32_t cmask;
3154         uint16_t mixernumber;
3155         uint8_t nchan;
3156         uint8_t chan;
3157         uint8_t ctl;
3158         uint8_t i;
3159
3160         if (d->bControlSize == 0)
3161                 return;
3162
3163         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3164
3165         nchan = (d->bLength - 7) / d->bControlSize;
3166         mmask = uaudio_mixer_feature_get_bmaControls(d, 0);
3167         cmask = 0;
3168
3169         if (nchan == 0)
3170                 return;
3171
3172         /* figure out what we can control */
3173
3174         for (chan = 1; chan < nchan; chan++) {
3175                 DPRINTFN(10, "chan=%d mask=%x\n",
3176                     chan, uaudio_mixer_feature_get_bmaControls(d, chan));
3177
3178                 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan);
3179         }
3180
3181         if (nchan > MIX_MAX_CHAN) {
3182                 nchan = MIX_MAX_CHAN;
3183         }
3184         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3185
3186         i = d->bmaControls[d->bControlSize];
3187         if (i == 0 ||
3188             usbd_req_get_string_any(sc->sc_udev, NULL,
3189             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3190                 MIX(sc).desc[0] = 0;
3191         }
3192
3193         for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) {
3194
3195                 fumask = FU_MASK(ctl);
3196
3197                 DPRINTFN(5, "ctl=%d fumask=0x%04x\n",
3198                     ctl, fumask);
3199
3200                 if (mmask & fumask) {
3201                         MIX(sc).nchan = 1;
3202                         MIX(sc).wValue[0] = MAKE_WORD(ctl, 0);
3203                 } else if (cmask & fumask) {
3204                         MIX(sc).nchan = nchan - 1;
3205                         for (i = 1; i < nchan; i++) {
3206                                 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask)
3207                                         MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i);
3208                                 else
3209                                         MIX(sc).wValue[i - 1] = -1;
3210                         }
3211                 } else {
3212                         continue;
3213                 }
3214
3215                 mixernumber = uaudio_mixer_feature_name(&iot[id], &MIX(sc));
3216
3217                 switch (ctl) {
3218                 case MUTE_CONTROL:
3219                         MIX(sc).type = MIX_ON_OFF;
3220                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3221                         MIX(sc).name = "mute";
3222                         break;
3223
3224                 case VOLUME_CONTROL:
3225                         MIX(sc).type = MIX_SIGNED_16;
3226                         MIX(sc).ctl = mixernumber;
3227                         MIX(sc).name = "vol";
3228                         break;
3229
3230                 case BASS_CONTROL:
3231                         MIX(sc).type = MIX_SIGNED_8;
3232                         MIX(sc).ctl = SOUND_MIXER_BASS;
3233                         MIX(sc).name = "bass";
3234                         break;
3235
3236                 case MID_CONTROL:
3237                         MIX(sc).type = MIX_SIGNED_8;
3238                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3239                         MIX(sc).name = "mid";
3240                         break;
3241
3242                 case TREBLE_CONTROL:
3243                         MIX(sc).type = MIX_SIGNED_8;
3244                         MIX(sc).ctl = SOUND_MIXER_TREBLE;
3245                         MIX(sc).name = "treble";
3246                         break;
3247
3248                 case GRAPHIC_EQUALIZER_CONTROL:
3249                         continue;       /* XXX don't add anything */
3250
3251                 case AGC_CONTROL:
3252                         MIX(sc).type = MIX_ON_OFF;
3253                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3254                         MIX(sc).name = "agc";
3255                         break;
3256
3257                 case DELAY_CONTROL:
3258                         MIX(sc).type = MIX_UNSIGNED_16;
3259                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3260                         MIX(sc).name = "delay";
3261                         break;
3262
3263                 case BASS_BOOST_CONTROL:
3264                         MIX(sc).type = MIX_ON_OFF;
3265                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3266                         MIX(sc).name = "boost";
3267                         break;
3268
3269                 case LOUDNESS_CONTROL:
3270                         MIX(sc).type = MIX_ON_OFF;
3271                         MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3272                         MIX(sc).name = "loudness";
3273                         break;
3274
3275                 default:
3276                         MIX(sc).type = MIX_UNKNOWN;
3277                         break;
3278                 }
3279
3280                 if (MIX(sc).type != MIX_UNKNOWN)
3281                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3282         }
3283 }
3284
3285 static void
3286 uaudio20_mixer_add_feature(struct uaudio_softc *sc,
3287     const struct uaudio_terminal_node *iot, int id)
3288 {
3289         const struct usb_audio20_feature_unit *d = iot[id].u.fu_v2;
3290         uint32_t ctl;
3291         uint32_t mmask;
3292         uint32_t cmask;
3293         uint16_t mixernumber;
3294         uint8_t nchan;
3295         uint8_t chan;
3296         uint8_t i;
3297         uint8_t what;
3298
3299         if (UGETDW(d->bmaControls[0]) == 0)
3300                 return;
3301
3302         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3303
3304         nchan = (d->bLength - 6) / 4;
3305         mmask = UGETDW(d->bmaControls[0]);
3306         cmask = 0;
3307
3308         if (nchan == 0)
3309                 return;
3310
3311         /* figure out what we can control */
3312
3313         for (chan = 1; chan < nchan; chan++)
3314                 cmask |= UGETDW(d->bmaControls[chan]);
3315
3316         if (nchan > MIX_MAX_CHAN)
3317                 nchan = MIX_MAX_CHAN;
3318
3319         MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3320
3321         i = d->bmaControls[nchan][0];
3322         if (i == 0 ||
3323             usbd_req_get_string_any(sc->sc_udev, NULL,
3324             MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3325                 MIX(sc).desc[0] = 0;
3326         }
3327
3328         for (ctl = 3; ctl != 0; ctl <<= 2) {
3329
3330                 mixernumber = uaudio20_mixer_feature_name(&iot[id], &MIX(sc));
3331
3332                 switch (ctl) {
3333                 case (3 << 0):
3334                         MIX(sc).type = MIX_ON_OFF;
3335                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3336                         MIX(sc).name = "mute";
3337                         what = MUTE_CONTROL;
3338                         break;
3339                 case (3 << 2):
3340                         MIX(sc).type = MIX_SIGNED_16;
3341                         MIX(sc).ctl = mixernumber;
3342                         MIX(sc).name = "vol";
3343                         what = VOLUME_CONTROL;
3344                         break;
3345                 case (3 << 4):
3346                         MIX(sc).type = MIX_SIGNED_8;
3347                         MIX(sc).ctl = SOUND_MIXER_BASS;
3348                         MIX(sc).name = "bass";
3349                         what = BASS_CONTROL;
3350                         break;
3351                 case (3 << 6):
3352                         MIX(sc).type = MIX_SIGNED_8;
3353                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3354                         MIX(sc).name = "mid";
3355                         what = MID_CONTROL;
3356                         break;
3357                 case (3 << 8):
3358                         MIX(sc).type = MIX_SIGNED_8;
3359                         MIX(sc).ctl = SOUND_MIXER_TREBLE;
3360                         MIX(sc).name = "treble";
3361                         what = TREBLE_CONTROL;
3362                         break;
3363                 case (3 << 12):
3364                         MIX(sc).type = MIX_ON_OFF;
3365                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3366                         MIX(sc).name = "agc";
3367                         what = AGC_CONTROL;
3368                         break;
3369                 case (3 << 14):
3370                         MIX(sc).type = MIX_UNSIGNED_16;
3371                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3372                         MIX(sc).name = "delay";
3373                         what = DELAY_CONTROL;
3374                         break;
3375                 case (3 << 16):
3376                         MIX(sc).type = MIX_ON_OFF;
3377                         MIX(sc).ctl = SOUND_MIXER_NRDEVICES;    /* XXXXX */
3378                         MIX(sc).name = "boost";
3379                         what = BASS_BOOST_CONTROL;
3380                         break;
3381                 case (3 << 18):
3382                         MIX(sc).type = MIX_ON_OFF;
3383                         MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3384                         MIX(sc).name = "loudness";
3385                         what = LOUDNESS_CONTROL;
3386                         break;
3387                 case (3 << 20):
3388                         MIX(sc).type = MIX_SIGNED_16;
3389                         MIX(sc).ctl = mixernumber;
3390                         MIX(sc).name = "igain";
3391                         what = INPUT_GAIN_CONTROL;
3392                         break;
3393                 case (3 << 22):
3394                         MIX(sc).type = MIX_SIGNED_16;
3395                         MIX(sc).ctl = mixernumber;
3396                         MIX(sc).name = "igainpad";
3397                         what = INPUT_GAIN_PAD_CONTROL;
3398                         break;
3399                 default:
3400                         continue;
3401                 }
3402
3403                 if ((mmask & ctl) == ctl) {
3404                         MIX(sc).nchan = 1;
3405                         MIX(sc).wValue[0] = MAKE_WORD(what, 0);
3406                 } else if ((cmask & ctl) == ctl) {
3407                         MIX(sc).nchan = nchan - 1;
3408                         for (i = 1; i < nchan; i++) {
3409                                 if ((UGETDW(d->bmaControls[i]) & ctl) == ctl)
3410                                         MIX(sc).wValue[i - 1] = MAKE_WORD(what, i);
3411                                 else
3412                                         MIX(sc).wValue[i - 1] = -1;
3413                         }
3414                 } else {
3415                         continue;
3416                 }
3417
3418                 if (MIX(sc).type != MIX_UNKNOWN)
3419                         uaudio_mixer_add_ctl(sc, &MIX(sc));
3420         }
3421 }
3422
3423 static void
3424 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc,
3425     const struct uaudio_terminal_node *iot, int id)
3426 {
3427         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3428         const struct usb_audio_processing_unit_1 *d1 =
3429             (const void *)(d0->baSourceId + d0->bNrInPins);
3430         const struct usb_audio_processing_unit_updown *ud =
3431             (const void *)(d1->bmControls + d1->bControlSize);
3432         uint8_t i;
3433
3434         if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) {
3435                 return;
3436         }
3437         if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes))
3438             == NULL) {
3439                 return;
3440         }
3441         DPRINTFN(3, "bUnitId=%d bNrModes=%d\n",
3442             d0->bUnitId, ud->bNrModes);
3443
3444         if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
3445                 DPRINTF("no mode select\n");
3446                 return;
3447         }
3448         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3449
3450         MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3451         MIX(sc).nchan = 1;
3452         MIX(sc).wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0);
3453         uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3454         MIX(sc).type = MIX_ON_OFF;              /* XXX */
3455
3456         for (i = 0; i < ud->bNrModes; i++) {
3457                 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i]));
3458                 /* XXX */
3459         }
3460
3461         uaudio_mixer_add_ctl(sc, &MIX(sc));
3462 }
3463
3464 static void
3465 uaudio_mixer_add_processing(struct uaudio_softc *sc,
3466     const struct uaudio_terminal_node *iot, int id)
3467 {
3468         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3469         const struct usb_audio_processing_unit_1 *d1 =
3470             (const void *)(d0->baSourceId + d0->bNrInPins);
3471         uint16_t ptype;
3472
3473         memset(&MIX(sc), 0, sizeof(MIX(sc)));
3474
3475         ptype = UGETW(d0->wProcessType);
3476
3477         DPRINTFN(3, "wProcessType=%d bUnitId=%d "
3478             "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins);
3479
3480         if (d1->bControlSize == 0) {
3481                 return;
3482         }
3483         if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
3484                 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3485                 MIX(sc).nchan = 1;
3486                 MIX(sc).wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0);
3487                 uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3488                 MIX(sc).type = MIX_ON_OFF;
3489                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3490         }
3491         switch (ptype) {
3492         case UPDOWNMIX_PROCESS:
3493                 uaudio_mixer_add_processing_updown(sc, iot, id);
3494                 break;
3495
3496         case DOLBY_PROLOGIC_PROCESS:
3497         case P3D_STEREO_EXTENDER_PROCESS:
3498         case REVERBATION_PROCESS:
3499         case CHORUS_PROCESS:
3500         case DYN_RANGE_COMP_PROCESS:
3501         default:
3502                 DPRINTF("unit %d, type=%d is not implemented\n",
3503                     d0->bUnitId, ptype);
3504                 break;
3505         }
3506 }
3507
3508 static void
3509 uaudio_mixer_add_extension(struct uaudio_softc *sc,
3510     const struct uaudio_terminal_node *iot, int id)
3511 {
3512         const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu_v1;
3513         const struct usb_audio_extension_unit_1 *d1 =
3514             (const void *)(d0->baSourceId + d0->bNrInPins);
3515
3516         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3517             d0->bUnitId, d0->bNrInPins);
3518
3519         if (sc->sc_uq_au_no_xu) {
3520                 return;
3521         }
3522         if (d1->bControlSize == 0) {
3523                 return;
3524         }
3525         if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
3526
3527                 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3528
3529                 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3530                 MIX(sc).nchan = 1;
3531                 MIX(sc).wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0);
3532                 uaudio_mixer_determine_class(&iot[id], &MIX(sc));
3533                 MIX(sc).type = MIX_ON_OFF;
3534
3535                 uaudio_mixer_add_ctl(sc, &MIX(sc));
3536         }
3537 }
3538
3539 static const void *
3540 uaudio_mixer_verify_desc(const void *arg, uint32_t len)
3541 {
3542         const struct usb_audio_mixer_unit_1 *d1;
3543         const struct usb_audio_extension_unit_1 *e1;
3544         const struct usb_audio_processing_unit_1 *u1;
3545
3546         union {
3547                 const struct usb_descriptor *desc;
3548                 const struct usb_audio_input_terminal *it;
3549                 const struct usb_audio_output_terminal *ot;
3550                 const struct usb_audio_mixer_unit_0 *mu;
3551                 const struct usb_audio_selector_unit *su;
3552                 const struct usb_audio_feature_unit *fu;
3553                 const struct usb_audio_processing_unit_0 *pu;
3554                 const struct usb_audio_extension_unit_0 *eu;
3555         }     u;
3556
3557         u.desc = arg;
3558
3559         if (u.desc == NULL) {
3560                 goto error;
3561         }
3562         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) {
3563                 goto error;
3564         }
3565         switch (u.desc->bDescriptorSubtype) {
3566         case UDESCSUB_AC_INPUT:
3567                 len += sizeof(*u.it);
3568                 break;
3569
3570         case UDESCSUB_AC_OUTPUT:
3571                 len += sizeof(*u.ot);
3572                 break;
3573
3574         case UDESCSUB_AC_MIXER:
3575                 len += sizeof(*u.mu);
3576
3577                 if (u.desc->bLength < len) {
3578                         goto error;
3579                 }
3580                 len += u.mu->bNrInPins;
3581
3582                 if (u.desc->bLength < len) {
3583                         goto error;
3584                 }
3585                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
3586
3587                 len += sizeof(*d1);
3588                 break;
3589
3590         case UDESCSUB_AC_SELECTOR:
3591                 len += sizeof(*u.su);
3592
3593                 if (u.desc->bLength < len) {
3594                         goto error;
3595                 }
3596                 len += u.su->bNrInPins + 1;
3597                 break;
3598
3599         case UDESCSUB_AC_FEATURE:
3600                 len += sizeof(*u.fu) + 1;
3601
3602                 if (u.desc->bLength < len)
3603                         goto error;
3604
3605                 len += u.fu->bControlSize;
3606                 break;
3607
3608         case UDESCSUB_AC_PROCESSING:
3609                 len += sizeof(*u.pu);
3610
3611                 if (u.desc->bLength < len) {
3612                         goto error;
3613                 }
3614                 len += u.pu->bNrInPins;
3615
3616                 if (u.desc->bLength < len) {
3617                         goto error;
3618                 }
3619                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
3620
3621                 len += sizeof(*u1);
3622
3623                 if (u.desc->bLength < len) {
3624                         goto error;
3625                 }
3626                 len += u1->bControlSize;
3627
3628                 break;
3629
3630         case UDESCSUB_AC_EXTENSION:
3631                 len += sizeof(*u.eu);
3632
3633                 if (u.desc->bLength < len) {
3634                         goto error;
3635                 }
3636                 len += u.eu->bNrInPins;
3637
3638                 if (u.desc->bLength < len) {
3639                         goto error;
3640                 }
3641                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
3642
3643                 len += sizeof(*e1);
3644
3645                 if (u.desc->bLength < len) {
3646                         goto error;
3647                 }
3648                 len += e1->bControlSize;
3649                 break;
3650
3651         default:
3652                 goto error;
3653         }
3654
3655         if (u.desc->bLength < len) {
3656                 goto error;
3657         }
3658         return (u.desc);
3659
3660 error:
3661         if (u.desc) {
3662                 DPRINTF("invalid descriptor, type=%d, "
3663                     "sub_type=%d, len=%d of %d bytes\n",
3664                     u.desc->bDescriptorType,
3665                     u.desc->bDescriptorSubtype,
3666                     u.desc->bLength, len);
3667         }
3668         return (NULL);
3669 }
3670
3671 static const void *
3672 uaudio20_mixer_verify_desc(const void *arg, uint32_t len)
3673 {
3674         const struct usb_audio20_mixer_unit_1 *d1;
3675         const struct usb_audio20_extension_unit_1 *e1;
3676         const struct usb_audio20_processing_unit_1 *u1;
3677         const struct usb_audio20_clock_selector_unit_1 *c1;
3678
3679         union {
3680                 const struct usb_descriptor *desc;
3681                 const struct usb_audio20_clock_source_unit *csrc;
3682                 const struct usb_audio20_clock_selector_unit_0 *csel;
3683                 const struct usb_audio20_clock_multiplier_unit *cmul;
3684                 const struct usb_audio20_input_terminal *it;
3685                 const struct usb_audio20_output_terminal *ot;
3686                 const struct usb_audio20_mixer_unit_0 *mu;
3687                 const struct usb_audio20_selector_unit *su;
3688                 const struct usb_audio20_feature_unit *fu;
3689                 const struct usb_audio20_sample_rate_unit *ru;
3690                 const struct usb_audio20_processing_unit_0 *pu;
3691                 const struct usb_audio20_extension_unit_0 *eu;
3692                 const struct usb_audio20_effect_unit *ef;
3693         }     u;
3694
3695         u.desc = arg;
3696
3697         if (u.desc == NULL)
3698                 goto error;
3699
3700         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE)
3701                 goto error;
3702
3703         switch (u.desc->bDescriptorSubtype) {
3704         case UDESCSUB_AC_INPUT:
3705                 len += sizeof(*u.it);
3706                 break;
3707
3708         case UDESCSUB_AC_OUTPUT:
3709                 len += sizeof(*u.ot);
3710                 break;
3711
3712         case UDESCSUB_AC_MIXER:
3713                 len += sizeof(*u.mu);
3714
3715                 if (u.desc->bLength < len)
3716                         goto error;
3717                 len += u.mu->bNrInPins;
3718
3719                 if (u.desc->bLength < len)
3720                         goto error;
3721
3722                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
3723
3724                 len += sizeof(*d1) + d1->bNrChannels;
3725                 break;
3726
3727         case UDESCSUB_AC_SELECTOR:
3728                 len += sizeof(*u.su);
3729
3730                 if (u.desc->bLength < len)
3731                         goto error;
3732
3733                 len += u.su->bNrInPins + 1;
3734                 break;
3735
3736         case UDESCSUB_AC_FEATURE:
3737                 len += sizeof(*u.fu) + 1;
3738                 break;
3739
3740         case UDESCSUB_AC_EFFECT:
3741                 len += sizeof(*u.ef) + 4;
3742                 break;
3743
3744         case UDESCSUB_AC_PROCESSING_V2:
3745                 len += sizeof(*u.pu);
3746
3747                 if (u.desc->bLength < len)
3748                         goto error;
3749
3750                 len += u.pu->bNrInPins;
3751
3752                 if (u.desc->bLength < len)
3753                         goto error;
3754
3755                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
3756
3757                 len += sizeof(*u1);
3758                 break;
3759
3760         case UDESCSUB_AC_EXTENSION_V2:
3761                 len += sizeof(*u.eu);
3762
3763                 if (u.desc->bLength < len)
3764                         goto error;
3765
3766                 len += u.eu->bNrInPins;
3767
3768                 if (u.desc->bLength < len)
3769                         goto error;
3770
3771                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
3772
3773                 len += sizeof(*e1);
3774                 break;
3775
3776         case UDESCSUB_AC_CLOCK_SRC:
3777                 len += sizeof(*u.csrc);
3778                 break;
3779
3780         case UDESCSUB_AC_CLOCK_SEL:
3781                 len += sizeof(*u.csel);
3782
3783                 if (u.desc->bLength < len)
3784                         goto error;
3785
3786                 len += u.csel->bNrInPins;
3787
3788                 if (u.desc->bLength < len)
3789                         goto error;
3790
3791                 c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins);
3792
3793                 len += sizeof(*c1);
3794                 break;
3795
3796         case UDESCSUB_AC_CLOCK_MUL:
3797                 len += sizeof(*u.cmul);
3798                 break;
3799
3800         case UDESCSUB_AC_SAMPLE_RT:
3801                 len += sizeof(*u.ru);
3802                 break;
3803
3804         default:
3805                 goto error;
3806         }
3807
3808         if (u.desc->bLength < len)
3809                 goto error;
3810
3811         return (u.desc);
3812
3813 error:
3814         if (u.desc) {
3815                 DPRINTF("invalid descriptor, type=%d, "
3816                     "sub_type=%d, len=%d of %d bytes\n",
3817                     u.desc->bDescriptorType,
3818                     u.desc->bDescriptorSubtype,
3819                     u.desc->bLength, len);
3820         }
3821         return (NULL);
3822 }
3823
3824 static struct usb_audio_cluster
3825 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
3826 {
3827         struct usb_audio_cluster r;
3828         const struct usb_descriptor *dp;
3829         uint8_t i;
3830
3831         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
3832                 dp = iot[id].u.desc;
3833                 if (dp == NULL) {
3834                         goto error;
3835                 }
3836                 switch (dp->bDescriptorSubtype) {
3837                 case UDESCSUB_AC_INPUT:
3838                         r.bNrChannels = iot[id].u.it_v1->bNrChannels;
3839                         r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0];
3840                         r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1];
3841                         r.iChannelNames = iot[id].u.it_v1->iChannelNames;
3842                         goto done;
3843
3844                 case UDESCSUB_AC_OUTPUT:
3845                         id = iot[id].u.ot_v1->bSourceId;
3846                         break;
3847
3848                 case UDESCSUB_AC_MIXER:
3849                         r = *(const struct usb_audio_cluster *)
3850                             &iot[id].u.mu_v1->baSourceId[
3851                             iot[id].u.mu_v1->bNrInPins];
3852                         goto done;
3853
3854                 case UDESCSUB_AC_SELECTOR:
3855                         if (iot[id].u.su_v1->bNrInPins > 0) {
3856                                 /* XXX This is not really right */
3857                                 id = iot[id].u.su_v1->baSourceId[0];
3858                         }
3859                         break;
3860
3861                 case UDESCSUB_AC_FEATURE:
3862                         id = iot[id].u.fu_v1->bSourceId;
3863                         break;
3864
3865                 case UDESCSUB_AC_PROCESSING:
3866                         r = *((const struct usb_audio_cluster *)
3867                             &iot[id].u.pu_v1->baSourceId[
3868                             iot[id].u.pu_v1->bNrInPins]);
3869                         goto done;
3870
3871                 case UDESCSUB_AC_EXTENSION:
3872                         r = *((const struct usb_audio_cluster *)
3873                             &iot[id].u.eu_v1->baSourceId[
3874                             iot[id].u.eu_v1->bNrInPins]);
3875                         goto done;
3876
3877                 default:
3878                         goto error;
3879                 }
3880         }
3881 error:
3882         DPRINTF("bad data\n");
3883         memset(&r, 0, sizeof(r));
3884 done:
3885         return (r);
3886 }
3887
3888 static struct usb_audio20_cluster
3889 uaudio20_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
3890 {
3891         struct usb_audio20_cluster r;
3892         const struct usb_descriptor *dp;
3893         uint8_t i;
3894
3895         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
3896                 dp = iot[id].u.desc;
3897                 if (dp == NULL)
3898                         goto error;
3899
3900                 switch (dp->bDescriptorSubtype) {
3901                 case UDESCSUB_AC_INPUT:
3902                         r.bNrChannels = iot[id].u.it_v2->bNrChannels;
3903                         r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0];
3904                         r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1];
3905                         r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2];
3906                         r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3];
3907                         r.iChannelNames = iot[id].u.it_v2->iTerminal;
3908                         goto done;
3909
3910                 case UDESCSUB_AC_OUTPUT:
3911                         id = iot[id].u.ot_v2->bSourceId;
3912                         break;
3913
3914                 case UDESCSUB_AC_MIXER:
3915                         r = *(const struct usb_audio20_cluster *)
3916                             &iot[id].u.mu_v2->baSourceId[
3917                             iot[id].u.mu_v2->bNrInPins];
3918                         goto done;
3919
3920                 case UDESCSUB_AC_SELECTOR:
3921                         if (iot[id].u.su_v2->bNrInPins > 0) {
3922                                 /* XXX This is not really right */
3923                                 id = iot[id].u.su_v2->baSourceId[0];
3924                         }
3925                         break;
3926
3927                 case UDESCSUB_AC_SAMPLE_RT:
3928                         id = iot[id].u.ru_v2->bSourceId;
3929                         break;
3930
3931                 case UDESCSUB_AC_EFFECT:
3932                         id = iot[id].u.ef_v2->bSourceId;
3933                         break;
3934
3935                 case UDESCSUB_AC_FEATURE:
3936                         id = iot[id].u.fu_v2->bSourceId;
3937                         break;
3938
3939                 case UDESCSUB_AC_PROCESSING_V2:
3940                         r = *((const struct usb_audio20_cluster *)
3941                             &iot[id].u.pu_v2->baSourceId[
3942                             iot[id].u.pu_v2->bNrInPins]);
3943                         goto done;
3944
3945                 case UDESCSUB_AC_EXTENSION_V2:
3946                         r = *((const struct usb_audio20_cluster *)
3947                             &iot[id].u.eu_v2->baSourceId[
3948                             iot[id].u.eu_v2->bNrInPins]);
3949                         goto done;
3950
3951                 default:
3952                         goto error;
3953                 }
3954         }
3955 error:
3956         DPRINTF("Bad data!\n");
3957         memset(&r, 0, sizeof(r));
3958 done:
3959         return (r);
3960 }
3961
3962 static uint16_t
3963 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot,
3964     struct uaudio_mixer_node *mix)
3965 {
3966         uint16_t terminal_type = 0x0000;
3967         const struct uaudio_terminal_node *input[2];
3968         const struct uaudio_terminal_node *output[2];
3969
3970         input[0] = uaudio_mixer_get_input(iot, 0);
3971         input[1] = uaudio_mixer_get_input(iot, 1);
3972
3973         output[0] = uaudio_mixer_get_output(iot, 0);
3974         output[1] = uaudio_mixer_get_output(iot, 1);
3975
3976         /*
3977          * check if there is only
3978          * one output terminal:
3979          */
3980         if (output[0] && (!output[1])) {
3981                 terminal_type =
3982                     UGETW(output[0]->u.ot_v1->wTerminalType);
3983         }
3984         /*
3985          * If the only output terminal is USB,
3986          * the class is UAC_RECORD.
3987          */
3988         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
3989
3990                 mix->class = UAC_RECORD;
3991                 if (input[0] && (!input[1])) {
3992                         terminal_type =
3993                             UGETW(input[0]->u.it_v1->wTerminalType);
3994                 } else {
3995                         terminal_type = 0;
3996                 }
3997                 goto done;
3998         }
3999         /*
4000          * if the unit is connected to just
4001          * one input terminal, the
4002          * class is UAC_INPUT:
4003          */
4004         if (input[0] && (!input[1])) {
4005                 mix->class = UAC_INPUT;
4006                 terminal_type =
4007                     UGETW(input[0]->u.it_v1->wTerminalType);
4008                 goto done;
4009         }
4010         /*
4011          * Otherwise, the class is UAC_OUTPUT.
4012          */
4013         mix->class = UAC_OUTPUT;
4014 done:
4015         return (terminal_type);
4016 }
4017
4018 static uint16_t
4019 uaudio20_mixer_determine_class(const struct uaudio_terminal_node *iot,
4020     struct uaudio_mixer_node *mix)
4021 {
4022         uint16_t terminal_type = 0x0000;
4023         const struct uaudio_terminal_node *input[2];
4024         const struct uaudio_terminal_node *output[2];
4025
4026         input[0] = uaudio_mixer_get_input(iot, 0);
4027         input[1] = uaudio_mixer_get_input(iot, 1);
4028
4029         output[0] = uaudio_mixer_get_output(iot, 0);
4030         output[1] = uaudio_mixer_get_output(iot, 1);
4031
4032         /*
4033          * check if there is only
4034          * one output terminal:
4035          */
4036         if (output[0] && (!output[1]))
4037                 terminal_type = UGETW(output[0]->u.ot_v2->wTerminalType);
4038         /*
4039          * If the only output terminal is USB,
4040          * the class is UAC_RECORD.
4041          */
4042         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
4043
4044                 mix->class = UAC_RECORD;
4045                 if (input[0] && (!input[1])) {
4046                         terminal_type =
4047                             UGETW(input[0]->u.it_v2->wTerminalType);
4048                 } else {
4049                         terminal_type = 0;
4050                 }
4051                 goto done;
4052         }
4053         /*
4054          * if the unit is connected to just
4055          * one input terminal, the
4056          * class is UAC_INPUT:
4057          */
4058         if (input[0] && (!input[1])) {
4059                 mix->class = UAC_INPUT;
4060                 terminal_type =
4061                     UGETW(input[0]->u.it_v2->wTerminalType);
4062                 goto done;
4063         }
4064         /*
4065          * Otherwise, the class is UAC_OUTPUT.
4066          */
4067         mix->class = UAC_OUTPUT;
4068 done:
4069         return (terminal_type);
4070 }
4071
4072 struct uaudio_tt_to_feature {
4073         uint16_t terminal_type;
4074         uint16_t feature;
4075 };
4076
4077 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = {
4078
4079         {UAT_STREAM, SOUND_MIXER_PCM},
4080
4081         {UATI_MICROPHONE, SOUND_MIXER_MIC},
4082         {UATI_DESKMICROPHONE, SOUND_MIXER_MIC},
4083         {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC},
4084         {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC},
4085         {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC},
4086         {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC},
4087
4088         {UATO_SPEAKER, SOUND_MIXER_SPEAKER},
4089         {UATO_DESKTOPSPEAKER, SOUND_MIXER_SPEAKER},
4090         {UATO_ROOMSPEAKER, SOUND_MIXER_SPEAKER},
4091         {UATO_COMMSPEAKER, SOUND_MIXER_SPEAKER},
4092
4093         {UATE_ANALOGCONN, SOUND_MIXER_LINE},
4094         {UATE_LINECONN, SOUND_MIXER_LINE},
4095         {UATE_LEGACYCONN, SOUND_MIXER_LINE},
4096
4097         {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM},
4098         {UATE_SPDIF, SOUND_MIXER_ALTPCM},
4099         {UATE_1394DA, SOUND_MIXER_ALTPCM},
4100         {UATE_1394DV, SOUND_MIXER_ALTPCM},
4101
4102         {UATF_CDPLAYER, SOUND_MIXER_CD},
4103
4104         {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH},
4105
4106         {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO},
4107         {UATF_DVDAUDIO, SOUND_MIXER_VIDEO},
4108         {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO},
4109
4110         /* telephony terminal types */
4111         {UATT_UNDEFINED, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4112         {UATT_PHONELINE, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4113         {UATT_TELEPHONE, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
4114         {UATT_DOWNLINEPHONE, SOUND_MIXER_PHONEIN},      /* SOUND_MIXER_PHONEOUT */
4115
4116         {UATF_RADIORECV, SOUND_MIXER_RADIO},
4117         {UATF_RADIOXMIT, SOUND_MIXER_RADIO},
4118
4119         {UAT_UNDEFINED, SOUND_MIXER_VOLUME},
4120         {UAT_VENDOR, SOUND_MIXER_VOLUME},
4121         {UATI_UNDEFINED, SOUND_MIXER_VOLUME},
4122
4123         /* output terminal types */
4124         {UATO_UNDEFINED, SOUND_MIXER_VOLUME},
4125         {UATO_DISPLAYAUDIO, SOUND_MIXER_VOLUME},
4126         {UATO_SUBWOOFER, SOUND_MIXER_VOLUME},
4127         {UATO_HEADPHONES, SOUND_MIXER_VOLUME},
4128
4129         /* bidir terminal types */
4130         {UATB_UNDEFINED, SOUND_MIXER_VOLUME},
4131         {UATB_HANDSET, SOUND_MIXER_VOLUME},
4132         {UATB_HEADSET, SOUND_MIXER_VOLUME},
4133         {UATB_SPEAKERPHONE, SOUND_MIXER_VOLUME},
4134         {UATB_SPEAKERPHONEESUP, SOUND_MIXER_VOLUME},
4135         {UATB_SPEAKERPHONEECANC, SOUND_MIXER_VOLUME},
4136
4137         /* external terminal types */
4138         {UATE_UNDEFINED, SOUND_MIXER_VOLUME},
4139
4140         /* embedded function terminal types */
4141         {UATF_UNDEFINED, SOUND_MIXER_VOLUME},
4142         {UATF_CALIBNOISE, SOUND_MIXER_VOLUME},
4143         {UATF_EQUNOISE, SOUND_MIXER_VOLUME},
4144         {UATF_DAT, SOUND_MIXER_VOLUME},
4145         {UATF_DCC, SOUND_MIXER_VOLUME},
4146         {UATF_MINIDISK, SOUND_MIXER_VOLUME},
4147         {UATF_ANALOGTAPE, SOUND_MIXER_VOLUME},
4148         {UATF_PHONOGRAPH, SOUND_MIXER_VOLUME},
4149         {UATF_VCRAUDIO, SOUND_MIXER_VOLUME},
4150         {UATF_SATELLITE, SOUND_MIXER_VOLUME},
4151         {UATF_CABLETUNER, SOUND_MIXER_VOLUME},
4152         {UATF_DSS, SOUND_MIXER_VOLUME},
4153         {UATF_MULTITRACK, SOUND_MIXER_VOLUME},
4154         {0xffff, SOUND_MIXER_VOLUME},
4155
4156         /* default */
4157         {0x0000, SOUND_MIXER_VOLUME},
4158 };
4159
4160 static uint16_t
4161 uaudio_mixer_feature_name(const struct uaudio_terminal_node *iot,
4162     struct uaudio_mixer_node *mix)
4163 {
4164         const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature;
4165         uint16_t terminal_type = uaudio_mixer_determine_class(iot, mix);
4166
4167         if ((mix->class == UAC_RECORD) && (terminal_type == 0)) {
4168                 return (SOUND_MIXER_IMIX);
4169         }
4170         while (uat->terminal_type) {
4171                 if (uat->terminal_type == terminal_type) {
4172                         break;
4173                 }
4174                 uat++;
4175         }
4176
4177         DPRINTF("terminal_type=0x%04x -> %d\n",
4178             terminal_type, uat->feature);
4179
4180         return (uat->feature);
4181 }
4182
4183 static uint16_t
4184 uaudio20_mixer_feature_name(const struct uaudio_terminal_node *iot,
4185     struct uaudio_mixer_node *mix)
4186 {
4187         const struct uaudio_tt_to_feature *uat;
4188         uint16_t terminal_type = uaudio20_mixer_determine_class(iot, mix);
4189
4190         if ((mix->class == UAC_RECORD) && (terminal_type == 0))
4191                 return (SOUND_MIXER_IMIX);
4192
4193         for (uat = uaudio_tt_to_feature; uat->terminal_type != 0; uat++) {
4194                 if (uat->terminal_type == terminal_type)
4195                         break;
4196         }
4197
4198         DPRINTF("terminal_type=0x%04x -> %d\n",
4199             terminal_type, uat->feature);
4200
4201         return (uat->feature);
4202 }
4203
4204 static const struct uaudio_terminal_node *
4205 uaudio_mixer_get_input(const struct uaudio_terminal_node *iot, uint8_t i)
4206 {
4207         struct uaudio_terminal_node *root = iot->root;
4208         uint8_t n;
4209
4210         n = iot->usr.id_max;
4211         do {
4212                 if (iot->usr.bit_input[n / 8] & (1 << (n % 8))) {
4213                         if (!i--)
4214                                 return (root + n);
4215                 }
4216         } while (n--);
4217
4218         return (NULL);
4219 }
4220
4221 static const struct uaudio_terminal_node *
4222 uaudio_mixer_get_output(const struct uaudio_terminal_node *iot, uint8_t i)
4223 {
4224         struct uaudio_terminal_node *root = iot->root;
4225         uint8_t n;
4226
4227         n = iot->usr.id_max;
4228         do {
4229                 if (iot->usr.bit_output[n / 8] & (1 << (n % 8))) {
4230                         if (!i--)
4231                                 return (root + n);
4232                 }
4233         } while (n--);
4234
4235         return (NULL);
4236 }
4237
4238 static void
4239 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4240     const uint8_t *p_id, uint8_t n_id,
4241     struct uaudio_search_result *info)
4242 {
4243         struct uaudio_terminal_node *iot;
4244         uint8_t n;
4245         uint8_t i;
4246         uint8_t is_last;
4247
4248 top:
4249         for (n = 0; n < n_id; n++) {
4250
4251                 i = p_id[n];
4252
4253                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4254                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4255                         return;
4256                 }
4257
4258                 info->recurse_level++;
4259
4260                 iot = (root + i);
4261
4262                 if (iot->u.desc == NULL)
4263                         continue;
4264
4265                 is_last = ((n + 1) == n_id);
4266
4267                 switch (iot->u.desc->bDescriptorSubtype) {
4268                 case UDESCSUB_AC_INPUT:
4269                         info->bit_input[i / 8] |= (1 << (i % 8));
4270                         break;
4271
4272                 case UDESCSUB_AC_FEATURE:
4273                         if (is_last) {
4274                                 p_id = &iot->u.fu_v1->bSourceId;
4275                                 n_id = 1;
4276                                 goto top;
4277                         }
4278                         uaudio_mixer_find_inputs_sub(
4279                             root, &iot->u.fu_v1->bSourceId, 1, info);
4280                         break;
4281
4282                 case UDESCSUB_AC_OUTPUT:
4283                         if (is_last) {
4284                                 p_id = &iot->u.ot_v1->bSourceId;
4285                                 n_id = 1;
4286                                 goto top;
4287                         }
4288                         uaudio_mixer_find_inputs_sub(
4289                             root, &iot->u.ot_v1->bSourceId, 1, info);
4290                         break;
4291
4292                 case UDESCSUB_AC_MIXER:
4293                         if (is_last) {
4294                                 p_id = iot->u.mu_v1->baSourceId;
4295                                 n_id = iot->u.mu_v1->bNrInPins;
4296                                 goto top;
4297                         }
4298                         uaudio_mixer_find_inputs_sub(
4299                             root, iot->u.mu_v1->baSourceId,
4300                             iot->u.mu_v1->bNrInPins, info);
4301                         break;
4302
4303                 case UDESCSUB_AC_SELECTOR:
4304                         if (is_last) {
4305                                 p_id = iot->u.su_v1->baSourceId;
4306                                 n_id = iot->u.su_v1->bNrInPins;
4307                                 goto top;
4308                         }
4309                         uaudio_mixer_find_inputs_sub(
4310                             root, iot->u.su_v1->baSourceId,
4311                             iot->u.su_v1->bNrInPins, info);
4312                         break;
4313
4314                 case UDESCSUB_AC_PROCESSING:
4315                         if (is_last) {
4316                                 p_id = iot->u.pu_v1->baSourceId;
4317                                 n_id = iot->u.pu_v1->bNrInPins;
4318                                 goto top;
4319                         }
4320                         uaudio_mixer_find_inputs_sub(
4321                             root, iot->u.pu_v1->baSourceId,
4322                             iot->u.pu_v1->bNrInPins, info);
4323                         break;
4324
4325                 case UDESCSUB_AC_EXTENSION:
4326                         if (is_last) {
4327                                 p_id = iot->u.eu_v1->baSourceId;
4328                                 n_id = iot->u.eu_v1->bNrInPins;
4329                                 goto top;
4330                         }
4331                         uaudio_mixer_find_inputs_sub(
4332                             root, iot->u.eu_v1->baSourceId,
4333                             iot->u.eu_v1->bNrInPins, info);
4334                         break;
4335
4336                 default:
4337                         break;
4338                 }
4339         }
4340 }
4341
4342 static void
4343 uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4344     const uint8_t *p_id, uint8_t n_id,
4345     struct uaudio_search_result *info)
4346 {
4347         struct uaudio_terminal_node *iot;
4348         uint8_t n;
4349         uint8_t i;
4350         uint8_t is_last;
4351
4352 top:
4353         for (n = 0; n < n_id; n++) {
4354
4355                 i = p_id[n];
4356
4357                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4358                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4359                         return;
4360                 }
4361
4362                 info->recurse_level++;
4363
4364                 iot = (root + i);
4365
4366                 if (iot->u.desc == NULL)
4367                         continue;
4368
4369                 is_last = ((n + 1) == n_id);
4370
4371                 switch (iot->u.desc->bDescriptorSubtype) {
4372                 case UDESCSUB_AC_INPUT:
4373                         info->bit_input[i / 8] |= (1 << (i % 8));
4374                         break;
4375
4376                 case UDESCSUB_AC_OUTPUT:
4377                         if (is_last) {
4378                                 p_id = &iot->u.ot_v2->bSourceId;
4379                                 n_id = 1;
4380                                 goto top;
4381                         }
4382                         uaudio20_mixer_find_inputs_sub(
4383                             root, &iot->u.ot_v2->bSourceId, 1, info);
4384                         break;
4385
4386                 case UDESCSUB_AC_MIXER:
4387                         if (is_last) {
4388                                 p_id = iot->u.mu_v2->baSourceId;
4389                                 n_id = iot->u.mu_v2->bNrInPins;
4390                                 goto top;
4391                         }
4392                         uaudio20_mixer_find_inputs_sub(
4393                             root, iot->u.mu_v2->baSourceId,
4394                             iot->u.mu_v2->bNrInPins, info);
4395                         break;
4396
4397                 case UDESCSUB_AC_SELECTOR:
4398                         if (is_last) {
4399                                 p_id = iot->u.su_v2->baSourceId;
4400                                 n_id = iot->u.su_v2->bNrInPins;
4401                                 goto top;
4402                         }
4403                         uaudio20_mixer_find_inputs_sub(
4404                             root, iot->u.su_v2->baSourceId,
4405                             iot->u.su_v2->bNrInPins, info);
4406                         break;
4407
4408                 case UDESCSUB_AC_SAMPLE_RT:
4409                         if (is_last) {
4410                                 p_id = &iot->u.ru_v2->bSourceId;
4411                                 n_id = 1;
4412                                 goto top;
4413                         }
4414                         uaudio20_mixer_find_inputs_sub(
4415                             root, &iot->u.ru_v2->bSourceId,
4416                             1, info);
4417                         break;
4418
4419                 case UDESCSUB_AC_EFFECT:
4420                         if (is_last) {
4421                                 p_id = &iot->u.ef_v2->bSourceId;
4422                                 n_id = 1;
4423                                 goto top;
4424                         }
4425                         uaudio20_mixer_find_inputs_sub(
4426                             root, &iot->u.ef_v2->bSourceId,
4427                             1, info);
4428                         break;
4429
4430                 case UDESCSUB_AC_FEATURE:
4431                         if (is_last) {
4432                                 p_id = &iot->u.fu_v2->bSourceId;
4433                                 n_id = 1;
4434                                 goto top;
4435                         }
4436                         uaudio20_mixer_find_inputs_sub(
4437                             root, &iot->u.fu_v2->bSourceId, 1, info);
4438                         break;
4439
4440                 case UDESCSUB_AC_PROCESSING_V2:
4441                         if (is_last) {
4442                                 p_id = iot->u.pu_v2->baSourceId;
4443                                 n_id = iot->u.pu_v2->bNrInPins;
4444                                 goto top;
4445                         }
4446                         uaudio20_mixer_find_inputs_sub(
4447                             root, iot->u.pu_v2->baSourceId,
4448                             iot->u.pu_v2->bNrInPins, info);
4449                         break;
4450
4451                 case UDESCSUB_AC_EXTENSION_V2:
4452                         if (is_last) {
4453                                 p_id = iot->u.eu_v2->baSourceId;
4454                                 n_id = iot->u.eu_v2->bNrInPins;
4455                                 goto top;
4456                         }
4457                         uaudio20_mixer_find_inputs_sub(
4458                             root, iot->u.eu_v2->baSourceId,
4459                             iot->u.eu_v2->bNrInPins, info);
4460                         break;
4461                 default:
4462                         break;
4463                 }
4464         }
4465 }
4466
4467 static void
4468 uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root,
4469     const uint8_t *p_id, uint8_t n_id,
4470     struct uaudio_search_result *info)
4471 {
4472         struct uaudio_terminal_node *iot;
4473         uint8_t n;
4474         uint8_t i;
4475         uint8_t is_last;
4476         uint8_t id;
4477
4478 top:
4479         for (n = 0; n < n_id; n++) {
4480
4481                 i = p_id[n];
4482
4483                 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4484                         DPRINTF("avoided going into a circle at id=%d!\n", i);
4485                         return;
4486                 }
4487
4488                 info->recurse_level++;
4489
4490                 iot = (root + i);
4491
4492                 if (iot->u.desc == NULL)
4493                         continue;
4494
4495                 is_last = ((n + 1) == n_id);
4496
4497                 switch (iot->u.desc->bDescriptorSubtype) {
4498                 case UDESCSUB_AC_INPUT:
4499                         info->is_input = 1;
4500                         if (is_last) {
4501                                 p_id = &iot->u.it_v2->bCSourceId;
4502                                 n_id = 1;
4503                                 goto top;
4504                         }
4505                         uaudio20_mixer_find_clocks_sub(root,
4506                             &iot->u.it_v2->bCSourceId, 1, info);
4507                         break;
4508
4509                 case UDESCSUB_AC_OUTPUT:
4510                         info->is_input = 0;
4511                         if (is_last) {
4512                                 p_id = &iot->u.ot_v2->bCSourceId;
4513                                 n_id = 1;
4514                                 goto top;
4515                         }
4516                         uaudio20_mixer_find_clocks_sub(root,
4517                             &iot->u.ot_v2->bCSourceId, 1, info);
4518                         break;
4519
4520                 case UDESCSUB_AC_CLOCK_SEL:
4521                         if (is_last) {
4522                                 p_id = iot->u.csel_v2->baCSourceId;
4523                                 n_id = iot->u.csel_v2->bNrInPins;
4524                                 goto top;
4525                         }
4526                         uaudio20_mixer_find_clocks_sub(root,
4527                             iot->u.csel_v2->baCSourceId,
4528                             iot->u.csel_v2->bNrInPins, info);
4529                         break;
4530
4531                 case UDESCSUB_AC_CLOCK_MUL:
4532                         if (is_last) {
4533                                 p_id = &iot->u.cmul_v2->bCSourceId;
4534                                 n_id = 1;
4535                                 goto top;
4536                         }
4537                         uaudio20_mixer_find_clocks_sub(root,
4538                             &iot->u.cmul_v2->bCSourceId,
4539                             1, info);
4540                         break;
4541
4542                 case UDESCSUB_AC_CLOCK_SRC:
4543
4544                         id = iot->u.csrc_v2->bClockId;
4545
4546                         switch (info->is_input) {
4547                         case 0:
4548                                 info->bit_output[id / 8] |= (1 << (id % 8));
4549                                 break;
4550                         case 1:
4551                                 info->bit_input[id / 8] |= (1 << (id % 8));
4552                                 break;
4553                         default:
4554                                 break;
4555                         }
4556                         break;
4557
4558                 default:
4559                         break;
4560                 }
4561         }
4562 }
4563
4564 static void
4565 uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *root, uint8_t id,
4566     uint8_t n_id, struct uaudio_search_result *info)
4567 {
4568         struct uaudio_terminal_node *iot = (root + id);
4569         uint8_t j;
4570
4571         j = n_id;
4572         do {
4573                 if ((j != id) && ((root + j)->u.desc) &&
4574                     ((root + j)->u.desc->bDescriptorSubtype == UDESCSUB_AC_OUTPUT)) {
4575
4576                         /*
4577                          * "j" (output) <--- virtual wire <--- "id" (input)
4578                          *
4579                          * if "j" has "id" on the input, then "id" have "j" on
4580                          * the output, because they are connected:
4581                          */
4582                         if ((root + j)->usr.bit_input[id / 8] & (1 << (id % 8))) {
4583                                 iot->usr.bit_output[j / 8] |= (1 << (j % 8));
4584                         }
4585                 }
4586         } while (j--);
4587 }
4588
4589 static void
4590 uaudio_mixer_fill_info(struct uaudio_softc *sc,
4591     struct usb_device *udev, void *desc)
4592 {
4593         const struct usb_audio_control_descriptor *acdp;
4594         struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
4595         const struct usb_descriptor *dp;
4596         const struct usb_audio_unit *au;
4597         struct uaudio_terminal_node *iot = NULL;
4598         uint16_t wTotalLen;
4599         uint8_t ID_max = 0;             /* inclusive */
4600         uint8_t i;
4601
4602         desc = usb_desc_foreach(cd, desc);
4603
4604         if (desc == NULL) {
4605                 DPRINTF("no Audio Control header\n");
4606                 goto done;
4607         }
4608         acdp = desc;
4609
4610         if ((acdp->bLength < sizeof(*acdp)) ||
4611             (acdp->bDescriptorType != UDESC_CS_INTERFACE) ||
4612             (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) {
4613                 DPRINTF("invalid Audio Control header\n");
4614                 goto done;
4615         }
4616         /* "wTotalLen" is allowed to be corrupt */
4617         wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength;
4618
4619         /* get USB audio revision */
4620         sc->sc_audio_rev = UGETW(acdp->bcdADC);
4621
4622         DPRINTFN(3, "found AC header, vers=%03x, len=%d\n",
4623             sc->sc_audio_rev, wTotalLen);
4624
4625         iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP,
4626             M_WAITOK | M_ZERO);
4627
4628         if (iot == NULL) {
4629                 DPRINTF("no memory!\n");
4630                 goto done;
4631         }
4632         while ((desc = usb_desc_foreach(cd, desc))) {
4633
4634                 dp = desc;
4635
4636                 if (dp->bLength > wTotalLen) {
4637                         break;
4638                 } else {
4639                         wTotalLen -= dp->bLength;
4640                 }
4641
4642                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30)
4643                         au = NULL;
4644                 else if (sc->sc_audio_rev >= UAUDIO_VERSION_20)
4645                         au = uaudio20_mixer_verify_desc(dp, 0);
4646                 else
4647                         au = uaudio_mixer_verify_desc(dp, 0);
4648
4649                 if (au) {
4650                         iot[au->bUnitId].u.desc = (const void *)au;
4651                         if (au->bUnitId > ID_max)
4652                                 ID_max = au->bUnitId;
4653                 }
4654         }
4655
4656         DPRINTF("Maximum ID=%d\n", ID_max);
4657
4658         /*
4659          * determine sourcing inputs for
4660          * all nodes in the tree:
4661          */
4662         i = ID_max;
4663         do {
4664                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
4665                         /* FALLTHROUGH */
4666                 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
4667                         uaudio20_mixer_find_inputs_sub(iot,
4668                             &i, 1, &((iot + i)->usr));
4669
4670                         sc->sc_mixer_clocks.is_input = 255;
4671                         sc->sc_mixer_clocks.recurse_level = 0;
4672
4673                         uaudio20_mixer_find_clocks_sub(iot,
4674                             &i, 1, &sc->sc_mixer_clocks);
4675                 } else {
4676                         uaudio_mixer_find_inputs_sub(iot,
4677                             &i, 1, &((iot + i)->usr));
4678                 }
4679         } while (i--);
4680
4681         /*
4682          * determine outputs for
4683          * all nodes in the tree:
4684          */
4685         i = ID_max;
4686         do {
4687                 uaudio_mixer_find_outputs_sub(iot,
4688                     i, ID_max, &((iot + i)->usr));
4689         } while (i--);
4690
4691         /* set "id_max" and "root" */
4692
4693         i = ID_max;
4694         do {
4695                 (iot + i)->usr.id_max = ID_max;
4696                 (iot + i)->root = iot;
4697         } while (i--);
4698
4699         /*
4700          * Scan the config to create a linked list of "mixer" nodes:
4701          */
4702
4703         i = ID_max;
4704         do {
4705                 dp = iot[i].u.desc;
4706
4707                 if (dp == NULL)
4708                         continue;
4709
4710                 DPRINTFN(11, "id=%d subtype=%d\n",
4711                     i, dp->bDescriptorSubtype);
4712
4713                 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
4714                         continue;
4715                 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
4716
4717                         switch (dp->bDescriptorSubtype) {
4718                         case UDESCSUB_AC_HEADER:
4719                                 DPRINTF("unexpected AC header\n");
4720                                 break;
4721
4722                         case UDESCSUB_AC_INPUT:
4723                         case UDESCSUB_AC_OUTPUT:
4724                         case UDESCSUB_AC_PROCESSING_V2:
4725                         case UDESCSUB_AC_EXTENSION_V2:
4726                         case UDESCSUB_AC_EFFECT:
4727                         case UDESCSUB_AC_CLOCK_SRC:
4728                         case UDESCSUB_AC_CLOCK_SEL:
4729                         case UDESCSUB_AC_CLOCK_MUL:
4730                         case UDESCSUB_AC_SAMPLE_RT:
4731                                 break;
4732
4733                         case UDESCSUB_AC_MIXER:
4734                                 uaudio20_mixer_add_mixer(sc, iot, i);
4735                                 break;
4736
4737                         case UDESCSUB_AC_SELECTOR:
4738                                 uaudio20_mixer_add_selector(sc, iot, i);
4739                                 break;
4740
4741                         case UDESCSUB_AC_FEATURE:
4742                                 uaudio20_mixer_add_feature(sc, iot, i);
4743                                 break;
4744
4745                         default:
4746                                 DPRINTF("bad AC desc subtype=0x%02x\n",
4747                                     dp->bDescriptorSubtype);
4748                                 break;
4749                         }
4750                         continue;
4751                 }
4752
4753                 switch (dp->bDescriptorSubtype) {
4754                 case UDESCSUB_AC_HEADER:
4755                         DPRINTF("unexpected AC header\n");
4756                         break;
4757
4758                 case UDESCSUB_AC_INPUT:
4759                 case UDESCSUB_AC_OUTPUT:
4760                         break;
4761
4762                 case UDESCSUB_AC_MIXER:
4763                         uaudio_mixer_add_mixer(sc, iot, i);
4764                         break;
4765
4766                 case UDESCSUB_AC_SELECTOR:
4767                         uaudio_mixer_add_selector(sc, iot, i);
4768                         break;
4769
4770                 case UDESCSUB_AC_FEATURE:
4771                         uaudio_mixer_add_feature(sc, iot, i);
4772                         break;
4773
4774                 case UDESCSUB_AC_PROCESSING:
4775                         uaudio_mixer_add_processing(sc, iot, i);
4776                         break;
4777
4778                 case UDESCSUB_AC_EXTENSION:
4779                         uaudio_mixer_add_extension(sc, iot, i);
4780                         break;
4781
4782                 default:
4783                         DPRINTF("bad AC desc subtype=0x%02x\n",
4784                             dp->bDescriptorSubtype);
4785                         break;
4786                 }
4787
4788         } while (i--);
4789
4790 done:
4791         free(iot, M_TEMP);
4792 }
4793
4794 static int
4795 uaudio_mixer_get(struct usb_device *udev, uint16_t audio_rev,
4796     uint8_t what, struct uaudio_mixer_node *mc)
4797 {
4798         struct usb_device_request req;
4799         int val;
4800         uint8_t data[2 + (2 * 3)];
4801         usb_error_t err;
4802
4803         if (mc->wValue[0] == -1)
4804                 return (0);
4805
4806         if (audio_rev >= UAUDIO_VERSION_30)
4807                 return (0);
4808         else if (audio_rev >= UAUDIO_VERSION_20) {
4809                 if (what == GET_CUR) {
4810                         req.bRequest = UA20_CS_CUR;
4811                         USETW(req.wLength, 2);
4812                 } else {
4813                         req.bRequest = UA20_CS_RANGE;
4814                         USETW(req.wLength, 8);
4815                 }
4816         } else {
4817                 uint16_t len = MIX_SIZE(mc->type);
4818
4819                 req.bRequest = what;
4820                 USETW(req.wLength, len);
4821         }
4822
4823         req.bmRequestType = UT_READ_CLASS_INTERFACE;
4824         USETW(req.wValue, mc->wValue[0]);
4825         USETW(req.wIndex, mc->wIndex);
4826
4827         memset(data, 0, sizeof(data));
4828
4829         err = usbd_do_request(udev, NULL, &req, data);
4830         if (err) {
4831                 DPRINTF("err=%s\n", usbd_errstr(err));
4832                 return (0);
4833         }
4834
4835         if (audio_rev >= UAUDIO_VERSION_30) {
4836                 val = 0;
4837         } else if (audio_rev >= UAUDIO_VERSION_20) {
4838                 switch (what) {
4839                 case GET_CUR:
4840                         val = (data[0] | (data[1] << 8));
4841                         break;
4842                 case GET_MIN:
4843                         val = (data[2] | (data[3] << 8));
4844                         break;
4845                 case GET_MAX:
4846                         val = (data[4] | (data[5] << 8));
4847                         break;
4848                 case GET_RES:
4849                         val = (data[6] | (data[7] << 8));
4850                         break;
4851                 default:
4852                         val = 0;
4853                         break;
4854                 }
4855         } else {
4856                 val = (data[0] | (data[1] << 8));
4857         }
4858
4859         if (what == GET_CUR || what == GET_MIN || what == GET_MAX)
4860                 val = uaudio_mixer_signext(mc->type, val);
4861
4862         DPRINTFN(3, "val=%d\n", val);
4863
4864         return (val);
4865 }
4866
4867 static void
4868 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error)
4869 {
4870         struct usb_device_request req;
4871         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
4872         struct uaudio_mixer_node *mc = sc->sc_mixer_curr;
4873         struct usb_page_cache *pc;
4874         uint16_t len;
4875         uint8_t repeat = 1;
4876         uint8_t update;
4877         uint8_t chan;
4878         uint8_t buf[2];
4879
4880         DPRINTF("\n");
4881
4882         switch (USB_GET_STATE(xfer)) {
4883         case USB_ST_TRANSFERRED:
4884 tr_transferred:
4885         case USB_ST_SETUP:
4886 tr_setup:
4887
4888                 if (mc == NULL) {
4889                         mc = sc->sc_mixer_root;
4890                         sc->sc_mixer_curr = mc;
4891                         sc->sc_mixer_chan = 0;
4892                         repeat = 0;
4893                 }
4894                 while (mc) {
4895                         while (sc->sc_mixer_chan < mc->nchan) {
4896
4897                                 chan = sc->sc_mixer_chan;
4898
4899                                 sc->sc_mixer_chan++;
4900
4901                                 update = ((mc->update[chan / 8] & (1 << (chan % 8))) &&
4902                                     (mc->wValue[chan] != -1));
4903
4904                                 mc->update[chan / 8] &= ~(1 << (chan % 8));
4905
4906                                 if (update) {
4907
4908                                         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
4909                                         USETW(req.wValue, mc->wValue[chan]);
4910                                         USETW(req.wIndex, mc->wIndex);
4911
4912                                         if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
4913                                                 return;
4914                                         } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
4915                                                 len = 2;
4916                                                 req.bRequest = UA20_CS_CUR;
4917                                                 USETW(req.wLength, len);
4918                                         } else {
4919                                                 len = MIX_SIZE(mc->type);
4920                                                 req.bRequest = SET_CUR;
4921                                                 USETW(req.wLength, len);
4922                                         }
4923
4924                                         buf[0] = (mc->wData[chan] & 0xFF);
4925                                         buf[1] = (mc->wData[chan] >> 8) & 0xFF;
4926
4927                                         pc = usbd_xfer_get_frame(xfer, 0);
4928                                         usbd_copy_in(pc, 0, &req, sizeof(req));
4929                                         pc = usbd_xfer_get_frame(xfer, 1);
4930                                         usbd_copy_in(pc, 0, buf, len);
4931
4932                                         usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
4933                                         usbd_xfer_set_frame_len(xfer, 1, len);
4934                                         usbd_xfer_set_frames(xfer, len ? 2 : 1);
4935                                         usbd_transfer_submit(xfer);
4936                                         return;
4937                                 }
4938                         }
4939
4940                         mc = mc->next;
4941                         sc->sc_mixer_curr = mc;
4942                         sc->sc_mixer_chan = 0;
4943                 }
4944
4945                 if (repeat) {
4946                         goto tr_setup;
4947                 }
4948                 break;
4949
4950         default:                        /* Error */
4951                 DPRINTF("error=%s\n", usbd_errstr(error));
4952                 if (error == USB_ERR_CANCELLED) {
4953                         /* do nothing - we are detaching */
4954                         break;
4955                 }
4956                 goto tr_transferred;
4957         }
4958 }
4959
4960 static usb_error_t
4961 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)
4962 {
4963         struct usb_device_request req;
4964         uint8_t data[3];
4965
4966         DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed);
4967
4968         req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
4969         req.bRequest = SET_CUR;
4970         USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
4971         USETW(req.wIndex, endpt);
4972         USETW(req.wLength, 3);
4973         data[0] = speed;
4974         data[1] = speed >> 8;
4975         data[2] = speed >> 16;
4976
4977         return (usbd_do_request(udev, NULL, &req, data));
4978 }
4979
4980 static usb_error_t
4981 uaudio20_set_speed(struct usb_device *udev, uint8_t iface_no,
4982     uint8_t clockid, uint32_t speed)
4983 {
4984         struct usb_device_request req;
4985         uint8_t data[4];
4986
4987         DPRINTFN(6, "ifaceno=%d clockid=%d speed=%u\n",
4988             iface_no, clockid, speed);
4989
4990         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
4991         req.bRequest = UA20_CS_CUR;
4992         USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
4993         USETW2(req.wIndex, clockid, iface_no);
4994         USETW(req.wLength, 4);
4995         data[0] = speed;
4996         data[1] = speed >> 8;
4997         data[2] = speed >> 16;
4998         data[3] = speed >> 24;
4999
5000         return (usbd_do_request(udev, NULL, &req, data));
5001 }
5002
5003 static int
5004 uaudio_mixer_signext(uint8_t type, int val)
5005 {
5006         if (!MIX_UNSIGNED(type)) {
5007                 if (MIX_SIZE(type) == 2) {
5008                         val = (int16_t)val;
5009                 } else {
5010                         val = (int8_t)val;
5011                 }
5012         }
5013         return (val);
5014 }
5015
5016 static int
5017 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int32_t val)
5018 {
5019         if (mc->type == MIX_ON_OFF) {
5020                 val = (val != 0);
5021         } else if (mc->type == MIX_SELECTOR) {
5022                 if ((val < mc->minval) ||
5023                     (val > mc->maxval)) {
5024                         val = mc->minval;
5025                 }
5026         } else {
5027
5028                 /* compute actual volume */
5029                 val = (val * mc->mul) / 255;
5030
5031                 /* add lower offset */
5032                 val = val + mc->minval;
5033
5034                 /* make sure we don't write a value out of range */
5035                 if (val > mc->maxval)
5036                         val = mc->maxval;
5037                 else if (val < mc->minval)
5038                         val = mc->minval;
5039         }
5040
5041         DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n",
5042             mc->type, val, mc->minval, mc->maxval, val);
5043         return (val);
5044 }
5045
5046 static void
5047 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc,
5048     uint8_t chan, int32_t val)
5049 {
5050         val = uaudio_mixer_bsd2value(mc, val);
5051
5052         mc->update[chan / 8] |= (1 << (chan % 8));
5053         mc->wData[chan] = val;
5054
5055         /* start the transfer, if not already started */
5056
5057         usbd_transfer_start(sc->sc_mixer_xfer[0]);
5058 }
5059
5060 static void
5061 uaudio_mixer_init(struct uaudio_softc *sc)
5062 {
5063         struct uaudio_mixer_node *mc;
5064         int32_t i;
5065
5066         for (mc = sc->sc_mixer_root; mc;
5067             mc = mc->next) {
5068
5069                 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
5070                         /*
5071                          * Set device mask bits. See
5072                          * /usr/include/machine/soundcard.h
5073                          */
5074                         sc->sc_mix_info |= (1 << mc->ctl);
5075                 }
5076                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5077                     (mc->type == MIX_SELECTOR)) {
5078
5079                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5080                                 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES) {
5081                                         continue;
5082                                 }
5083                                 sc->sc_recsrc_info |= 1 << mc->slctrtype[i - 1];
5084                         }
5085                 }
5086         }
5087 }
5088
5089 int
5090 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5091 {
5092         DPRINTF("\n");
5093
5094         sc->sc_mixer_lock = mixer_get_lock(m);
5095         sc->sc_mixer_dev = m;
5096
5097         if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
5098             sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
5099             sc->sc_mixer_lock)) {
5100                 DPRINTFN(0, "could not allocate USB "
5101                     "transfer for audio mixer!\n");
5102                 return (ENOMEM);
5103         }
5104         if (!(sc->sc_mix_info & SOUND_MASK_VOLUME)) {
5105                 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM);
5106                 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE);
5107         }
5108         mix_setdevs(m, sc->sc_mix_info);
5109         mix_setrecdevs(m, sc->sc_recsrc_info);
5110         return (0);
5111 }
5112
5113 int
5114 uaudio_mixer_uninit_sub(struct uaudio_softc *sc)
5115 {
5116         DPRINTF("\n");
5117
5118         usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
5119
5120         sc->sc_mixer_lock = NULL;
5121
5122         return (0);
5123 }
5124
5125 void
5126 uaudio_mixer_set(struct uaudio_softc *sc, unsigned type,
5127     unsigned left, unsigned right)
5128 {
5129         struct uaudio_mixer_node *mc;
5130         int chan;
5131
5132         for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) {
5133
5134                 if (mc->ctl == type) {
5135                         for (chan = 0; chan < mc->nchan; chan++) {
5136                                 uaudio_mixer_ctl_set(sc, mc, chan,
5137                                     (int)((chan == 0 ? left : right) *
5138                                     255) / 100);
5139                         }
5140                 }
5141         }
5142 }
5143
5144 uint32_t
5145 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, uint32_t src)
5146 {
5147         struct uaudio_mixer_node *mc;
5148         uint32_t mask;
5149         uint32_t temp;
5150         int32_t i;
5151
5152         for (mc = sc->sc_mixer_root; mc;
5153             mc = mc->next) {
5154
5155                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5156                     (mc->type == MIX_SELECTOR)) {
5157
5158                         /* compute selector mask */
5159
5160                         mask = 0;
5161                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5162                                 mask |= (1 << mc->slctrtype[i - 1]);
5163                         }
5164
5165                         temp = mask & src;
5166                         if (temp == 0) {
5167                                 continue;
5168                         }
5169                         /* find the first set bit */
5170                         temp = (-temp) & temp;
5171
5172                         /* update "src" */
5173                         src &= ~mask;
5174                         src |= temp;
5175
5176                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5177                                 if (temp != (1 << mc->slctrtype[i - 1])) {
5178                                         continue;
5179                                 }
5180                                 uaudio_mixer_ctl_set(sc, mc, 0, i);
5181                                 break;
5182                         }
5183                 }
5184         }
5185         return (src);
5186 }
5187
5188 /*========================================================================*
5189  * MIDI support routines
5190  *========================================================================*/
5191
5192 static void
5193 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
5194 {
5195         struct umidi_chan *chan = usbd_xfer_softc(xfer);
5196         struct umidi_sub_chan *sub;
5197         struct usb_page_cache *pc;
5198         uint8_t buf[4];
5199         uint8_t cmd_len;
5200         uint8_t cn;
5201         uint16_t pos;
5202         int actlen;
5203
5204         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
5205
5206         switch (USB_GET_STATE(xfer)) {
5207         case USB_ST_TRANSFERRED:
5208
5209                 DPRINTF("actlen=%d bytes\n", actlen);
5210
5211                 pos = 0;
5212                 pc = usbd_xfer_get_frame(xfer, 0);
5213
5214                 while (actlen >= 4) {
5215
5216                         /* copy out the MIDI data */
5217                         usbd_copy_out(pc, pos, buf, 4);
5218                         /* command length */
5219                         cmd_len = umidi_cmd_to_len[buf[0] & 0xF];
5220                         /* cable number */
5221                         cn = buf[0] >> 4;
5222                         /*
5223                          * Lookup sub-channel. The index is range
5224                          * checked below.
5225                          */
5226                         sub = &chan->sub[cn];
5227
5228                         if ((cmd_len != 0) &&
5229                             (cn < chan->max_cable) &&
5230                             (sub->read_open != 0)) {
5231
5232                                 /* Send data to the application */
5233                                 usb_fifo_put_data_linear(
5234                                     sub->fifo.fp[USB_FIFO_RX],
5235                                     buf + 1, cmd_len, 1);
5236                         }
5237                         actlen -= 4;
5238                         pos += 4;
5239                 }
5240
5241         case USB_ST_SETUP:
5242                 DPRINTF("start\n");
5243 tr_setup:
5244                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
5245                 usbd_transfer_submit(xfer);
5246                 break;
5247
5248         default:
5249                 DPRINTF("error=%s\n", usbd_errstr(error));
5250
5251                 if (error != USB_ERR_CANCELLED) {
5252                         /* try to clear stall first */
5253                         usbd_xfer_set_stall(xfer);
5254                         goto tr_setup;
5255                 }
5256                 break;
5257         }
5258 }
5259
5260 /*
5261  * The following statemachine, that converts MIDI commands to
5262  * USB MIDI packets, derives from Linux's usbmidi.c, which
5263  * was written by "Clemens Ladisch":
5264  *
5265  * Returns:
5266  *    0: No command
5267  * Else: Command is complete
5268  */
5269 static uint8_t
5270 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b)
5271 {
5272         uint8_t p0 = (cn << 4);
5273
5274         if (b >= 0xf8) {
5275                 sub->temp_0[0] = p0 | 0x0f;
5276                 sub->temp_0[1] = b;
5277                 sub->temp_0[2] = 0;
5278                 sub->temp_0[3] = 0;
5279                 sub->temp_cmd = sub->temp_0;
5280                 return (1);
5281
5282         } else if (b >= 0xf0) {
5283                 switch (b) {
5284                 case 0xf0:              /* system exclusive begin */
5285                         sub->temp_1[1] = b;
5286                         sub->state = UMIDI_ST_SYSEX_1;
5287                         break;
5288                 case 0xf1:              /* MIDI time code */
5289                 case 0xf3:              /* song select */
5290                         sub->temp_1[1] = b;
5291                         sub->state = UMIDI_ST_1PARAM;
5292                         break;
5293                 case 0xf2:              /* song position pointer */
5294                         sub->temp_1[1] = b;
5295                         sub->state = UMIDI_ST_2PARAM_1;
5296                         break;
5297                 case 0xf4:              /* unknown */
5298                 case 0xf5:              /* unknown */
5299                         sub->state = UMIDI_ST_UNKNOWN;
5300                         break;
5301                 case 0xf6:              /* tune request */
5302                         sub->temp_1[0] = p0 | 0x05;
5303                         sub->temp_1[1] = 0xf6;
5304                         sub->temp_1[2] = 0;
5305                         sub->temp_1[3] = 0;
5306                         sub->temp_cmd = sub->temp_1;
5307                         sub->state = UMIDI_ST_UNKNOWN;
5308                         return (1);
5309
5310                 case 0xf7:              /* system exclusive end */
5311                         switch (sub->state) {
5312                         case UMIDI_ST_SYSEX_0:
5313                                 sub->temp_1[0] = p0 | 0x05;
5314                                 sub->temp_1[1] = 0xf7;
5315                                 sub->temp_1[2] = 0;
5316                                 sub->temp_1[3] = 0;
5317                                 sub->temp_cmd = sub->temp_1;
5318                                 sub->state = UMIDI_ST_UNKNOWN;
5319                                 return (1);
5320                         case UMIDI_ST_SYSEX_1:
5321                                 sub->temp_1[0] = p0 | 0x06;
5322                                 sub->temp_1[2] = 0xf7;
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_2:
5328                                 sub->temp_1[0] = p0 | 0x07;
5329                                 sub->temp_1[3] = 0xf7;
5330                                 sub->temp_cmd = sub->temp_1;
5331                                 sub->state = UMIDI_ST_UNKNOWN;
5332                                 return (1);
5333                         }
5334                         sub->state = UMIDI_ST_UNKNOWN;
5335                         break;
5336                 }
5337         } else if (b >= 0x80) {
5338                 sub->temp_1[1] = b;
5339                 if ((b >= 0xc0) && (b <= 0xdf)) {
5340                         sub->state = UMIDI_ST_1PARAM;
5341                 } else {
5342                         sub->state = UMIDI_ST_2PARAM_1;
5343                 }
5344         } else {                        /* b < 0x80 */
5345                 switch (sub->state) {
5346                 case UMIDI_ST_1PARAM:
5347                         if (sub->temp_1[1] < 0xf0) {
5348                                 p0 |= sub->temp_1[1] >> 4;
5349                         } else {
5350                                 p0 |= 0x02;
5351                                 sub->state = UMIDI_ST_UNKNOWN;
5352                         }
5353                         sub->temp_1[0] = p0;
5354                         sub->temp_1[2] = b;
5355                         sub->temp_1[3] = 0;
5356                         sub->temp_cmd = sub->temp_1;
5357                         return (1);
5358                 case UMIDI_ST_2PARAM_1:
5359                         sub->temp_1[2] = b;
5360                         sub->state = UMIDI_ST_2PARAM_2;
5361                         break;
5362                 case UMIDI_ST_2PARAM_2:
5363                         if (sub->temp_1[1] < 0xf0) {
5364                                 p0 |= sub->temp_1[1] >> 4;
5365                                 sub->state = UMIDI_ST_2PARAM_1;
5366                         } else {
5367                                 p0 |= 0x03;
5368                                 sub->state = UMIDI_ST_UNKNOWN;
5369                         }
5370                         sub->temp_1[0] = p0;
5371                         sub->temp_1[3] = b;
5372                         sub->temp_cmd = sub->temp_1;
5373                         return (1);
5374                 case UMIDI_ST_SYSEX_0:
5375                         sub->temp_1[1] = b;
5376                         sub->state = UMIDI_ST_SYSEX_1;
5377                         break;
5378                 case UMIDI_ST_SYSEX_1:
5379                         sub->temp_1[2] = b;
5380                         sub->state = UMIDI_ST_SYSEX_2;
5381                         break;
5382                 case UMIDI_ST_SYSEX_2:
5383                         sub->temp_1[0] = p0 | 0x04;
5384                         sub->temp_1[3] = b;
5385                         sub->temp_cmd = sub->temp_1;
5386                         sub->state = UMIDI_ST_SYSEX_0;
5387                         return (1);
5388                 default:
5389                         break;
5390                 }
5391         }
5392         return (0);
5393 }
5394
5395 static void
5396 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
5397 {
5398         struct umidi_chan *chan = usbd_xfer_softc(xfer);
5399         struct umidi_sub_chan *sub;
5400         struct usb_page_cache *pc;
5401         uint32_t actlen;
5402         uint16_t nframes;
5403         uint8_t buf;
5404         uint8_t start_cable;
5405         uint8_t tr_any;
5406         int len;
5407
5408         usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
5409
5410         /*
5411          * NOTE: Some MIDI devices only accept 4 bytes of data per
5412          * short terminated USB transfer.
5413          */
5414         switch (USB_GET_STATE(xfer)) {
5415         case USB_ST_TRANSFERRED:
5416                 DPRINTF("actlen=%d bytes\n", len);
5417
5418         case USB_ST_SETUP:
5419 tr_setup:
5420                 DPRINTF("start\n");
5421
5422                 nframes = 0;    /* reset */
5423                 start_cable = chan->curr_cable;
5424                 tr_any = 0;
5425                 pc = usbd_xfer_get_frame(xfer, 0);
5426
5427                 while (1) {
5428
5429                         /* round robin de-queueing */
5430
5431                         sub = &chan->sub[chan->curr_cable];
5432
5433                         if (sub->write_open) {
5434                                 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX],
5435                                     &buf, 1, &actlen, 0);
5436                         } else {
5437                                 actlen = 0;
5438                         }
5439
5440                         if (actlen) {
5441
5442                                 tr_any = 1;
5443
5444                                 DPRINTF("byte=0x%02x from FIFO %u\n", buf,
5445                                     (unsigned int)chan->curr_cable);
5446
5447                                 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) {
5448
5449                                         DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n",
5450                                             sub->temp_cmd[0], sub->temp_cmd[1],
5451                                             sub->temp_cmd[2], sub->temp_cmd[3]);
5452
5453                                         usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4);
5454
5455                                         nframes++;
5456
5457                                         if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0))
5458                                                 break;
5459                                 } else {
5460                                         continue;
5461                                 }
5462                         }
5463
5464                         chan->curr_cable++;
5465                         if (chan->curr_cable >= chan->max_cable)
5466                                 chan->curr_cable = 0;
5467
5468                         if (chan->curr_cable == start_cable) {
5469                                 if (tr_any == 0)
5470                                         break;
5471                                 tr_any = 0;
5472                         }
5473                 }
5474
5475                 if (nframes != 0) {
5476                         DPRINTF("Transferring %d frames\n", (int)nframes);
5477                         usbd_xfer_set_frame_len(xfer, 0, 4 * nframes);
5478                         usbd_transfer_submit(xfer);
5479                 }
5480                 break;
5481
5482         default:                        /* Error */
5483
5484                 DPRINTF("error=%s\n", usbd_errstr(error));
5485
5486                 if (error != USB_ERR_CANCELLED) {
5487                         /* try to clear stall first */
5488                         usbd_xfer_set_stall(xfer);
5489                         goto tr_setup;
5490                 }
5491                 break;
5492         }
5493 }
5494
5495 static struct umidi_sub_chan *
5496 umidi_sub_by_fifo(struct usb_fifo *fifo)
5497 {
5498         struct umidi_chan *chan = usb_fifo_softc(fifo);
5499         struct umidi_sub_chan *sub;
5500         uint32_t n;
5501
5502         for (n = 0; n < UMIDI_CABLES_MAX; n++) {
5503                 sub = &chan->sub[n];
5504                 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) ||
5505                     (sub->fifo.fp[USB_FIFO_TX] == fifo)) {
5506                         return (sub);
5507                 }
5508         }
5509
5510         panic("%s:%d cannot find usb_fifo!\n",
5511             __FILE__, __LINE__);
5512
5513         return (NULL);
5514 }
5515
5516 static void
5517 umidi_start_read(struct usb_fifo *fifo)
5518 {
5519         struct umidi_chan *chan = usb_fifo_softc(fifo);
5520
5521         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
5522 }
5523
5524 static void
5525 umidi_stop_read(struct usb_fifo *fifo)
5526 {
5527         struct umidi_chan *chan = usb_fifo_softc(fifo);
5528         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5529
5530         DPRINTF("\n");
5531
5532         sub->read_open = 0;
5533
5534         if (--(chan->read_open_refcount) == 0) {
5535                 /*
5536                  * XXX don't stop the read transfer here, hence that causes
5537                  * problems with some MIDI adapters
5538                  */
5539                 DPRINTF("(stopping read transfer)\n");
5540         }
5541 }
5542
5543 static void
5544 umidi_start_write(struct usb_fifo *fifo)
5545 {
5546         struct umidi_chan *chan = usb_fifo_softc(fifo);
5547
5548         usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]);
5549 }
5550
5551 static void
5552 umidi_stop_write(struct usb_fifo *fifo)
5553 {
5554         struct umidi_chan *chan = usb_fifo_softc(fifo);
5555         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5556
5557         DPRINTF("\n");
5558
5559         sub->write_open = 0;
5560
5561         if (--(chan->write_open_refcount) == 0) {
5562                 DPRINTF("(stopping write transfer)\n");
5563                 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]);
5564         }
5565 }
5566
5567 static int
5568 umidi_open(struct usb_fifo *fifo, int fflags)
5569 {
5570         struct umidi_chan *chan = usb_fifo_softc(fifo);
5571         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5572
5573         if (fflags & FREAD) {
5574                 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
5575                         return (ENOMEM);
5576                 }
5577                 mtx_lock(&chan->mtx);
5578                 chan->read_open_refcount++;
5579                 sub->read_open = 1;
5580                 mtx_unlock(&chan->mtx);
5581         }
5582         if (fflags & FWRITE) {
5583                 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
5584                         return (ENOMEM);
5585                 }
5586                 /* clear stall first */
5587                 mtx_lock(&chan->mtx);
5588                 chan->write_open_refcount++;
5589                 sub->write_open = 1;
5590
5591                 /* reset */
5592                 sub->state = UMIDI_ST_UNKNOWN;
5593                 mtx_unlock(&chan->mtx);
5594         }
5595         return (0);                     /* success */
5596 }
5597
5598 static void
5599 umidi_close(struct usb_fifo *fifo, int fflags)
5600 {
5601         if (fflags & FREAD) {
5602                 usb_fifo_free_buffer(fifo);
5603         }
5604         if (fflags & FWRITE) {
5605                 usb_fifo_free_buffer(fifo);
5606         }
5607 }
5608
5609
5610 static int
5611 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data,
5612     int fflags)
5613 {
5614         return (ENODEV);
5615 }
5616
5617 static void
5618 umidi_init(device_t dev)
5619 {
5620         struct uaudio_softc *sc = device_get_softc(dev);
5621         struct umidi_chan *chan = &sc->sc_midi_chan;
5622
5623         mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE);
5624 }
5625
5626 static struct usb_fifo_methods umidi_fifo_methods = {
5627         .f_start_read = &umidi_start_read,
5628         .f_start_write = &umidi_start_write,
5629         .f_stop_read = &umidi_stop_read,
5630         .f_stop_write = &umidi_stop_write,
5631         .f_open = &umidi_open,
5632         .f_close = &umidi_close,
5633         .f_ioctl = &umidi_ioctl,
5634         .basename[0] = "umidi",
5635 };
5636
5637 static int
5638 umidi_probe(device_t dev)
5639 {
5640         struct uaudio_softc *sc = device_get_softc(dev);
5641         struct usb_attach_arg *uaa = device_get_ivars(dev);
5642         struct umidi_chan *chan = &sc->sc_midi_chan;
5643         struct umidi_sub_chan *sub;
5644         int unit = device_get_unit(dev);
5645         int error;
5646         uint32_t n;
5647
5648         if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI))
5649                 chan->single_command = 1;
5650
5651         if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index,
5652             chan->iface_alt_index)) {
5653                 DPRINTF("setting of alternate index failed!\n");
5654                 goto detach;
5655         }
5656         usbd_set_parent_iface(sc->sc_udev, chan->iface_index,
5657             sc->sc_mixer_iface_index);
5658
5659         error = usbd_transfer_setup(uaa->device, &chan->iface_index,
5660             chan->xfer, umidi_config, UMIDI_N_TRANSFER,
5661             chan, &chan->mtx);
5662         if (error) {
5663                 DPRINTF("error=%s\n", usbd_errstr(error));
5664                 goto detach;
5665         }
5666
5667         /*
5668          * Some USB MIDI device makers couldn't resist using
5669          * wMaxPacketSize = 4 for RX and TX BULK endpoints, although
5670          * that size is an unsupported value for FULL speed BULK
5671          * endpoints. The same applies to some HIGH speed MIDI devices
5672          * which are using a wMaxPacketSize different from 512 bytes.
5673          *
5674          * Refer to section 5.8.3 in USB 2.0 PDF: Cite: "All Host
5675          * Controllers are required to have support for 8-, 16-, 32-,
5676          * and 64-byte maximum packet sizes for full-speed bulk
5677          * endpoints and 512 bytes for high-speed bulk endpoints."
5678          */
5679         if (usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER]))
5680                 chan->single_command = 1;
5681
5682         if (chan->single_command != 0)
5683                 device_printf(dev, "Single command MIDI quirk enabled\n");
5684
5685         if ((chan->max_cable > UMIDI_CABLES_MAX) ||
5686             (chan->max_cable == 0)) {
5687                 chan->max_cable = UMIDI_CABLES_MAX;
5688         }
5689
5690         for (n = 0; n < chan->max_cable; n++) {
5691
5692                 sub = &chan->sub[n];
5693
5694                 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
5695                     &umidi_fifo_methods, &sub->fifo, unit, n,
5696                     chan->iface_index,
5697                     UID_ROOT, GID_OPERATOR, 0644);
5698                 if (error) {
5699                         goto detach;
5700                 }
5701         }
5702
5703         mtx_lock(&chan->mtx);
5704
5705         /*
5706          * NOTE: At least one device will not work properly unless the
5707          * BULK IN pipe is open all the time. This might have to do
5708          * about that the internal queues of the device overflow if we
5709          * don't read them regularly.
5710          */
5711         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
5712
5713         mtx_unlock(&chan->mtx);
5714
5715         return (0);                     /* success */
5716
5717 detach:
5718         return (ENXIO);                 /* failure */
5719 }
5720
5721 static int
5722 umidi_detach(device_t dev)
5723 {
5724         struct uaudio_softc *sc = device_get_softc(dev);
5725         struct umidi_chan *chan = &sc->sc_midi_chan;
5726         uint32_t n;
5727
5728         for (n = 0; n < UMIDI_CABLES_MAX; n++) {
5729                 usb_fifo_detach(&chan->sub[n].fifo);
5730         }
5731
5732         mtx_lock(&chan->mtx);
5733
5734         usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]);
5735
5736         mtx_unlock(&chan->mtx);
5737
5738         usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
5739
5740         mtx_destroy(&chan->mtx);
5741
5742         return (0);
5743 }
5744
5745 static void
5746 uaudio_hid_rx_callback(struct usb_xfer *xfer, usb_error_t error)
5747 {
5748         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
5749         const uint8_t *buffer = usbd_xfer_get_frame_buffer(xfer, 0);
5750         struct snd_mixer *m;
5751         uint8_t id;
5752         int actlen;
5753
5754         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
5755
5756         switch (USB_GET_STATE(xfer)) {
5757         case USB_ST_TRANSFERRED:
5758                 DPRINTF("actlen=%d\n", actlen);
5759
5760                 if (actlen != 0 &&
5761                     (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) {
5762                         id = *buffer;
5763                         buffer++;
5764                         actlen--;
5765                 } else {
5766                         id = 0;
5767                 }
5768
5769                 m = sc->sc_mixer_dev;
5770
5771                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) &&
5772                     (sc->sc_hid.mute_id == id) &&
5773                     hid_get_data(buffer, actlen,
5774                     &sc->sc_hid.mute_loc)) {
5775
5776                         DPRINTF("Mute toggle\n");
5777
5778                         mixer_hwvol_mute_locked(m);
5779                 }
5780
5781                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) &&
5782                     (sc->sc_hid.volume_up_id == id) &&
5783                     hid_get_data(buffer, actlen,
5784                     &sc->sc_hid.volume_up_loc)) {
5785
5786                         DPRINTF("Volume Up\n");
5787
5788                         mixer_hwvol_step_locked(m, 1, 1);
5789                 }
5790
5791                 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) &&
5792                     (sc->sc_hid.volume_down_id == id) &&
5793                     hid_get_data(buffer, actlen,
5794                     &sc->sc_hid.volume_down_loc)) {
5795
5796                         DPRINTF("Volume Down\n");
5797
5798                         mixer_hwvol_step_locked(m, -1, -1);
5799                 }
5800
5801         case USB_ST_SETUP:
5802 tr_setup:
5803                 /* check if we can put more data into the FIFO */
5804                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
5805                 usbd_transfer_submit(xfer);
5806                 break;
5807
5808         default:                        /* Error */
5809
5810                 DPRINTF("error=%s\n", usbd_errstr(error));
5811
5812                 if (error != USB_ERR_CANCELLED) {
5813                         /* try to clear stall first */
5814                         usbd_xfer_set_stall(xfer);
5815                         goto tr_setup;
5816                 }
5817                 break;
5818         }
5819 }
5820
5821 static int
5822 uaudio_hid_probe(struct uaudio_softc *sc,
5823     struct usb_attach_arg *uaa)
5824 {
5825         void *d_ptr;
5826         uint32_t flags;
5827         uint16_t d_len;
5828         uint8_t id;
5829         int error;
5830
5831         if (!(sc->sc_hid.flags & UAUDIO_HID_VALID))
5832                 return (-1);
5833
5834         if (sc->sc_mixer_lock == NULL)
5835                 return (-1);
5836
5837         /* Get HID descriptor */
5838         error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
5839             &d_len, M_TEMP, sc->sc_hid.iface_index);
5840
5841         if (error) {
5842                 DPRINTF("error reading report description\n");
5843                 return (-1);
5844         }
5845
5846         /* check if there is an ID byte */
5847         hid_report_size(d_ptr, d_len, hid_input, &id);
5848
5849         if (id != 0)
5850                 sc->sc_hid.flags |= UAUDIO_HID_HAS_ID;
5851
5852         if (hid_locate(d_ptr, d_len,
5853             HID_USAGE2(HUP_CONSUMER, 0xE9 /* Volume Increment */),
5854             hid_input, 0, &sc->sc_hid.volume_up_loc, &flags,
5855             &sc->sc_hid.volume_up_id)) {
5856                 if (flags & HIO_VARIABLE)
5857                         sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP;
5858                 DPRINTFN(1, "Found Volume Up key\n");
5859         }
5860
5861         if (hid_locate(d_ptr, d_len,
5862             HID_USAGE2(HUP_CONSUMER, 0xEA /* Volume Decrement */),
5863             hid_input, 0, &sc->sc_hid.volume_down_loc, &flags,
5864             &sc->sc_hid.volume_down_id)) {
5865                 if (flags & HIO_VARIABLE)
5866                         sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN;
5867                 DPRINTFN(1, "Found Volume Down key\n");
5868         }
5869
5870         if (hid_locate(d_ptr, d_len,
5871             HID_USAGE2(HUP_CONSUMER, 0xE2 /* Mute */),
5872             hid_input, 0, &sc->sc_hid.mute_loc, &flags,
5873             &sc->sc_hid.mute_id)) {
5874                 if (flags & HIO_VARIABLE)
5875                         sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE;
5876                 DPRINTFN(1, "Found Mute key\n");
5877         }
5878
5879         free(d_ptr, M_TEMP);
5880
5881         if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP |
5882             UAUDIO_HID_HAS_VOLUME_DOWN |
5883             UAUDIO_HID_HAS_MUTE))) {
5884                 DPRINTFN(1, "Did not find any volume related keys\n");
5885                 return (-1);
5886         }
5887
5888         /* prevent the uhid driver from attaching */
5889         usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index,
5890             sc->sc_mixer_iface_index);
5891
5892         /* allocate USB transfers */
5893         error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index,
5894             sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER,
5895             sc, sc->sc_mixer_lock);
5896         if (error) {
5897                 DPRINTF("error=%s\n", usbd_errstr(error));
5898                 return (-1);
5899         }
5900         return (0);
5901 }
5902
5903 static void
5904 uaudio_hid_detach(struct uaudio_softc *sc)
5905 {
5906         usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER);
5907 }
5908
5909 DRIVER_MODULE_ORDERED(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0, SI_ORDER_ANY);
5910 MODULE_DEPEND(uaudio, usb, 1, 1, 1);
5911 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
5912 MODULE_VERSION(uaudio, 1);