sys/dev/sound/usb/uaudio.c

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