sys/dev/sound/usb/uaudio.c

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