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