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