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