sys/dev/sound/usb/uaudio.c

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